Erstellen einer CI/CD-Pipeline mit Python und DuckDB

10 Februar 2025 - Veröffentlicht unter Community & Best Practices von schwarer2006

In diesem Blogbeitrag werden wir Schritt für Schritt eine CI/CD-Pipeline (Continuous Integration/Continuous Deployment) mit Python und DuckDB erstellen. DuckDB ist eine leistungsstarke, in-memory OLAP-Datenbank, die sich hervorragend für analytische Workloads eignet. Wir werden eine Pipeline aufbauen, die automatisch Tests durchführt, die Datenbank aktualisiert und bei Bedarf neue Versionen bereitstellt.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie folgende Tools installiert haben:

Python 3.8 oder höher
DuckDB: Installieren Sie DuckDB mit pip install duckdb.
Git: Für die Versionskontrolle.
GitHub Actions oder ein anderer CI/CD-Dienst (z.B. GitLab CI, Jenkins).
Ein GitHub-Repository: Wo wir unseren Code und die Pipeline speichern werden.

Schritt 1: Projektstruktur erstellen

Zuerst erstellen wir eine grundlegende Projektstruktur:

my_duckdb_project/
│
├── .github/
│   └── workflows/
│       └── ci_cd_pipeline.yml
├── src/
│   └── main.py
├── tests/
│   └── test_main.py
├── requirements.txt
└── README.md

.github/workflows/ci_cd_pipeline.yml: Hier definieren wir unsere CI/CD-Pipeline.
src/main.py: Unser Hauptskript, das DuckDB verwendet.
tests/test_main.py: Unit-Tests für unser Skript.
requirements.txt: Liste der Python-Abhängigkeiten.
README.md: Dokumentation des Projekts.

Schritt 2: Python-Skript mit DuckDB erstellen

In src/main.py schreiben wir ein einfaches Python-Skript, das DuckDB verwendet:

import duckdb

def create_table():
    conn = duckdb.connect('my_db.duckdb')
    conn.execute("CREATE TABLE IF NOT EXISTS my_table (id INTEGER, name STRING)")
    conn.close()

def insert_data(id, name):
    conn = duckdb.connect('my_db.duckdb')
    conn.execute(f"INSERT INTO my_table VALUES ({id}, '{name}')")
    conn.close()

def query_data():
    conn = duckdb.connect('my_db.duckdb')
    result = conn.execute("SELECT * FROM my_table").fetchall()
    conn.close()
    return result

if __name__ == "__main__":
    create_table()
    insert_data(1, 'Alice')
    insert_data(2, 'Bob')
    print(query_data())

Dieses Skript erstellt eine Tabelle, fügt Daten ein und gibt die Daten aus der Tabelle zurück.

Schritt 3: Unit-Tests schreiben

In tests/test_main.py schreiben wir Unit-Tests für unser Skript:

import unittest
from src.main import create_table, insert_data, query_data

class TestDuckDB(unittest.TestCase):
    def test_create_table(self):
        create_table()
        # Überprüfen, ob die Tabelle erstellt wurde
        self.assertTrue(True)  # Platzhalter für echte Überprüfung

    def test_insert_data(self):
        insert_data(1, 'Alice')
        data = query_data()
        self.assertIn((1, 'Alice'), data)

if __name__ == "__main__":
    unittest.main()

Schritt 4: Abhängigkeiten festlegen

In requirements.txt listen wir unsere Python-Abhängigkeiten auf:

duckdb==0.5.0

Schritt 5: CI/CD-Pipeline mit GitHub Actions erstellen

In .github/workflows/ci_cd_pipeline.yml definieren wir unsere CI/CD-Pipeline:

name: CI/CD Pipeline for DuckDB Project

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run tests
      run: |
        python -m unittest discover -s tests

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run main script
      run: |
        python src/main.py

Diese Pipeline führt die folgenden Schritte aus:

Test-Job: Führt die Unit-Tests aus, wenn ein Push oder Pull Request auf den main-Branch erfolgt.
Deploy-Job: Führt das Hauptskript aus, wenn die Tests erfolgreich sind.

Schritt 6: Pipeline in Aktion

Sobald Sie den Code in Ihr GitHub-Repository pushen, wird die Pipeline automatisch ausgeführt. Sie können den Fortschritt und die Ergebnisse der Pipeline in der GitHub Actions-Ansicht überprüfen.

Fazit

In diesem Blogbeitrag haben wir eine einfache CI/CD-Pipeline mit Python und DuckDB erstellt. Diese Pipeline führt automatisch Tests durch und stellt bei Erfolg das Skript bereit. Dieses Setup kann je nach Bedarf erweitert werden, z.B. durch das Hinzufügen von Datenbank-Migrationen, weiteren Tests oder Deployment-Schritten.

Nächster Voriger