Kurs
Grundlagen der Softwareentwicklung in Python
4 Std.
69.8K
Stell dir vor, du hast ein End-to-End-Problem im Machine Learning gelöst und die optimale Lösung mit den besten Modellen gefunden. Doch sobald du deinen Code ans Engineering-Team übergibst, läuft er dort nicht — auf ihren Servern mit anderem Betriebssystem und abweichenden Bibliotheksversionen verhält er sich plötzlich anders.
Trotz Sorgfalt und viel Arbeit passiert das leider immer wieder. Fast jede Entwicklerin und jeder Entwickler erlebt das irgendwann. Was also tun? Hier kommt Docker ins Spiel. Mit Docker definierst du eine präzise, konsistente Umgebung für dein Projekt und stellst sicher, dass dein Code zuverlässig läuft — unabhängig von System oder Setup.
Dieses Tutorial führt in Docker und die wichtigsten Konzepte ein und erklärt, warum Docker für Data Scientists relevant ist. Außerdem zeigen wir dir die Installation und wie du Docker in deinem nächsten Projekt praktisch einsetzt. Zum Schluss lernst du bewährte Praktiken aus der Industrie kennen und bekommst Antworten auf häufige Docker-Fragen.
Was sind Docker, Container und Images?
Docker ist eine Plattform zum Erstellen, Ausführen und Ausliefern von Anwendungen.
Container sind leichtgewichtige, eigenständige, ausführbare Pakete, die alles enthalten, was eine Anwendung benötigt: Code, Laufzeit, Bibliotheken, Umgebungsvariablen und Konfigurationsdateien.
Ein Docker Image ist eine schreibgeschützte Vorlage mit allen Anweisungen, um einen Container zu erstellen. Images dienen dazu, zur Laufzeit neue Container zu erzeugen und zu starten.
Docker hilft Entwickelnden, ihre Anwendungen zusammen mit allen Abhängigkeiten in einen Container zu packen, der dann auf jeder Maschine mit installiertem Docker läuft.
Im Grunde ist es, als würdest du für ein neues Projekt eine frische Maschine bekommen: Du installierst die nötigen Pakete, kopierst die benötigten Dateien und startest deine Skripte. Diese „neue Maschine“ kannst du sogar weitergeben. Etwas vereinfacht, aber du siehst, worum es geht.
Worin unterscheiden sich Docker-Container von Virtual Machines?
Nach der Definition von Containern fragst du dich vielleicht, wie sie sich von virtuellen Maschinen unterscheiden — schließlich erlauben beide, mehrere isolierte Umgebungen auf derselben Hardware zu betreiben.
Sieh dir die architektonischen Unterschiede in der Grafik unten an und versuche, die Differenzen zu erkennen.
Bild: Autorin/Autor
Jede virtuelle Maschine ist eine isolierte Umgebung, die eigene Betriebssysteme und Konfigurationen ausführen kann. Das bedeutet aber auch: Jede VM benötigt eine vollständige Kopie des Betriebssystems und verbraucht entsprechend viele Ressourcen. Containerisierte Anwendungen laufen dagegen isoliert, ohne ein komplettes Betriebssystem mitzubringen — das macht sie deutlich schlanker und effizienter.
Virtuelle Maschinen sind nützlich, aber für das Ausliefern von Anwendungen sind Container in der Regel ausreichend und oft ideal.
Warum Docker für Data Scientists?
Vielleicht fragst du dich, warum du dich als Data Scientist mit Docker beschäftigen sollst. Ist dafür nicht das DevOps-Team zuständig?
Gute Frage — aber Docker ist auch mit DevOps-Team extrem wertvoll für Data Scientists. Schauen wir uns an, warum.
Zusammenspiel mit dem DevOps-Team
Ein DevOps-Team macht Docker nicht überflüssig — im Gegenteil, es schließt die Lücke zwischen Entwicklung und Betrieb. Data Scientists können ihren Code mit Docker paketieren und ans DevOps-Team zur Bereitstellung und Skalierung übergeben. In gut strukturierten Data-Science-Teams ist das gängige Praxis.
Konsistente Umgebung und Reproduzierbarkeit
Data Scientists arbeiten oft mit komplexen Abhängigkeiten und Konfigurationen, die eingerichtet und gepflegt werden müssen. Um vergleichbare Ergebnisse zu erzielen, muss die Umgebung stabil bleiben. Mit Docker erstellst und teilst du eine konsistente Umgebung mit allen benötigten Abhängigkeiten und Voreinstellungen, die andere leicht replizieren können.
Portabilität
Docker-Container laufen überall dort, wo Docker installiert ist — auf Laptops, Servern oder in der Cloud. So kannst du deine Arbeit problemlos zwischen Umgebungen verschieben.
Ressourcenisolation
Docker ermöglicht mehrere Container auf derselben Maschine, jeweils mit eigenen isolierten Ressourcen. So nutzt du Hardware effizienter und vermeidest Konflikte mit anderen Anwendungen. Gerade bei mehreren ML-Projekten ist das Gold wert.
Zusammenarbeit erleichtern
Mit Docker teilst du deine Arbeit in Containern schnell mit anderen — auch mit verteilten Teams. Zusammenarbeit ist zentral in Data-Science-Teams, und Docker nimmt hier viel Reibung raus.
Viele erfahrene Data Scientists bestätigen: Mit Docker konzentrierst du dich auf die Arbeit — ohne dir über die zugrunde liegende Infrastruktur den Kopf zu zerbrechen.
Docker-Tutorial: So nutzt du Docker in deinem nächsten Projekt
Da wir den Nutzen von Docker für Data Scientists geklärt haben, legen wir direkt los. Zuerst installieren wir Docker auf unserer Maschine und machen uns mit den gängigen Befehlen vertraut.
Docker auf deiner Maschine oder deinem lokalen Server installieren
Docker gibt es für alle gängigen Betriebssysteme: Linux, Windows und Mac. Die Installation ist unkompliziert und am besten in der offiziellen Dokumentation beschrieben.
- Anleitung zur Installation von Docker für Linux.
- Anleitung zur Installation von Docker für Windows.
- Anleitung zur Installation von Docker für Mac.
Wenn du eigene Images erstellen und auf Docker Hub pushen möchtest (wie in einigen Befehlen unten gezeigt), brauchst du ein Konto bei Docker Hub. Denk an Docker Hub als zentrale Plattform, auf der Entwicklerinnen und Entwickler Docker-Images speichern und teilen.
Sich mit gängigen Docker-Befehlen vertraut machen
Nachdem Docker auf deiner Maschine (oder dem Server) eingerichtet ist, lernst du als Nächstes die wichtigsten Befehle kennen. Hier ist eine Liste aus der offiziellen Docker-Dokumentation.
Für den schnellen Einstieg haben wir die zehn am häufigsten genutzten Docker-Befehle zusammengefasst, auf die du sicher stößt.
- docker run: Startet einen Container aus einem Image. Der Schalter -p mappt einen Port der Hostmaschine auf einen Port im Container. Beispiel: Der folgende Befehl startet einen Container aus dem "nginx"-Image und mappt Port 80 des Hosts auf Port 80 im Container.
docker run -p 80:80 nginx- docker ps: Listet alle laufenden Container auf. Nützlich, wenn mehrere isolierte Container auf derselben Maschine laufen.
docker ps- docker stop: Stoppt einen laufenden Container.
docker stop <container_id>- docker rm: Entfernt einen gestoppten Container.
docker rm <container_id>- docker images: Listet alle Images auf der Hostmaschine auf. Praktisch, um verfügbare lokale Images zu prüfen, bevor du Container daraus startest.
docker images- docker rmi: Entfernt ein Image.
docker rmi <image_id>- docker build: Baut ein Image aus einem Dockerfile. Der Schalter -t vergibt einen Namen, der Punkt am Ende legt den Build-Kontext fest (aktuelles Verzeichnis).
docker build -t my_image .- docker exec: Führt einen Befehl in einem laufenden Container aus.
docker exec -it <container_id> /bin/bash- docker pull: Lädt ein Image aus einer Registry, z. B. von Docker Hub.
docker pull <image_name>- docker push: Lädt ein Image in eine Registry hoch.
docker push <image_name>
Jetzt, da Setup und Basisbefehle sitzen, dockerisieren wir eine Machine-Learning-Anwendung.
Möchtest du dich in Docker zertifizieren lassen? Schau dir unseren Guide zur Docker-Zertifizierung an!
Eine einfache Machine-Learning-Anwendung dockerisieren
Das Dockerisieren einer ML-Anwendung ist einfacher als gedacht, wenn du dich an drei Schritte hältst.
Bild: Autorin/Autor.
Wir bleiben bei einem Einsteiger-Skript, denn es geht darum zu zeigen, wie du ein Skript dockerisierst. Im Beispiel trainieren wir ein einfaches Logistic-Regression-Modell auf dem Iris-Datensatz.
# Load the libraries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# Load the iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Train a logistic regression model
clf = LogisticRegression()
clf.fit(X_train, y_train)
# Make predictions
y_pred = clf.predict(X_test)
# Print the accuracy of the model
accuracy_score = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy_score}')1. Die Umgebung definieren
Um eine Umgebung woanders reproduzieren zu können, musst du sie exakt kennen. Am einfachsten (und am weitesten verbreitet) erstellst du dafür eine requirements.txt, die alle Bibliotheken deines Projekts inklusive Versionen enthält.
So könnte der Inhalt aussehen:
scikit-learn==1.2.0
Hinweis: Eine komplexere ML-Anwendung nutzt weitere Bibliotheken wie NumPy, pandas, matplotlib und andere. Daher ist das Erstellen einer requirements.txt in der Regel sinnvoller, als Bibliotheken einzeln zu installieren (mehr dazu in den Best Practices).
2. Ein Dockerfile schreiben
Als Nächstes erstellst du eine Datei namens Dockerfile, die die Umgebung aufsetzt und deine Anwendung darin ausführt. Einfach gesagt: Es ist die Anleitung für Docker — welche Umgebung, welche Inhalte und welche Schritte zur Ausführung nötig sind.
FROM python:3.9
WORKDIR /src
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python","iris_classification.py"]Dieses Dockerfile verwendet das offizielle Python-Image als Basis, setzt das Arbeitsverzeichnis, kopiert die requirements.txt, installiert die Abhängigkeiten, kopiert den Anwendungscode und startet die Anwendung mit dem Befehl python iris_classification.py.
3. Das Image bauen
Der letzte Schritt zur reproduzierbaren Umgebung ist das Erstellen eines Images (einer Vorlage), aus dem du beliebig viele Container mit identischer Konfiguration starten kannst.
Baue das Image mit docker build -t <image-name> . im Verzeichnis, in dem das Dockerfile liegt.
Nachdem du die Beispielanwendung dockerisiert hast, kannst du sie mit docker run starten, Container erstellen und bei Bedarf wieder stoppen. Einige der wichtigsten Befehle haben wir oben bereits gesehen.
Jetzt heben wir das Wissen von den Grundlagen auf Branchenstandard.
Bewährte Branchenpraktiken für den Einsatz von Docker
Für den Einstieg reichen die Basics. In Projekten solltest du jedoch Best Practices befolgen.
Wenige Layer verwenden
Jede Anweisung im Dockerfile erzeugt einen neuen Layer. Zu viele Layer blähen das Image auf und verlangsamen Transfers.
Sieh dir folgendes Codebeispiel an:
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies
RUN pip install pandas
RUN pip install matplotlib
RUN pip install seaborn
# Copy neccesary files
COPY my_script.py .
COPY data/ .
# Run the script
CMD ["python","my_script.py"]
Was ist hier das Problem? Mehrere RUN- und COPY-Befehle sind unnötig. So lässt es sich verbessern:
# Use the official Python image as the build image
FROM python:3.9
# Install the dependencies using requirements.txt
COPY my_script.py requirements.txt data/ .
RUN pip install --no-cache-dir -r requirements.txt
# Run the script
CMD ["python","my_script.py"]In kleinen Dateien ist es offensichtlich, aber in der Praxis schreiben wir oft unnötig große Dockerfiles. Befehle zu gruppieren, die ähnliche Aufgaben erfüllen oder dieselben Dateien betreffen, reduziert die Layer-Zahl effektiv.
Offizielle Images verwenden
Offizielle Images werden vom jeweiligen Publisher gepflegt und unterstützt. Sie gelten in der Regel als stabiler und sicherer.
Aus Zeitdruck greift man schnell zu inoffiziellen Images. Wann immer möglich, nutze offizielle Images als Basis.
Multi-Stage-Builds zur Performance-Optimierung
Ein Multi-Stage-Build erlaubt mehrere FROM-Anweisungen in einem Dockerfile.
Du kannst ein größeres Image zum Bauen verwenden und anschließend nur die benötigten Dateien in ein kleineres Runtime-Image kopieren. Ohne unnötige Dateien schrumpft die finale Image-Größe — das verbessert nicht nur die Performance, sondern erhöht auch die Sicherheit.
Ein Beispiel, wie es in der Industrie häufig eingesetzt wird:
# Use the official Python image as the build image
FROM python:3.9 AS build
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the application files
COPY . .
# Train the model
RUN python train.py
# Use the official Alpine Linux image as the runtime image
FROM alpine:3
# Set the working directory
WORKDIR /app
# Copy the model files from the build image
COPY --from=build /app/models /app/models
# Copy the requirements.txt file
COPY --from=build /app/requirements.txt /app
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Run the application
CMD ["python","predict.py"]Im Beispiel dient zunächst das offizielle Python-Image als Build-Image, in dem alle Abhängigkeiten installiert werden.
Nach dem Ausführen von train.py kopieren wir die erzeugten Modellausgaben und die requirements.txt in ein kleines Alpine-Linux-Image für die Laufzeit. Indem Build-Abhängigkeiten und der Python-Interpreter nicht im finalen Image landen, wird es deutlich schlanker.
Volumes nutzen, um Daten zu persistieren
Daten in einem Container sind weg, sobald er gestoppt und gelöscht wird. Oft willst du aber Ergebnisse für später sichern oder zwischen mehreren Containern teilen.
Mit einem Volume stellst du sicher, dass Daten außerhalb des Containers erhalten bleiben. So kannst du vorgehen:
# Use the official Python image as the base image
FROM python:3.9
# Set the working directory
WORKDIR /app
# Copy the requirements.txt file
COPY requirements.txt ./
# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt
# Copy the rest of the application files
COPY . .
# Create a directory for storing data
RUN mkdir /app/data
# Define a volume for the data directory
VOLUME /app/data
# Run the application
CMD ["python","main.py"]Docker-Images organisieren und versionieren
Mit mehreren Docker-Images wird es schnell unübersichtlich. Organisationen handhaben das unterschiedlich, aber diese gängigen Praktiken helfen:
- Einheitliche Namenskonvention pro Image. Zum Beispiel <registry>/<organization>/<image>:<version>. So erkennst du Image und Version in der Registry auf einen Blick.
- Saubere Versionierung, um bei Bedarf zurückzurollen. Die Version kann z. B. als <Major>.<Minor>.<Patch> geführt werden und ist Teil der Tag-Struktur.
- Sinnvolle Tags wie latest, staging, production verwenden. So ordnest du Images schnell den jeweiligen Umgebungen und Pipeline-Phasen zu.
Stimme dich mit deinem Unternehmen ab — das gesamte Team sollte dieselbe Konvention nutzen.
Fazit
Dieser Artikel hat gezeigt, wie wichtig reproduzierbare Codes und Anwendungen für Data Scientists sind — und wie Docker dabei unterstützt. Wir sind von der Relevanz von Docker über die Installation bis zu gängigen Befehlen gegangen, haben eine ML-Anwendung dockerisiert und Best Practices aus der Industrie beleuchtet.
Wenn du weitermachen willst, schau dir unseren Introduction to Docker-Kurs an — dort lernst du die wichtigsten Grundlagen. Arbeitest du schon im Feld, könnte auch eine Docker-Zertifizierung spannend sein.
Viele Data Scientists fokussieren sich auf Statistik, Mathematik, Machine Learning, Deep Learning und Programmierung — vergessen aber die Software-Engineering-Praktiken, die in der Industrie erwartet werden.
Wenn du deine Kernkompetenzen in Data Science festigen möchtest, wirf einen Blick auf den Data Scientist with Python-Lernpfad mit praxisnahen Projekten. Oder frische deine Software-Engineering-Skills im Kurs Software Engineering for Data Scientists with Python auf — mit Essentials wie Modularität, Dokumentation und automatisiertem Testen.
