In diesem Artikel werde ich die Installation von dbt mit Docker und PostgreSQL als Datenquelle und Ziel behandeln.

Ich erkläre jeden Schritt so detailliert, dass Sie ihn fehlerfrei reproduzieren können.

Wenn etwas nicht stimmt, teilen Sie es mir bitte mit, damit ich den Inhalt aktualisieren und diese Anleitung so lange wie möglich beibehalten kann

1. Überprüfen Sie die Installation von Docker

Überprüfen Sie zunächst, ob Docker korrekt auf Ihrem Computer installiert ist.

Dazu können Sie die folgenden zwei Befehle eingeben:

docker --version
Docker version 20.10.12, build e91ed57docker-compose --version
Docker Compose version v2.2.3

Wenn dies nicht der Fall ist, installieren Sie am einfachsten Docker Desktop (das auch über eine komfortable grafische Oberfläche verfügt) und installieren Sie die Version, die Ihrem Betriebssystem entspricht.

Ich habe die vorgeschlagenen Manipulationen unter Windows 10, Ubuntu 20.04 und Mac OS X Montery getestet.

2. Erstellen Sie die Docker Compose-Datei

Derzeit (März 2023) gibt es kein offizielles Docker-Rezept zum Einrichten einer lokalen Docker-Umgebung für dbt. Wir müssen uns auf Community-Docker-Images verlassen und unsere Konfiguration erstellen.

Wir verwenden das Docker-Image aus Artikel 1 DataOps Github-Repository [1], wo Sie mehrere Docker-Images finden, die Ihren Anforderungen entsprechen.

Beginnen wir einfach und verwenden das „vollständige“ Image in einer docker-compose.yml -Konfiguration:

version: '3'
services:
  dbt:
    image: article1dataops/dbt:latest
    volumes:
      - .:/usr/app
    ports:
      - "8080:8080"

  # Required for the tutorial
  db:
    image: postgres
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: my_app
    ports:
      - "5432:5432"

Um diesem Tutorial zu folgen, kopieren Sie diese Datei in einen Ordner mit dem Namen dbt_app . Dann können Sie mit einem Terminal den Ask Docker starten, um dbt zu installieren:

docker-compose up

docker ps

error during connect: This error may indicate that the docker daemon is not running.: Get "http://%2F%2F.%2Fpipe%2Fdocker_engine/v1.24/containers/json": open //./pipe/docker_engine: The specified file can't be found.

Schließlich können Sie auch in den Docker Desktop UI-Client schauen: Wenn die Statusleiste grün ist, ist die Engine gestartet und funktioniert wie erwartet!

GRÜN = ✅

Ist das Image einmal installiert, benötigen Sie künftig nur noch die Anweisung docker-compose up „as usual“.

4. Initieren Sie Ihr Projekt: der Befehl dbt init

Jetzt können wir dbt verwenden, um sich selbst mit dem Befehl dbt init zu initialisieren [2]:

docker compose run dbt dbt init --profiles-dir /usr/app

      
                

                    
                    
                
            

# Replace "my_dbt_project" by the name of your dbt project
mv my_dbt_project/* .
rm -r my_dbt_project

5. Richten Sie Ihre Test-PostgreSQL-Datenbank ein

Sie haben vielleicht bemerkt, dass meine Docker-Konfiguration ein Postgres- Image mit einer Datenbank enthält. Obwohl dies nicht erforderlich ist , möchte ich, dass Sie Ansichten und Tabellen aus diesem Tutorial erstellen, wie mit allen anderen Datenbanken, mit denen Sie möglicherweise arbeiten müssen.

Lassen Sie uns zunächst einige Tabellen und Daten zu unserer Datenbank hinzufügen:

docker-compose exec db psql -U postgres -c "CREATE TABLE users(id SERIAL PRIMARY KEY, name VARCHAR(200), city_code VARCHAR(3));" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.users(name, city_code) VALUES('mickael', 'BCN');" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.users(name, city_code) VALUES('timmy', 'MAD');" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.users(name, city_code) VALUES('jeane', 'PAR');" my_app

docker-compose exec db psql -U postgres -c "CREATE TABLE cities(city_code VARCHAR(3), city VARCHAR(200), country VARCHAR(200));" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.cities(city_code, city, country) VALUES('BCN', 'Barcelona', 'Spain');" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.cities(city_code, city, country) VALUES('MAD', 'Madrid', 'Spain');" my_app
docker-compose exec db psql -U postgres -c "INSERT INTO public.cities(city_code, city, country) VALUES('PAR', 'Paris', 'France');" my_app

      
                

                    
                    
                
            

docker-compose exec db psql -U postgres -c "SELECT * FROM users;" my_app

      
                

                    
                    
                
            

Die Konfiguration der Datenquellen muss in der Datei profiles.yml [3] eingerichtet werden .

Da wir bereits PostgreSQL als unser „Data Warehouse“ ausgewählt haben, hat dbt uns ein Template generiert:

# profiles.yml
app:
  outputs:

    dev:
      type: postgres
      threads: [1 or more]
      host: [host]
      port: [port]
      user: [dev_username]
      pass: [dev_password]
      dbname: [dbname]
      schema: [dev_schema]

    prod:
      type: postgres
      threads: [1 or more]
      host: [host]
      port: [port]
      user: [prod_username]
      pass: [prod_password]
      dbname: [dbname]
      schema: [prod_schema]

  target: dev

Die Eigenschaft targetrichtet das Hauptziel ein, wenn Sie es nicht angeben: Wie Sie aus der Datei lesen können, geben wir standardmäßig die dbt-Transformationen an die devKonfiguration aus.

Sie können die erforderlichen Informationen mit den Einstellungen aus der Docker-Konfiguration ausfüllen. Sie können die Anzahl der Threads entsprechend der Leistung Ihres Computers auswählen. Meistens habe ich mich für 4 entschieden:

dev:
      type: postgres
      threads: 4
      host: db
      port: 5432
      user: postgres
      pass: password
      dbname: my_app
      schema: dev

docker compose run dbt dbt run

      
                

                    
                    
                
            

docker-compose exec db psql -U postgres -c "\dt" my_app
docker-compose exec db psql -U postgres -c "\dv" my_app

      
                

                    
                    
                
            

Wenn Sie sich den Code genauer ansehen möchten, können Sie das GitHub-Repository [4] überprüfen, das ich für diesen Artikel erstellt habe.

Fazit: Was hast du gelernt?

• So richten Sie ein dbt-Projekt mit Docker ein;
• So konfigurieren Sie eine Datenquelle für dbt: Hier haben wir eine dockerisierte PostgreSQL-Datenbank verwendet
• Wie man Transformationen in die Datenbank durchführt und prüft, ob es funktioniert.

[1] dbt-Docker-Image

[2] Beispiele für Daten aus der Airbyte-Dokumentation

[3] Postgres-Plugin aus der dbt-Dokumentation

[4] Projekt-Repository auf GitHub

Level-Up-Codierung

Danke, dass Sie ein Teil unserer Community sind! Bevor du gehst:

• Klatsche für die Geschichte und folge dem Autor
• Sehen Sie sich weitere Inhalte in der Level Up Coding-Publikation an
• Kostenloser Kurs für Programmierinterviews ⇒ Kurs anzeigen
• Folge uns: Twitter | LinkedIn | Newsletter