Mise en œuvre d'une couche sémantique avec dbt : Un guide pratique

Apprenez à construire une couche sémantique avec dbt, en transformant les données brutes en mesures cohérentes pour les outils d'analyse et de BI !

Actualisé 23 janv. 2025 · 18 min de lecture

De nombreuses entreprises modernes s'appuient sur des couches sémantiques pour combler le fossé entre les données brutes stockées dans des entrepôts de données tels que Snowflake et les informations contenues dans les tableaux de bord ou les rapports.

Une couche sémantique est une abstraction qui définit des métriques, des mesures et des dimensions cohérentes pour les analyses et les rapports.

Dans ce tutoriel, nous verrons comment mettre en place une couche sémantique en utilisant dbt (data build tool), un cadre populaire de transformation et de modélisation des données. Ce guide contient des exemples pratiques et des idées pour vous aider à maîtriser le concept.

Qu'est-ce qu'une couche sémantique et pourquoi est-elle importante ?

Une couche sémantique traduit les données brutes en mesures et dimensions cohérentes et réutilisables, ce qui simplifie l'analyse des données. Il s'agit d'un outil permettant de maintenir l'uniformité entre les équipes et les outils.

Avantages d'une couche sémantique

Définitions cohérentes des données : Veille à ce que les indicateurs commerciaux tels que le chiffre d'affaires, le taux de désabonnement, la croissance annuelle, la valeur moyenne des commandes, etc. soient définis de manière uniforme. Cela élimine la confusion causée par l'utilisation de définitions incohérentes par différentes équipes et contribue à maintenir la confiance dans les données au sein de l'organisation.
Amélioration de la collaboration : Facilite une meilleure communication et un meilleur alignement entre les équipes techniques et non techniques. En fournissant une couche de données unifiée, les équipes techniques peuvent se concentrer sur l'exactitude des données tandis que les équipes commerciales tirent parti de mesures claires et accessibles pour prendre des décisions stratégiques.
Accélération de la prise de conscience : Réduit l'ambiguïté et permet une prise de décision plus rapide. Grâce à une couche sémantique, les parties prenantes peuvent rapidement accéder à des mesures fiables et les analyser, ce qui réduit le temps consacré au rapprochement des données ou à la résolution des divergences.

Pourquoi dbt est idéal pour construire une couche sémantique

Voyons ce qui fait de dbt l'outil idéal pour permettre aux ingénieurs en données et en analyse de construire une couche sémantique.

Diagramme conceptuel de la couche sémantique de dbt, courtesy of dbt Labs

Modélisation modulaire des données

dbt vous permet de décomposer des transformations de données complexes en modèles modulaires réutilisables. Ces modèles peuvent être hiérarchisés, les modèles de données fondamentaux alimentant des modèles analytiques de niveau supérieur.

Cette approche facilite la maintenance du pipeline et permet aux équipes de collaborer plus efficacement en isolant les changements apportés à des modèles spécifiques sans avoir d'impact sur l'ensemble du système.

Pour en savoir plus sur les concepts fondamentaux de dbt et les meilleures pratiques en matière de modélisation des données, consultez le didacticiel dbt : 7 Concepts incontournables pour les ingénieurs de données. Il offre des perspectives qui complètent les stratégies décrites ici.

Définitions centralisées des mesures

Avec dbt, la logique d'entreprise et les mesures sont définies en un seul endroit, ce qui garantit la cohérence entre les différents outils d'analyse. En utilisant la fonction métrique de dbt, vous pouvez définir des indicateurs clés de performance (KPI) tels que les revenus, les taux de conversion ou le taux de désabonnement une fois pour toutes et les utiliser dans les tableaux de bord, les rapports et les analyses sans avoir à les redéfinir. Cela permet de réduire les divergences et de garantir l'intégrité des données.

Contrôle des versions et documentation

L'intégration de dbtavec Git facilite un contrôle de version robuste, vous permettant de suivre et d'auditer les modifications au fil du temps. Associé à sa documentation auto-générée, dbt crée une référence vivante et accessible pour toutes les transformations de donnéesns et métriques. Cela favorise la transparence et permet aux nouveaux membres de l'équipe de s'intégrer rapidement en explorant le pipeline de données documenté.

Intégration avec les outils de BI

dbt fonctionne avec des plateformes de BI telles que Looker, Tableau et Mode, ce qui permet d'intégrer la couche sémantique dans les outils de visualisation. En utilisant les expositions dbt, vous pouvez relier directement les modèles dbt aux tableaux de bord BI, garantissant ainsi que toute mise à jour des modèles de données est reflétée dans les analyses sans intervention manuelle.

Devenez ingénieur en données

Devenez un ingénieur de données grâce à l'apprentissage avancé de Python

Commencez à apprendre gratuitement

Mise en place de votre projet dbt

Habituellement, dbt se place au-dessus d'entrepôts de données dans le cloudcomme Snowflake ou Google BigQuery. Cependant, pour simplifier les choses dans ce tutoriel, nous nous connecterons localement à une base de données DuckDB .

1. Conditions préalables

Installez Python sur votre machine si ce n'est pas déjà fait.

2. Installation des outils nécessaires

Utilisez pip pour installer le CLI dbt :

pip install dbt-core

Installez DuckDB via pip :

pip install duckdb

Installez l'adaptateur DuckDB via pip :

pip install dbt-duckdb

3. Initialisation du projet dbt

Créez un nouveau projet dbt :

dbt init project_name

Cette commande créera un projet dans votre répertoire actuel, qui ressemblera à ceci :

project_name/
├── analyses/
├── logs/
├── macros/
├── models/
├── seeds/
├── snapshots/
├── tests/
├── .gitignore
├── dbt_project.yml

4. Configuration de la connexion DuckDB

Modifiez le fichier profiles.yml, généralement situé dans le dossier ~/.dbt/. S'il n'existe pas, créez-en un :

project_name:  # This matches the name in dbt_project.yml file
  target: dev
  outputs:
    dev:
      type: duckdb
      path: path/to/demo_database.duckdb  
      threads: 1

L'adresse profiles.yml contient le pointeur vers l'emplacement du fichier de base de données .duckdb, que vous devez indiquer dans l'adresse path.

Vous pouvez créer une nouvelle base de données ou télécharger un petit échantillon à partir d' ici. Dans la section suivante, j'utiliserai le fichier duckdb-demo.duckdb provenant de la même source .

Pour créer un nouveau fichier de base de données duckDB, exécutez simplement ce qui suit :

import duckdb
duckdb.connect('/path/to/your/duckdb/database.duckdb')

5. Test de la connexion

Nous pouvons maintenant tester en lançant dbt debug pour vérifier que tout fonctionne. Assurez-vous d'être dans le dossier du projet avant d'exécuter la commande :

cd /path/to/your/project/
dbt debug

Si tout est mis en place correctement, vous obtiendrez quelque chose comme ceci en retour (tous les chemins sont expurgés pour des raisons de confidentialité) :

15:20:00  Running with dbt=1.9.1
15:20:00  dbt version: 1.9.1
15:20:00  python version: 3.11.5
15:20:00  python path: ...
15:20:00  os info: Windows-10-10.0.22631-SP0
15:20:00  Using profiles dir at ....
15:20:00  Using profiles.yml file at ...
15:20:00  Using dbt_project.yml file at ...
15:20:00  adapter type: duckdb
15:20:00  adapter version: 1.9.1
15:20:00  Configuration:
15:20:00    profiles.yml file [OK found and valid]
15:20:00    dbt_project.yml file [OK found and valid]
15:20:00  Required dependencies:
15:20:00   - git [OK found]

15:20:00  Connection:
15:20:00    database: demo_database
15:20:00    schema: main
15:20:00    path: ...
15:20:00    config_options: None
15:20:00    extensions: None
15:20:00    settings: {}
15:20:00    external_root: .
15:20:00    use_credential_provider: None
15:20:00    attach: None
15:20:00    filesystems: None
15:20:00    remote: None
15:20:00    plugins: None
15:20:00    disable_transactions: False
15:20:00  Registered adapter: duckdb=1.9.1
15:20:01    Connection test: [OK connection ok]

Créer une couche sémantique avec dbt

Félicitations pour avoir réussi à aller aussi loin ! Vous avez réussi à mettre en place votre premier projet dbt.

Voyons maintenant comment créer une couche sémantique au-dessus d'une base de données. Pour ce faire, vouspouvez soit importer vos propres données à partir d'un fichier CSV dans DuckDB, soit télécharger un petit fichier de base de données (5 Mo) à partir d'ici.

Ensuite, nous pouvons écrire un simple script Python pour explorer ce que contient ce fichier de base de données :

import duckdb

# Connect to the database
conn = duckdb.connect("duckdb-demo.duckdb")

# Get list of tables
tables = conn.execute(
    "SELECT table_name FROM information_schema.tables WHERE table_schema='main'"
).fetchall()

print(f"\nNumber of tables in database: {len(tables)}")

print("Table names:")
for t in tables:
    print(f"- {t[0]}")

print("\nTables in database:")
for table in tables:
    print(f"- {table[0]}")

    # Get schema for each table
    schema = conn.execute(f"DESCRIBE {table[0]}").fetchall()
    print("\nSchema:")
    for col in schema:
        print(f"  {col[0]}: {col[1]}")

    # Preview data
    data = conn.execute(f"SELECT * FROM {table[0]} LIMIT 5").fetchall()
    print("\nFirst 5 rows:")
    for row in data:
        print(f"  {row}")
    print("\n---")

# Close connection
conn.close()

Sortie (tronquée par souci de concision) :

Number of tables in database: 17
Table names:
- bank_failures
- boxplot
- calendar
- ...

Tables in database:
- bank_failures

Schema:
  c1: BIGINT
  Bank: VARCHAR
  City: VARCHAR
  State: VARCHAR
  Date: DATE
  Acquired by: VARCHAR
  Assets ($mil.): DOUBLE

First 5 rows:
  (1, 'Douglass National Bank', 'Kansas City', 'Missouri', datetime.date(2008, 1, 25), 'Liberty Bank and Trust', 58.5)
  (2, 'Hume Bank', 'Hume', 'Missouri', datetime.date(2008, 3, 7), 'Security Bank', 18.7)
...
…

Cette base de données comporte 17 tableaux. Toutefois, nous n'utiliserons que le tableau bank_failures pour ce tutoriel. Ce tableau contient les données financières historiques des banques en faillite aux États-Unis.

1. Définition des modèles SQL

Les modèles SQL sont la base de tout projet de dbt. Ils représentent les transformations structurées de données brutes dans un format plus analytique.

Pour ce tutoriel, nous définirons deux fichiers SQL dans le dossier models/.

Créez un nouveau fichier dans le dossier models de votre projet, nommé base_bank_failures.sql:

SELECT *
FROM bank_failures

Ce fichier extrait directement les données brutes du tableau bank_failures. Il sert de modèle de base, auquel les modèles suivants peuvent se référer.

Ensuite, créez un autre fichier nommé clean_bank_failures.sql:

SELECT
    State,
    COUNT(*) AS total_failures,
    SUM("Assets ($mil.)" ) AS total_assets
FROM
    {{ ref('base_bank_failures') }}
GROUP BY
    State

Ce fichier s'appuie sur le modèle base_bank_failures (à l'aide de la fonction ref() ) pour agréger et nettoyer les données et les préparer à l'analyse. Il résume le nombre total de faillites et d'actifs par État.

2. Création d'un fichier metrics.yml

Le fichier metrics.yml définit des mesures centralisées et réutilisables qui garantissent la cohérence des analyses et des tableaux de bord.

Dans notre cas, il décrira des mesures telles que total_assets et avg_assets_per_failure, les rendant disponibles pour une utilisation dans des outils de BI et d'autres requêtes :

version: 2
models:
  - name: clean_bank_failures
    description: "Aggregated data about bank failures."
    columns:
      - name: State
        tests:
          - unique
      - name: "Assets ($mil.)"
    metrics:
      - name: total_assets
        label: Total Assets
        type: sum
        expression: "Assets ($mil.)"
        description: "Total assets of failed banks, aggregated by state."

      - name: avg_assets_per_failure
        label: Average Assets per Failure
        type: average
        expression: "Assets ($mil.)"
        description: "Average assets for each bank failure."

3. Création d'un fichier exposures.yml

Le fichier exposures.yml relie vos modèles dbt à des outils externes tels que Tableau ou Looker. Il documente ces connexions, assurant ainsi la traçabilité et la cohérence.

Ce fichier indique que le modèle clean_bank_failures est utilisé dans un tableau de bord Tableau, en fournissant des détails sur le propriétaire et la dépendance :

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Data Team
      email: datateam@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')

Construire et tester la couche sémantique

Pour valider et construire avec succès votre projet dbt, voici quelques commandes utiles que vous pouvez utiliser :

1. Construisez les modèles : Exécutez la commande dbt build pour matérialiser tous les modèles, appliquer les tests et exécuter les semences et les instantanés. Cette commande combine les fonctionnalités de dbt run et dbt test:

dbt build

2. Testez les modèles : Si vous souhaitez uniquement valider vos données par des tests après la construction, utilisez la commande dbt test. Cela garantit que tous les tests de qualité des données (par exemple, les contrôles d'unicité et d'absence de nullité) sont appliqués à vos modèles.

dbt test

3. Exécuter des modèles ou des tests spécifiques : Pour n'exécuter que des modèles ou des tests spécifiques, indiquez leurs noms en tant qu'arguments. Par exemple, pour exécuter un seul modèle :

dbt run --select clean_bank_failures

Pour tester une colonne spécifique :

dbt test --select clean_bank_failures.State

Intégrer la couche sémantique aux outils de BI

Pour connecter dbt à des outils de BI tels que Looker ou Tableau, suivez les étapes suivantes pour exposer efficacement la couche sémantique et vous assurer que les outils de BI peuvent référencer directement les modèles et les métriques de dbt :

1. Permettre les expositions dans la dbt

Dans votre projet dbt, créez un fichier exposures.yml dans le dossier models, qui ressemble à ceci :

exposures:
  - name: tableau_dashboard
    type: dashboard
    url: https://tableau.yourcompany.com/workbook
    owner:
      name: Your Name
      email: email@yourcompany.com
    depends_on:
      - ref('clean_bank_failures')

2. Préparation de la connexion à la base de données

Assurez-vous que les modèles de données transformés sont disponibles dans votre base de données (par exemple, Snowflake, BigQuery, DuckDB).
Exécutez dbt build pour matérialiser les modèles dbt dans la base de données.

3. Connecter Tableau aux modèles dbt

Ouvrez Tableau Desktop et créez une nouvelle connexion à votre base de données.
Sélectionnez le schéma dans lequel les modèles dbt sont stockés.
Glissez-déposez les modèles dbt (par exemple, clean_bank_failures) sur l'espace de travail Tableau.

4. Définir des métriques dans Tableau

Dans Tableau, utilisez les mesures définies par dbt, telles que total_assets ou avg_assets_per_failure, directement dans vos visualisations pour garantir la cohérence.
Créez des champs calculés si nécessaire pour améliorer les visualisations.

5. Connecter Looker aux modèles dbt

Dans Looker, accédez au panneau d'administration et établissez une connexion avec votre base de données.
Créez une vue LookML pour chaque modèle dbt en important le schéma et les champs.
Utilisez les paramètres total_assets ou avg_assets_per_failure définis dans dbt pour créer des explorations et des tableaux de bord Looker cohérents.

Bonnes pratiques pour la mise en œuvre d'une couche sémantique avec dbt

Maintenant que vous avez une vue d'ensemble des étapes de la construction d'une couche sémantique avec dbt, passons en revue quelques bonnes pratiques.

Centraliser la logique d'entreprise

Définir toutes les règles de gestion dans la base de données afin de garantir la cohérence et la maintenabilité. En centralisant la logique d'entreprise, vous éliminez les définitions redondantes d'un outil à l'autre, créant ainsi une source unique de vérité que toutes les parties prenantes peuvent facilement mettre à jour et comprendre.

Modulariser les modèles

Diviser les transformations en composants logiques et réutilisables. Par exemple, créez des modèles de base pour les données brutes, des modèles intermédiaires pour les données nettoyées et transformées, et des modèles finaux pour les données prêtes à être analysées.

Cette structure modulaire simplifie le dépannage, favorise la réutilisation du code et permet la collaboration entre les membres de l'équipe qui peuvent travailler sur des composants individuels sans perturber l'ensemble du pipeline.

Tout documenter

Tirez parti de la documentation automatisée de dbt pour maintenir votre couche sémantique bien organisée et transparente.

Utilisez les descriptions dans les fichiers YAML pour fournir des explications claires sur les modèles, les métriques et les colonnes.

Mettez régulièrement à jour la documentation pour refléter les changements et utilisez les graphiques de lignage générés automatiquement par dbt pour visualiser les relations entre les modèles. Cela garantit que la couche sémantique reste accessible et facile à parcourir pour tous les utilisateurs.

Des outils tels que le paquet dbt-utils peuvent considérablement rationaliser vos flux de travail dbt, en fournissant des macros et des utilitaires prédéfinis qui simplifient le développement de modèles et garantissent une documentation complète.

Conclusion

La mise en œuvre d'une couche sémantique avec dbt est une approche puissante pour combler le fossé entre les données brutes et les informations exploitables. La modélisation modulaire des données de dbt, les définitions centralisées des métriques, le contrôle robuste des versions et l'intégration avec les outils BI peuvent vous aider à garantir des données cohérentes, fiables et accessibles pour l'analyse et le reporting.

Ce tutoriel vous a guidé dans la mise en place d'un projet dbt, la création de modèles SQL, la définition de métriques réutilisables et l'intégration de la couche sémantique avec des outils de visualisation tels que Tableau et Looker.

Pour en savoir plus sur la dbt, consultez l'excellent cours Introduction à la dbt!