Wie man eine Anwendung mit Docker containerisiert

Da Anwendungen für maschinelles Lernen immer komplexer werden, geht es bei der Überführung unserer maschinellen Lernmodelle von der Entwicklung in die Produktion nicht nur darum, guten Code zu schreiben. Es geht darum, dass unsere Anwendung in verschiedenen Umgebungen konsistent läuft. Hier kommt die Containerisierung ins Spiel. Aber was genau ist die Containerisierung und warum ist sie ein entscheidender Faktor für maschinelle Lernabläufe?

Die Containerisierung ist eine leichtgewichtige, portable Methode, um eine Anwendung zusammen mit all ihren Abhängigkeiten, Bibliotheken und Konfigurationen in eine einzige Einheit, einen Container, zu packen. Anders als herkömmliche virtuelle Maschinen (VMs) teilen sich Container das Betriebssystem des Hostsystems, was sie schneller, effizienter und einfacher skalierbar macht. 

Für Datenwissenschaftler und ML-Ingenieure bedeutet dies, dass du ein Modell auf deinem lokalen Rechner erstellen und es überall einsetzen kannst, sei es auf einer Cloud-Plattform, einem Server oder sogar auf dem Laptop eines Kollegen, ohne dich um Kompatibilitätsprobleme kümmern zu müssen.

In diesem Tutorial werden wir uns die Containerisierung einer Machine Learning-Anwendung mit Docker und Kubernetes ansehen. Am Ende wirst du wissen, wie es geht:

1. Erstelle einen Docker-Container für deine ML-Anwendung.
2. Implementiere und verwalte deine containerisierte Anwendung mit Kubernetes.
3. Skaliere und überwache deine ML-Anwendung in einer Produktionsumgebung.

Wenn du neu bei Docker bist, schau dir unseren Leitfaden an Wie du Docker von Grund auf lernst. Du kannst auch unseren Kurs besuchen, Containerisierung und Virtualisierung mit Docker und Kubernetes.

Voraussetzungen

Bevor du einsteigst, solltest du ein grundlegendes Verständnis von Python, maschinellen Lernabläufen und der Arbeit mit der Kommandozeile haben. Vertrautheit mit Docker-Konzepten (z. B. Images, Container, grundlegende Befehle) wird empfohlen, und Grundkenntnisse über Kubernetes sind optional, aber hilfreich für den Einsatz und die Skalierung.

Was ist eine containerisierte Anwendung?

Eine containerisierte Anwendung ist eine Softwareanwendung, die mit all ihren Abhängigkeiten, Bibliotheken und Konfigurationen in einer einzigen, leichtgewichtigen Einheit, einem Container, verpackt ist. Für Anwendungen des maschinellen Lernens bedeutet dies, dass du alles - vom trainierten Modell bis hin zu den Python-Bibliotheken, von denen es abhängt - in Pakete packen musst, damit deine Anwendung überall auf die gleiche Weise läuft.

Traditionelle Anwendung versus containerisierte Anwendung

Warum Containerisierung für Machine Learning-Anwendungen wichtig ist

Wenn du Anwendungen für maschinelles Lernen entwickelst, bist du wahrscheinlich schon einmal auf das Problem gestoßen, dass "es auf meinem Rechner funktioniert". Vielleicht läuft dein Modell auf deinem Laptop einwandfrei, schlägt aber fehl, wenn du es in die Cloud stellst, oder ein Kollege kann deine Ergebnisse nicht reproduzieren, weil er eine andere Version von Scikit-Learn oder TensorFlow installiert hat. 

Die Containerisierung löst diese Probleme, indem sie eine konsistente, isolierte Umgebung für deine Anwendung schafft. Hier erfährst du, warum containerisierte Anwendungen besser für maschinelles Lernen geeignet sind:

1. Konsistenz: Deine Anwendung verhält sich in verschiedenen Umgebungen gleich - von der Entwicklung über die Tests bis zur Produktion.
2. Isolation: Jeder Container läuft in seiner eigenen Umgebung, wodurch Konflikte zwischen verschiedenen Anwendungen oder Abhängigkeiten vermieden werden.
3. Tragbarkeit: Container können auf jeder Plattform laufen, die Containerisierung unterstützt, egal ob es sich um deinen lokalen Rechner, einen Cloud-Service oder einen Server vor Ort handelt.
4. Skalierbarkeit: Du musst mehr Anfragen bearbeiten? Mit Containern kannst du deine Anwendung einfach horizontal skalieren, indem du mehrere Instanzen laufen lässt.

Container vs. virtuelle Maschinen

Obwohl sowohl Container als auch virtuelle Maschinen (VMs) zur Isolierung von Anwendungen verwendet werden, unterscheiden sie sich erheblich in ihrer Funktionsweise und ihren Anwendungsfällen. Hier findest du eine Übersicht über die wichtigsten Unterschiede und Vorteile:

Für Anwendungen des maschinellen Lernens sind diese Unterschiede wichtig. Wenn du dein Modell skalieren musst, um mehr Vorhersagen zu verarbeiten, oder wenn du mehrere Versionen deines Modells für A/B-Tests einsetzen willst, bieten Container die Flexibilität und Ressourceneffizienz, die du brauchst.

Wenn du mehr über Containerisierung und Virtualisierung erfahren möchtest, schau dir diesen Lernpfad an: Containerisierung und Virtualisierung mit Docker und Kubernetes.

Wie man eine Machine Learning Anwendung containerisiert 

In den folgenden Abschnitten haben wir eine Schritt-für-Schritt-Anleitung für die Containerisierung einer Anwendung erstellt: 

1. Einrichten deiner Umgebung

Bevor wir mit der Containerisierung unserer Machine-Learning-Anwendung beginnen, müssen wir die notwendigen Tools einrichten und unsere Umgebung vorbereiten. Dieser Abschnitt führt dich durch die Installation von Docker und die Vorbereitung einer einfachen Machine Learning-Anwendung für die Containerisierung.

Werkzeuge, die du brauchst

Um eine Machine-Learning-Anwendung zu containerisieren, brauchst du die folgenden Tools:

1. Docker: Eine Plattform für Bau, Versand und Betrieb von Containern.
2. Kubernetes (optional): Ein Orchestrierungswerkzeug für die Verwaltung von Containern im großen Maßstab. (Darauf gehen wir später im Lernprogramm ein).

Beginnen wir mit der Installation von Docker.

Schritt 1: Docker installieren

Docker ist für Windows, macOS und Linux verfügbar. Nachfolgend findest du die Schritte zur Installation von Docker auf deinem System.

Für Windows/macOS:

1. Besuchen Sie die Docker-Website.
2. Lade Docker Desktop herunter und installiere es.
3. Befolge die Installationsanweisungen des Installateurs.

Für Linux (Ubuntu/Debian):

Öffne dein Terminal und führe die folgenden Befehle aus, um Docker zu installieren:

# Update your package list
sudo apt-get update

# Install required packages to allow apt to use a repository over HTTPS
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Add Docker’s official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the Docker repository to your system
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update your package list again
sudo apt-get update

# Install Docker
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Verify Docker installation
sudo docker --version

Dieser Installationsprozess fügt das Docker-Repository zu deinem System hinzu, verifiziert seine Authentizität mit dem GPG-Schlüssel und installiert die Docker-Engine sowie die dazugehörigen Kommandozeilen-Tools.

Schritt 2: Überprüfe die Docker-Installation 

Sobald Docker installiert ist, überprüfe, ob es richtig funktioniert, indem du den folgenden Befehl in der Eingabeaufforderung ausführst:

# Check Docker version
docker --version

# Run hello-world container
docker run hello-world

Dies zieht ein leichtgewichtiges Test-Image und führt es als Container aus. Wenn die Installation erfolgreich war, siehst du eine Willkommensnachricht, die bestätigt, dass deine Installation ordnungsgemäß funktioniert (siehe unten):

Hello from Docker!

2. Vorbereitung deiner Anwendung für maschinelles Lernen

Jetzt, wo Docker installiert ist, wollen wir eine einfache Machine Learning-Anwendung für die Containerisierung vorbereiten. In diesem Tutorial verwenden wir ein einfaches Python-Skript, das ein vortrainiertes Modell lädt und Vorhersagen über eine Flask-API liefert.

Schritt 1: Eine einfache ML-Anwendung erstellen

Erstelle ein neues Verzeichnis für dein Projekt und füge die folgenden Dateien hinzu:

1. app.py: Ein Python-Skript, das Vorhersagen über eine Flask-API liefert.
2. requirements.txt: Eine Datei, in der die Python-Abhängigkeiten aufgelistet sind.

Hier ist der Code für app.py:

# Import required libraries
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from flask import Flask, request, jsonify
import numpy as np

# Initialize Flask app
app = Flask(__name__)

# Load and prepare the model
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

@app.route('/predict', methods=['POST'])
def predict():
    # Get features from request
    features = request.json['features']
    
    # Make prediction
    prediction = model.predict([features])
    
    return jsonify({'prediction': int(prediction[0]),
                   'class_name': iris.target_names[prediction[0]]})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Der Code lädt den Iris-Datensatz, trainiert einen Random Forest Klassifikatorund richtet einen Flask-API-Endpunkt ein, der Merkmalswerte annimmt und Vorhersagen zurückgibt. Wir bauen dies als Webservice auf, um es für die Containerisierung geeignet zu machen.

Schritt 2: erstellen requirements.txt

Die Dateirequirements.txt listet die Python-Bibliotheken auf, die für die Ausführung des Skripts benötigt werden. Erstelle diese Datei in demselben Verzeichnis wie app.py:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
flask==2.0.1

Hier werden die genauen Versionen der Python-Pakete angegeben, die unsere Anwendung benötigt. Feste Versionen stellen sicher, dass unsere containerisierte Anwendung konsistent und reproduzierbar ist.

Jetzt, da unsere Umgebung eingerichtet und unsere ML-Anwendung fertig ist, können wir mit dem Bau unseres ersten Docker-Containers fortfahren. Im nächsten Abschnitt werden wir eine Dockerfile schreiben und ein Docker-Image für unsere Flask-basierte ML-Anwendung erstellen.

3. Baue deinen ersten Docker-Container

Jetzt, wo unsere Lernanwendung fertig ist, muss sie im nächsten Schritt mit Docker containerisiert werden. Dazu musst du ein Dockerfile erstellen. Das ist ein Skript, das Anweisungen zum Erstellen eines Docker-Images enthält. Sobald das Image erstellt ist, können wir es als Container ausführen.

Dockerfile Beispiel: Eine Dockerdatei schreiben

Ein Dockerfile ist ein Textdokument, das alle Befehle enthält, um ein Bild zusammenzusetzen. Hier erfährst du, wie wir eine solche für unsere Flask-basierte ML-Anwendung erstellen.

1. In demselben Verzeichnis wie app.py und requirements.txterstellst du eine neue Datei mit dem Namen Dockerfile (ohne Dateierweiterung).
2. Füge den folgenden Inhalt in die Dockerfile:

# Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code into the container
COPY . .

# Expose port 5000 for the Flask app
EXPOSE 5000

# Define the command to run the Flask app
CMD ["python", "app.py"]

Erläuterung:

• FROM python:3.9-slim: Wir verwenden das offizielle Python 3.9 slim Image als Basis-Image. Die schlanke Version ist leicht und ideal für den Einsatz in Containern.
• WORKDIR /app: Damit wird das Arbeitsverzeichnis innerhalb des Containers auf /app gesetzt. Alle nachfolgenden Befehle werden von diesem Verzeichnis aus ausgeführt.
• COPY requirements.txt .: Kopiert die Datei requirements.txt von deinem lokalen Rechner in den Container.
• RUN pip install --no-cache-dir -r requirements.txt: Installiert die Python-Abhängigkeiten, die in requirements.txt aufgeführt sind. Das --no-cache-dir Flag reduziert die Bildgröße, indem der Cache nicht gespeichert wird.
• COPY . .: Kopiert alle Dateien aus dem aktuellen Verzeichnis auf deinem lokalen Rechner in das Verzeichnis /app im Container.
• EXPOSE 5000: Zeigt Port 5000 an, auf dem unsere Flask-App lauscht.
• CMD ["python", "app.py"]: Legt den Befehl fest, mit dem die Flask-App beim Start des Containers ausgeführt wird.

Erstellen und Testen des Docker-Images

Mit dem Dockerfile können wir nun das Docker-Image erstellen und als Container ausführen. 

Schritt 1: Erstelle das Docker-Image

Führe den folgenden Befehl im Terminal aus, um das Docker-Image zu erstellen:

docker build -t ml-flask-app .

Mit diesem Befehl wird ein Docker-Image aus der Dockerdatei im aktuellen Verzeichnis erstellt. Das Flag -t ml-flask-app versieht das Bild mit dem Namen ml-flask-app, damit es später leichter referenziert werden kann.

Schritt 2: Starte den Docker-Container

Sobald das Image erstellt ist, führe es mit folgendem Befehl als Container aus:

docker run -p 5000:5000 ml-flask-app

Dieser Befehl startet einen Container aus dem ml-flask-app Image. Das -p 5000:5000 Flag ordnet Port 5000 auf deinem lokalen Rechner dem Port 5000 im Container zu, so dass du über deinen Browser oder ein Tool wie curl auf die Flask-App zugreifen kannst .

Schritt 3: Teste die containerisierte Anwendung

Öffne ein neues Terminalfenster und sende eine Testanfrage an die Flask-App, die im Container läuft:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' http://localhost:5000/predict

Du solltest eine Antwort wie diese sehen:

{
  "prediction": 0
}

Das bedeutet, dass die containerisierte Flask-App erfolgreich läuft und bereit ist, Vorhersagen zu treffen.

Fehlersuche bei allgemeinen Problemen

Wenn du beim Bau oder Betrieb des Containers auf Probleme stößt, findest du hier einige Tipps, die dir bei der Fehlersuche helfen:

Überprüfe die Docker-Logs:Verwende den folgenden Befehl, um die Logs eines laufenden Containers einzusehen:

docker logs <container_id>

Überprüfe die Syntax der Dockerdatei:Überprüfe die Dockerdatei doppelt auf Tipp- oder Syntaxfehler.

Überprüfe Portkonflikte:Vergewissere dich, dass Port 5000 auf deinem lokalen Rechner nicht bereits in Gebrauch ist. Wenn das der Fall ist, kannst du den Container einem anderen Port zuordnen, etwa so:

docker run -p 5001:5000 ml-flask-app

Baue das Bild wieder auf:

Wenn du Änderungen an der Dockerdatei oder am Anwendungscode vornimmst, musst du das Image neu erstellen:

docker build -t ml-flask-app .

Nachdem wir unseren Docker-Container erfolgreich gebaut und getestet haben, müssen wir im nächsten Schritt lernen, wie wir die containerisierte Anwendung verwalten und skalieren können. Im nächsten Abschnitt erfahren wir, wie wir Kubernetes für die Bereitstellung und Skalierung unserer ML-Anwendung nutzen können.

Weitere Docker-Projekte findest du in unserem Leitfaden 10 Ideen für Docker-Projekte: Von Anfängern bis zu Fortgeschrittenen.

Deine containerisierte Anwendung ausführen

Nachdem wir nun unseren Docker-Container gebaut haben, wollen wir uns ansehen, wie wir ihn effektiv verwalten können. In diesem Abschnitt lernst du die wichtigsten Docker-Befehle zum Starten, Stoppen und Überprüfen von Containern sowie die Arbeit mit Logs und Ports kennen.

Docker zur Verwaltung von Containern verwenden

Docker bietet eine Reihe von leistungsstarken Befehlen, um Container zu verwalten. Schauen wir uns die am häufigsten verwendeten an.

Einen Container starten

Um einen Container aus einem Image zu starten, verwende den Befehldocker run. Zum Beispiel:

docker run -p 5000:5000 ml-flask-app

Dieser Befehl startet einen Container aus dem ml-flask-app Image und ordnet Port 5000 auf deinem lokalen Rechner dem Port 5000 im Container zu.

Wenn Sie den Container im Hintergrund laufen lassen wollen (detached mode), fügen Sie das -d Flagge hinzu:

docker run -d -p 5000:5000 ml-flask-app

So kann der Container im Hintergrund laufen und du hast mehr Zeit für dein Terminal.

Anhalten eines Containers

Um einen laufenden Container zu stoppen, musst du zuerst seine Container-ID finden:

docker ps

Hier werden alle laufenden Container mit ihren IDs, Namen und anderen Details aufgelistet. Sobald du die Container-ID hast, halte den Container mit an:

docker stop <container_id>

Zum Beispiel:

docker stop a1b2c3d4e5f6

Inspektion eines Containers

Um detaillierte Informationen über einen Container anzuzeigen, verwendest du den docker inspect Befehl:

docker inspect <container_id>

Dies liefert eine JSON-Ausgabe mit Details wie den Netzwerkeinstellungen des Containers, gemounteten Volumes und Umgebungsvariablen.

Listing Container

Um alle Container (sowohl laufende als auch gestoppte) zu sehen, verwende:

docker ps -a

Dies ist nützlich, um den Status deiner Container zu überprüfen und Container-IDs zu finden.

Arbeiten mit Logs und Ports

Logs und Ports sind entscheidend für das Debugging und den Zugriff auf unsere containerisierte Anwendung. Lass uns herausfinden, wie du mit ihnen arbeiten kannst.

Einsicht in die Containerprotokolle

Um die Logs eines laufenden Containers einzusehen, verwende:

docker logs <container_id>

Zum Beispiel:

docker logs a1b2c3d4e5f6

Hier wird die Ausgabe deiner Anwendung angezeigt, einschließlich aller Fehler oder Meldungen, die auf der Konsole ausgegeben werden. Wenn du die Logs in Echtzeit verfolgen willst (wie tail -f ), füge das Flag-f hinzu :

docker logs -f <container_id>

Mapping-Ports

Wenn du einen Container ausführst, kannst du die Container-Ports mit dem Flag-p auf deinen lokalen Rechner abbilden . Zum Beispiel:

docker run -p 5000:5000 ml-flask-app

Dadurch wird Port 5000 im Container auf Port 5000 auf deinem lokalen Rechner abgebildet. Wenn Port 5000 bereits verwendet wird, kannst du ihn wie folgt einem anderen Port zuordnen:

docker run -p 5001:5000 ml-flask-app

Jetzt wird deine Flask-App unter http://localhost:5001 zugänglich sein.

Überprüfen von Port-Bindungen

Um zu sehen, welche Ports einem laufenden Container zugewiesen sind, verwende:

docker port <container_id>

Hier werden die Port-Zuordnungen für den Container aufgelistet, was bei der Fehlersuche bei Verbindungsproblemen hilfreich ist. Im nächsten Abschnitt schauen wir uns an, wie wir unsere containerisierte ML-Anwendung auf Kubernetes bereitstellen und in großem Umfang verwalten können.

Skalierung mit Kubernetes

Sobald unsere Anwendung containerisiert ist, können wir sie mit Kubernetes. Kubernetes automatisiert die Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen und erleichtert so die Handhabung großer Arbeitslasten. In diesem Abschnitt schauen wir uns an, wie wir unsere ML-Anwendung in einem Kubernetes-Cluster bereitstellen.

Einsatz von Containern in Kubernetes

Kubernetes verwendet YAML-Dateien, um den gewünschten Zustand deiner Anwendung zu definieren. Diese Dateien beschreiben, wie deine Container eingesetzt, skaliert und verwaltet werden sollen. Beginnen wir damit, ein Kubernetes-Deployment für unsere Flask-basierte ML-Anwendung zu erstellen.

Schritt 1: Schreibe eine Kubernetes Deployment YAML-Datei

Erstelle eine Datei namens ml-flask-app-deployment.yaml mit dem folgenden Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-flask-app
  template:
    metadata:
      labels:
        app: ml-flask-app
    spec:
      containers:
      - name: ml-flask-app
        image: ml-flask-app
        ports:
        - containerPort: 5000

Diese YAML-Datei definiert:

• Ein Einsatz namens ml-flask-app.
• Drei Replikate der Anwendung, die eine hohe Verfügbarkeit gewährleisten.
• Ein Container, der das ml-flask-app Image, das wir zuvor erstellt haben.
• Ein ContainerPort von 5000, der der Port ist, auf dem unsere Flask-App lauscht.

Schritt 2: Die Anwendung bereitstellen

Um die Anwendung in Kubernetes einzusetzen, verwenden Sie den kubectl apply Befehl:

kubectl apply -f ml-flask-app-deployment.yaml

Mit diesem Befehl wird Kubernetes angewiesen, die in der YAML-Datei definierten Ressourcen zu erstellen. Du kannst den Status der Bereitstellung mit überprüfen:

kubectl get deployments

Hier wird der Status deines Einsatzes angezeigt, einschließlich der Anzahl der laufenden Replikate.

Schritt 3: Die Anwendung freigeben

Um die Anwendung außerhalb des Kubernetes-Clusters zugänglich zu machen, erstellst du einen Service. Erstelle eine Datei namens ml-flask-app-service.yaml mit dem folgenden Inhalt:

apiVersion: v1
kind: Service
metadata:
  name: ml-flask-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: ml-flask-app

Diese YAML-Datei definiert:

• Ein Dienst namens ml-flask-app-service.
• Ein LoadBalancer-Typ, der die Anwendung dem Internet aussetzt.
• Ein Mapping von Port 80 (extern) auf Port 5000 (intern).

Wende den Dienst mit an:

kubectl apply -f ml-flask-app-service.yaml

Du kannst den Status des Dienstes mit überprüfen:

kubectl get services

Hier wird die externe IP-Adresse angezeigt, über die deine Anwendung erreichbar ist.

Skalierung und Überwachung

Kubernetes macht es einfach, deine Anwendung zu skalieren und ihre Leistung zu überwachen. Lass uns herausfinden, wie man das macht.

Skalierung der Anwendung

Um deine Anwendung zu skalieren, aktualisiere die Anzahl der Replikate in der Bereitstellung. Um zum Beispiel auf 5 Replikate zu skalieren, führe aus:

kubectl scale deployment ml-flask-app --replicas=5

Du kannst auch das replicas Feld in der YAML-Datei aktualisieren und es erneut anwenden:

spec:
  replicas: 5

Dann lauf:

kubectl apply -f ml-flask-app-deployment.yaml

Überwachung der Anwendung

Kubernetes bietet verschiedene Tools zur Überwachung unserer Anwendung. Schauen wir uns einige der Tools an, mit denen wir unsere Anwendung überwachen können.

Verwenden Sie kubectl logs um die Logs eines bestimmten Pods anzuzeigen:

kubectl logs <pod_name>
 

Verwende kubectl get pods kannst du den Status deiner Pods überprüfen:

kubectl get pods

Verwende kubectl top, um die CPU- und Speichernutzung anzuzeigen:

kubectl top pods

Autoskalierung

Kubernetes unterstützt auch den Horizontal Pod Autoscaler (HPA), der die Anzahl der Pods automatisch anhand der CPU- oder Speichernutzung skaliert. Um die automatische Skalierung zu aktivieren, führe aus:

kubectl autoscale deployment ml-flask-app --cpu-percent=50 --min=3 --max=10

Dadurch wird sichergestellt, dass der Einsatz je nach CPU-Auslastung zwischen 3 und 10 Replikaten skaliert.

Bewährte Praktiken für Kubernetes-Einsätze

Hier sind einige Best Practices, die du bei der Bereitstellung von Anwendungen in Kubernetes beachten solltest.

Ressourcengrenzen nutzen

Definiere CPU- und Speicherlimits für deine Container, um eine Erschöpfung der Ressourcen zu verhindern:

resources:
   limits:
     cpu: "1"
     memory: "512Mi"

Aktivitäts- und Bereitschaftstests verwenden

Füge Gesundheitsprüfungen hinzu, um sicherzustellen, dass deine Anwendung korrekt läuft:

livenessProbe:
  httpGet:
    path: /health
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
   

Namespaces verwenden

Organisiere deine Ressourcen mit Namespaces, um Konflikte zu vermeiden:

kubectl create namespace ml-app
kubectl apply -f ml-flask-app-deployment.yaml -n ml-app

Im nächsten Abschnitt werden wir Tipps zur Optimierung von Dockerdateien, zur Verwaltung von Abhängigkeiten und zur Gewährleistung der Sicherheit geben.

Best Practices für die Containerisierung von ML-Anwendungen

Die Containerisierung von Machine-Learning-Anwendungen bringt eine Reihe von Herausforderungen mit sich, z. B. die Verwaltung großer Abhängigkeiten, die Gewährleistung der Reproduzierbarkeit und die Aufrechterhaltung der Sicherheit. Hier sind einige Best Practices, die dir helfen, diese Herausforderungen zu meistern und robuste containerisierte ML-Anwendungen zu entwickeln.

Dockerdateien optimieren

Ein gut optimiertes Dockerfile kann die Erstellungszeit und die Größe des Images erheblich reduzieren. Hier sind einige Tipps, um deine Dockerdateien zu optimieren:

Verwende mehrstufige Builds

Mehrstufige Builds ermöglichen es uns, mehrere FROM Anweisungen in einem einzigen Dockerfile zu verwenden. Dies trägt dazu bei, die endgültige Bildgröße zu reduzieren, indem unnötige Dateien und Abhängigkeiten aus Zwischenstufen verworfen werden. Zum Beispiel:

# Stage 1: Build the application
FROM python:3.9-slim as builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt

COPY . .

# Stage 2: Create the final image
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app .

ENV PATH=/root/.local/bin:$PATH
EXPOSE 5000
CMD ["python", "app.py"]

Dieses Dockerfile:

• Verwendet eine builder Stufe, um Abhängigkeiten zu installieren und die Anwendung zu erstellen.
• Kopiert nur die notwendigen Dateien (z. B. installierte Abhängigkeiten und Anwendungscode) in das endgültige Image und reduziert so dessen Größe.

Schichten minimieren

Jede Anweisung in einem Dockerfile erzeugt eine neue Schicht. Um die Anzahl der Ebenen zu minimieren und die Bildgröße zu verringern:

• Kombinieren Sie mehrere RUN Befehle zu einem einzigen Befehl mit &&.
• Verwenden Sie COPY anstelle von ADD es sei denn, du brauchst die zusätzlichen Funktionen von ADD.

Zum Beispiel:

RUN apt-get update && \
    apt-get install -y --no-install-recommends build-essential && \
    rm -rf /var/lib/apt/lists/*

Leichtgewichtige Basisbilder verwenden

Wähle leichte Basisbilder wie python:3.9-slim anstelle von größeren Bildern wie python:3.9. Schlanke Bilder enthalten nur die wichtigsten Pakete, wodurch die Gesamtgröße des Bildes reduziert wird.

Abhängigkeiten und Reproduzierbarkeit verwalten

Die Reproduzierbarkeit ist bei maschinellen Lernabläufen entscheidend. Hier erfährst du, wie du Abhängigkeiten verwaltest und die Reproduzierbarkeit in deinen containerisierten Anwendungen sicherstellst.

Anforderungen.txt oder pipen verwenden

Listen Sie alle Ihre Python-Abhängigkeiten in einer requirements.txt Datei auf oder verwenden Sie pipenv, um sie zu verwalten. Zum Beispiel:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Installiere die Abhängigkeiten in deinem Dockerfile:

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Versionen der Pin-Abhängigkeit

Halte immer die Versionen deiner Abhängigkeiten fest, um unerwartete Änderungen zu vermeiden. Zum Beispiel:

scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Umgebungsvariablen für die Konfiguration verwenden

Verwende Umgebungsvariablen, um die Anwendung zu konfigurieren, anstatt Werte fest zu codieren. Dadurch wird dein Container flexibler und lässt sich leichter in verschiedenen Umgebungen konfigurieren. Zum Beispiel:

ENV MODEL_PATH=/app/models/model.pkl

Dann greifst du in deiner Anwendung auf die Umgebungsvariable zu:

import os
model_path = os.getenv('MODEL_PATH')

Sicherheitsüberlegungen

Sicherheit ist ein entscheidender Aspekt von containerisierten Anwendungen. Hier sind einige Best Practices zur Sicherung deiner ML-Anwendungen:

Vermeide es, als root zu laufen

Der Betrieb von Containern als root Benutzer kann dein System Sicherheitsrisiken aussetzen. Erstelle stattdessen einen Nicht-Root-Benutzer und führe den Container als diesen Benutzer aus. Zum Beispiel:

# Create a non-root user
RUN useradd -m myuser

# Switch to the non-root user
USER myuser

# Set the working directory
WORKDIR /home/myuser/app

# Copy the application code
COPY --chown=myuser:myuser . .

# Run the application
CMD ["python", "app.py"]

Bilder auf Schwachstellen scannen

Verwende Tools wie Trivy oder Clair, um deine Docker-Images auf Schwachstellen zu überprüfen. Zum Beispiel, um ein Bild mit Trivy zu scannen:

trivy image ml-flask-app

Geheimnisse sicher verwalten

Codiere niemals sensible Informationen wie API-Schlüssel oder Datenbankanmeldeinformationen in deinem Dockerfile oder Anwendungscode. Verwende stattdessen Kubernetes Secrets oder Docker Secrets, um sensible Daten zu verwalten. Zum Beispiel in Kubernetes:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  api_key: <base64-encoded-api-key>

Dann bindest du das Geheimnis als Umgebungsvariable in dein Deployment ein:

env:
- name: API_KEY
  valueFrom:
    secretKeyRef:
      name: my-secret
      key: api_key

Testen und Fehlersuche

Testen und Debuggen sind wichtig, um sicherzustellen, dass deine containerisierte Anwendung wie erwartet funktioniert. Hier sind einige Tipps:

Lokal testen

Bevor du deinen Container in Kubernetes bereitstellst, solltest du ihn lokal mit Docker testen. Zum Beispiel:

docker run -p 5000:5000 ml-flask-app

Logs für die Fehlersuche verwenden

Verwende docker logs oder kubectl logs, um Probleme in deiner containerisierten Anwendung zu debuggen. Zum Beispiel:

docker logs <container_id>
kubectl logs <pod_name>

Testen automatisieren

Nutze CI/CD-Pipelines, um das Testen und die Bereitstellung deiner containerisierten Anwendungen zu automatisieren. Tools wie GitHub Actions, GitLab CI oder Jenkins können uns helfen, automatisierte Arbeitsabläufe einzurichten.

Wenn wir diese Best Practices befolgen, können wir effiziente, reproduzierbare und sichere containerisierte Machine-Learning-Anwendungen erstellen. Von der Optimierung von Dockerdateien über die Verwaltung von Abhängigkeiten bis hin zur Gewährleistung der Sicherheit - diese Strategien werden uns helfen, unsere ML-Workflows zu optimieren und Modelle zuverlässig einzusetzen.

Fazit

Die Containerisierung von Anwendungen für maschinelles Lernen mit Docker und Kubernetes rationalisiert die Bereitstellung, gewährleistet Reproduzierbarkeit und verbessert die Skalierbarkeit. Wenn wir Best Practices wie die Optimierung von Dockerdateien, die Verwaltung von Abhängigkeiten und die Priorisierung von Sicherheit befolgen, können wir robuste, effiziente und sichere ML-Workflows aufbauen.

Wenn du mehr über Containerisierung erfahren und deine Workflows für maschinelles Lernen verbessern willst, dann schau dir diese Kurse an:

• Einführung in den Docker-Kurs
• Docker-Kurs für Fortgeschrittene
• Einführung in Kubernetes Kurs
• Docker für Data Science: Eine Einführung
• Werde ein Machine Learning Scientist in Python
• Grundlagen des maschinellen Lernens in Python Lernpfad