Implementierung einer semantischen Schicht mit dbt: Ein praktischer Leitfaden

Dein dbt-Projekt einrichten

Normalerweise wird dbt auf Cloud Data Warehouseswie Snowflake oder Google BigQuery aufgesetzt. Um die Dinge für dieses Tutorial einfach zu halten, werden wir uns lokal mit einer DuckDB-Datenbank verbinden.

1. Voraussetzungen

• Installiere Python auf deinem Rechner, wenn es noch nicht installiert ist.

2. Installieren der notwendigen Werkzeuge

Verwende pip, um die dbt CLI zu installieren:

pip install dbt-core

Installiere DuckDB über pip:

pip install duckdb

Installiere den DuckDB-Adapter über pip:

pip install dbt-duckdb

3. Initialisierung des dbt-Projekts

Erstelle ein neues dbt-Projekt:

dbt init project_name

Mit diesem Befehl wird ein Projekt in deinem aktuellen Verzeichnis erstellt, das wie folgt aussieht:

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

4. Einrichten der DuckDB-Verbindung

Bearbeite die Datei profiles.yml, die sich normalerweise im Ordner ~/.dbt/ befindet. Wenn sie nicht existiert, erstelle eine:

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

Die profiles.yml enthält den Zeiger auf den Speicherort der .duckdb Datenbankdatei, die du in der path angeben solltest. 

Du kannst entweder eine neue Datenbank erstellen oder eine kleine Beispieldatenbank von hierherunterladen. Im nächsten Abschnitt werde ich die Datei duckdb-demo.duckdb aus derselben Quelle verwenden .

Um eine neue duckDB-Datenbankdatei zu erstellen, führe einfach Folgendes aus:

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

5. Testen der Verbindung

Jetzt können wir testen, ob alles funktioniert, indem wir dbt debug ausführen. Stelle sicher, dass du dich im Projektordner befindest, bevor du den Befehl ausführst:

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

Wenn alles richtig eingestellt ist, bekommst du etwa so etwas zurück (alle Pfade sind aus Datenschutzgründen geschwärzt):

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]

Einen semantischen Layer mit dbt erstellen

Glückwunsch, dass du es so weit geschafft hast! Du hast dein erstes dbt-Projekt erfolgreich aufgesetzt.

Sehen wir uns nun an, wie man eine semantische Schicht auf einer Datenbank erstellt. Um das zu tun, kannst duentweder deine eigenen Daten von CSV in DuckDB importieren oder eine kleine (5MB) Beispieldatenbankdatei von hier herunterladen.

Dann können wir ein einfaches Python-Skript schreiben, um zu erkunden, was diese Datenbankdatei enthält:

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()

Ausgabe (der Kürze halber gekürzt):

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)
...
…

Diese Datenbank hat 17 Tabellen. Für diesen Lehrgang werden wir jedoch nur die Tabelle bank_failures verwenden. Diese Tabelle enthält historische Finanzdaten von gescheiterten Banken in den USA.

1. Definieren der SQL-Modelle

SQL-Modelle sind die Grundlage für jedes dbt-Projekt. Sie stellen die strukturierte Umwandlung von Rohdaten in ein analytischeres Format dar. 

Für diesen Lehrgang werden wir zwei SQL-Dateien im Ordner models/ definieren. 

Erstelle eine neue Datei im Ordner models deines Projekts mit dem Namen base_bank_failures.sql:

SELECT *
FROM bank_failures

Diese Datei bezieht die Rohdaten direkt aus der Tabelle bank_failures. Es dient als Basismodell, auf das sich nachfolgende Modelle beziehen können.

Danach erstellst du eine weitere Datei namens clean_bank_failures.sql:

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

Diese Datei baut auf dem Modell base_bank_failures auf (mit der Funktion ref() ), um die Daten zu aggregieren und zu bereinigen und sie für die Analyse vorzubereiten. Sie fasst die Gesamtausfälle und Vermögenswerte nach Bundesländern zusammen.

2. Erstellen einer metrics.yml-Datei

Die Datei metrics.yml definiert zentrale, wiederverwendbare Metriken, die die Konsistenz von Analysen und Dashboards sicherstellen.

In unserem Fall werden Metriken wie total_assets und avg_assets_per_failure beschrieben, damit sie in BI-Tools und anderen Abfragen verwendet werden können:

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. Erstellen einer exposures.yml-Datei

Die Datei exposures.yml verbindet deine dbt-Modelle mit externen Tools wie Tableau oder Looker. Sie dokumentiert diese Verbindungen und sorgt so für Nachvollziehbarkeit und Konsistenz.

Diese Datei gibt an, dass das Modell clean_bank_failures in einem Tableau-Dashboard verwendet wird, und liefert Details über den Eigentümer und die Abhängigkeit:

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')

Aufbau und Test der semantischen Schicht

Um dein dbt-Projekt erfolgreich zu validieren und zu bauen, findest du hier einige nützliche Befehle, die du verwenden kannst:

1. Baue die Modelle: Führe den Befehl dbt build aus, um alle Modelle zu materialisieren, Tests anzuwenden und Seeds und Snapshots auszuführen. Dieser Befehl kombiniert die Funktionalitäten von dbt run und dbt test:

dbt build

2. Teste die Modelle: Wenn du deine Daten erst nach der Erstellung mit Tests überprüfen willst, verwende den Befehl dbt test. So wird sichergestellt, dass alle Datenqualitätstests (z. B. Eindeutigkeits- und Nicht-Null-Prüfungen) auf deine Modelle angewendet werden.

dbt test

3. Führe bestimmte Modelle oder Tests durch: Wenn du nur bestimmte Modelle oder Tests ausführen willst, gib ihre Namen als Argumente an. Zum Beispiel, um ein einzelnes Modell auszuführen:

dbt run --select clean_bank_failures

Um eine bestimmte Spalte zu testen:

dbt test --select clean_bank_failures.State

Die Integration der semantischen Schicht mit BI-Tools

Um dbt mit BI-Tools wie Looker oder Tableau zu verbinden, befolgst du die folgenden Schritte, um die semantische Schicht effektiv darzustellen und sicherzustellen, dass die BI-Tools direkt auf dbt-Modelle und -Metriken verweisen können:

1. Freigabe von Expositionen im dbt

Erstelle in deinem dbt-Projekt eine Datei exposures.yml im Ordner models, die wie folgt aussieht:

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. Vorbereiten deiner Datenbankverbindung

• Stelle sicher, dass die umgewandelten Datenmodelle in deiner Datenbank (z. B. Snowflake, BigQuery, DuckDB) verfügbar sind.
• Führe dbt build aus, um die dbt-Modelle in der Datenbank zu materialisieren.

3. Tableau mit dbt-Modellen verbinden

• Öffne Tableau Desktop und erstelle eine neue Verbindung zu deiner Datenbank.
• Wähle das Schema aus, in dem die dbt-Modelle gespeichert sind.
• Ziehe die dbt-Modelle (z.B. clean_bank_failures) auf den Tableau-Arbeitsbereich und lege sie dort ab.

4. Definieren von Metriken in Tableau

• In Tableau solltest du die von dbt definierten Metriken wie total_assets oder avg_assets_per_failure direkt in deinen Visualisierungen verwenden, um die Konsistenz zu gewährleisten.
• Erstelle bei Bedarf berechnete Felder, um die Visualisierungen zu verbessern.

5. Verbindung von Looker mit dbt-Modellen

• Navigiere in Looker zum Verwaltungsbereich und richte eine Verbindung zu deiner Datenbank ein.
• Erstelle eine LookML-Ansicht für jedes dbt-Modell, indem du das Schema und die Felder importierst.
• Verwende die in dbt definierten total_assets oder avg_assets_per_failure Metriken, um konsistente Looker Explores und Dashboards zu erstellen.

Best Practices für die Implementierung einer semantischen Schicht mit dbt

Nachdem du nun einen Überblick über die Schritte zum Aufbau einer semantischen Schicht mit dbt hast, wollen wir uns einige Best Practices ansehen. 

Geschäftslogik zentralisieren

Definiere alle Geschäftsregeln in dbt, um Konsistenz und Wartbarkeit zu gewährleisten. Indem du die Geschäftslogik zentralisierst, vermeidest du redundante Definitionen in verschiedenen Tools und schaffst eine einzige Quelle der Wahrheit, die alle Beteiligten leicht aktualisieren und verstehen können. 

Modelle modularisieren

Unterteile Transformationen in logische, wiederverwendbare Komponenten. Erstelle zum Beispiel Basismodelle für Rohdaten, Zwischenmodelle für bereinigte und transformierte Daten und endgültige Modelle für auswertbare Daten. 

Diese modulare Struktur vereinfacht die Fehlersuche, fördert die Wiederverwendung von Code und ermöglicht die Zusammenarbeit zwischen Teammitgliedern, die an einzelnen Komponenten arbeiten können, ohne die gesamte Pipeline zu unterbrechen.

Alles dokumentieren

Nutze die automatische Dokumentation von dbt, um deine semantische Schicht übersichtlich und transparent zu halten. 

Verwende Beschreibungen in YAML-Dateien, um klare Erklärungen für Modelle, Metriken und Spalten zu liefern. 

Aktualisiere die Dokumentation regelmäßig, um Änderungen widerzuspiegeln, und verwende die von dbt automatisch generierten Abstammungsdiagramme, um die Beziehungen zwischen den Modellen zu visualisieren. So wird sichergestellt, dass die semantische Ebene für alle Nutzer zugänglich und leicht zu navigieren ist.

Werkzeuge wie das dbt-utils-Paket können deine dbt-Arbeitsabläufe erheblich rationalisieren. Sie bieten vorgefertigte Makros und Dienstprogramme, die die Modellentwicklung vereinfachen und eine gründliche Dokumentation sicherstellen.

Fazit

Die modulare Datenmodellierung von dbt, die zentrale Definition von Kennzahlen, die robuste Versionskontrolle und die Integration mit BI-Tools helfen dir, konsistente, zuverlässige und zugängliche Daten für Analysen und Berichte zu gewährleisten.

Dieses Tutorial hat dich durch die Einrichtung eines dbt-Projekts, die Erstellung von SQL-Modellen, die Definition wiederverwendbarer Metriken und die Integration der semantischen Schicht mit Visualisierungstools wie Tableau und Looker geführt.

Um mehr über dbt zu erfahren, schau dir den hervorragenden Kurs Einführung in dbt an!