Direkt zum Inhalt

Implementierung einer semantischen Schicht mit dbt: Ein praktischer Leitfaden

Lerne, wie du mit dbt eine semantische Schicht aufbaust, die Rohdaten in konsistente Metriken für Analyse- und BI-Tools verwandelt!
Aktualisierte 23. Jan. 2025  · 18 Min. Lesezeit

Viele moderne Unternehmen verlassen sich auf semantische Schichten, um die Lücke zwischen den in Data Warehouses wie Snowflake gespeicherten Rohdaten und den Erkenntnissen in Dashboards oder Berichten zu schließen. 

Eine semantische Ebene ist eine Abstraktion, die konsistente Metriken, Kennzahlen und Dimensionen für Analysen und Berichte definiert.

In diesem Tutorial wird gezeigt, wie man eine semantische Schicht mit dbt (data build tool), einem beliebten Framework zur Datentransformation und -modellierung, implementiert. Dieser Leitfaden enthält praktische Beispiele und Erkenntnisse, die dir helfen, das Konzept zu beherrschen.

Was ist eine semantische Schicht und warum ist sie wichtig?

Eine semantische Ebene übersetzt Rohdaten in konsistente, wiederverwendbare Metriken und Dimensionen und vereinfacht so die Datenanalyse. Es ist ein Werkzeug, um die Einheitlichkeit zwischen Teams und Tools zu wahren.

Vorteile einer semantischen Ebene

  • Konsistente Datendefinitionen: Stellt sicher, dass Geschäftskennzahlen wie Umsatz, Abwanderungsrate, jährliches Wachstum, durchschnittlicher Auftragswert usw. einheitlich definiert sind. Dadurch wird Verwirrung vermieden, die dadurch entsteht, dass verschiedene Teams widersprüchliche Definitionen verwenden, und das Vertrauen in die Daten im gesamten Unternehmen erhalten.
  • Verbesserte Zusammenarbeit: Ermöglicht eine bessere Kommunikation und Abstimmung zwischen technischen und nicht-technischen Teams. Durch die Bereitstellung einer einheitlichen Datenebene können sich die technischen Teams auf die Datengenauigkeit konzentrieren, während die Geschäftsteams klare und zugängliche Metriken für strategische Entscheidungen nutzen.
  • Verkürzte Zeit bis zur Einsicht: Reduziert Unklarheiten und ermöglicht schnellere Entscheidungen. Mit einer semantischen Ebene können die Beteiligten schnell auf verlässliche Kennzahlen zugreifen und diese analysieren, wodurch der Zeitaufwand für den Datenabgleich oder die Behebung von Diskrepanzen minimiert wird.

Warum dbt ideal für den Aufbau einer semantischen Schicht ist

Sehen wir uns an, was dbt zum perfekten Werkzeug macht, um Daten- und Analytikingenieuren den Aufbau einer semantischen Schicht zu ermöglichen.

Ein Bildschirmfoto zeigt die Architektur der Modellierung mit dbt

Konzeptdiagramm des dbt Semantic Layer, mitrtesy of dbt Labs

Modulare Datenmodellierung

dbt ermöglicht es dir, komplexe Datentransformationen in wiederverwendbare, modulare Modelle zu zerlegen. Diese Modelle können hierarchisch geschichtet werden, wobei die grundlegenden Datenmodelle in die übergeordneten analytischen Modelle einfließen. 

Dieser Ansatz macht die Pipeline wartbar und ermöglicht es den Teams, effektiver zusammenzuarbeiten, indem Änderungen an bestimmten Modellen isoliert werden, ohne das gesamte System zu beeinflussen.

Wenn du mehr über die grundlegenden Konzepte und Best Practices von dbt für die Datenmodellierung erfahren möchtest, schau dir das dbt Tutorial an: 7 wichtige Konzepte für Dateningenieure. Sie bietet Einblicke, die die hier dargestellten Strategien ergänzen.

Zentralisierte Metrikdefinitionen

Mit dbt werden Geschäftslogik und Metriken an einer Stelle definiert, um die Konsistenz zwischen verschiedenen Analysetools zu gewährleisten. Mit der dbt-Metrikenfunktion kannst du KPIs wie Umsatz, Konversionsraten oder Abwanderung einmal definieren und sie ohne Neudefinition in Dashboards, Berichten und Analysen verwenden. Dadurch werden Unstimmigkeiten reduziert und die Datenintegrität sichergestellt.

Versionskontrolle und Dokumentation

Die Integration von dbtin Git ermöglicht eine robuste Versionskontrolle, mit der du Änderungen im Laufe der Zeit verfolgen und überprüfen kannst. Zusammen mit der automatisch generierten Dokumentation schafft dbt eine lebendige, zugängliche Referenz für alle Datentransformations und Metriken. Das schafft Transparenz und ermöglicht es neuen Teammitgliedern, sich schnell einzuarbeiten, indem sie die dokumentierte Datenpipeline erkunden.

Integration mit BI-Tools

dbt arbeitet mit BI-Plattformen wie Looker, Tableau und Mode zusammen und ermöglicht die Integration der semantischen Ebene in Visualisierungstools. Mit dbt exposures kannst du dbt-Modelle direkt mit BI-Dashboards verknüpfen und so sicherstellen, dass alle Aktualisierungen in den Datenmodellen ohne manuelle Eingriffe in die Analysen übernommen werden.

Werde Dateningenieur

Werde ein Dateningenieur durch fortgeschrittenes Python-Lernen
Kostenloses Lernen beginnen

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!

Werde Dateningenieur

Beweise deine Fähigkeiten als einsatzbereiter Datentechniker.

Moez Ali's photo
Author
Moez Ali
LinkedIn
Twitter

Datenwissenschaftler, Gründer und Schöpfer von PyCaret

Themen

Lerne mehr über Data Engineering mit diesen Kursen!

Zertifizierung verfügbar

Kurs

Einführung in die Datentechnik

4 hr
116K
In diesem kurzen Kurs lernst du die Welt des Data Engineering kennen und erfährst mehr über Tools und Themen wie ETL und Cloud Computing.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow
Verwandt

Der Blog

Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Bist du gerade auf der Suche nach einem Job, der Snowflake nutzt? Bereite dich mit diesen 20 besten Snowflake-Interview-Fragen vor, damit du den Job bekommst!
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 Min.

Der Blog

Lehrer/innen und Schüler/innen erhalten das Premium DataCamp kostenlos für ihre gesamte akademische Laufbahn

Keine Hacks, keine Tricks. Schüler/innen und Lehrer/innen, lest weiter, um zu erfahren, wie ihr die Datenerziehung, die euch zusteht, kostenlos bekommen könnt.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

4 Min.

Der Blog

Top 30 Generative KI Interview Fragen und Antworten für 2024

Dieser Blog bietet eine umfassende Sammlung von Fragen und Antworten zu generativen KI-Interviews, die von grundlegenden Konzepten bis hin zu fortgeschrittenen Themen reichen.
Hesam Sheikh Hassani's photo

Hesam Sheikh Hassani

15 Min.

Der Blog

Die 32 besten AWS-Interview-Fragen und Antworten für 2024

Ein kompletter Leitfaden zur Erkundung der grundlegenden, mittleren und fortgeschrittenen AWS-Interview-Fragen, zusammen mit Fragen, die auf realen Situationen basieren. Es deckt alle Bereiche ab und sorgt so für eine abgerundete Vorbereitungsstrategie.
Zoumana Keita 's photo

Zoumana Keita

30 Min.

Der Blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates hat im zweiten Quartal 2023 über 20.000 Stipendien an unsere gemeinnützigen Partner vergeben. Erfahre, wie fleißige benachteiligte Lernende diese Chancen in lebensverändernde berufliche Erfolge verwandelt haben.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

Der Blog

2022-2023 DataCamp Classrooms Jahresbericht

Zu Beginn des neuen Schuljahres ist DataCamp Classrooms motivierter denn je, das Lernen mit Daten zu demokratisieren. In den letzten 12 Monaten sind über 7.650 neue Klassenzimmer hinzugekommen.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 Min.

Mehr anzeigenMehr anzeigen