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.