Python-Anwendung in einem Docker-Container ausführen

Einführung

Docker hat die Softwareentwicklung revolutioniert, indem Entwickler ihre Anwendungen und Abhängigkeiten in tragbare, selbstkonsistente Einheiten, sogenannte Container, verpacken können. In diesem Tutorial führen wir Sie durch den Prozess der Ausführung einer Python-Anwendung in einem Docker-Container und decken die essentiellen Schritte von der Docker-Grundlagen bis zur Bereitstellung der containerisierten Anwendung ab.

Docker verstehen

Was ist Docker?

Docker ist eine Open-Source-Plattform, die Entwicklern ermöglicht, Anwendungen in einer containerisierten Umgebung zu erstellen, bereitzustellen und auszuführen. Container sind leichte, eigenständige und ausführbare Softwarepakete, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Bibliotheken. Docker bietet eine Möglichkeit, diese Container zu verpacken und zu verteilen, wodurch die Bereitstellung und Verwaltung von Anwendungen in verschiedenen Umgebungen vereinfacht wird.

Vorteile der Verwendung von Docker

1. Konsistenz: Docker-Container gewährleisten, dass die Anwendung unabhängig von der zugrunde liegenden Infrastruktur auf dieselbe Weise ausgeführt wird.
2. Skalierbarkeit: Docker erleichtert die Skalierung von Anwendungen nach Bedarf, indem Container hinzugefügt oder entfernt werden.
3. Effizienz: Docker-Container sind leichtgewichtig und verbrauchen weniger Ressourcen als herkömmliche virtuelle Maschinen, was zu einer effizienteren Nutzung der Rechenressourcen führt.
4. Portabilität: Docker-Container können problemlos zwischen verschiedenen Umgebungen wie Entwicklung, Test und Produktion verschoben werden, ohne komplexe Konfigurationsänderungen vornehmen zu müssen.

Docker-Architektur

Die Docker-Architektur basiert auf einem Client-Server-Modell, wobei der Docker-Client mit dem Docker-Daemon kommuniziert, der für die Erstellung, Ausführung und Verwaltung von Docker-Containern zuständig ist. Die wichtigsten Komponenten der Docker-Architektur umfassen:

Erste Schritte mit Docker

Um mit Docker zu beginnen, müssen Sie die Docker-Engine auf Ihrem System installieren. Sie können Docker von der offiziellen Docker-Website (https://www.docker.com/get-started) herunterladen und installieren. Nach der Installation können Sie die Docker-Befehlszeilenschnittstelle (CLI) verwenden, um mit dem Docker-Daemon zu interagieren und Ihre Container zu verwalten.

Hier ist ein Beispiel dafür, wie Sie einen einfachen "Hello, World!"-Container mit Docker ausführen:

$ docker run hello-world

Dieser Befehl zieht das hello-world-Image aus dem Docker Hub-Repository, erstellt einen neuen Container und führt die Anwendung innerhalb des Containers aus.

Containerisierung einer Python-Anwendung

Erstellen eines Docker-Images für eine Python-Anwendung

Um eine Python-Anwendung mit Docker zu containerisieren, müssen Sie ein Docker-Image erstellen. Ein Docker-Image ist ein leichtgewichtiges, eigenständiges, ausführbares Paket, das alles enthält, was zum Ausführen der Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Bibliotheken.

Hier ist ein Beispiel, wie Sie ein Docker-Image für eine einfache Python-Anwendung erstellen:

1. Erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie in Ihrem Terminal dorthin.

2. Erstellen Sie eine neue Datei namens app.py und fügen Sie den folgenden Python-Code hinzu:

   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello():
       return 'Hello, LabEx!'
   
   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=5000)

3. Erstellen Sie eine neue Datei namens Dockerfile und fügen Sie den folgenden Inhalt hinzu:

   FROM python:3.9-slim
   WORKDIR /app
   COPY . /app
   RUN pip install --no-cache-dir -r requirements.txt
   CMD ["python", "app.py"]

   Diese Dockerfile definiert die Schritte zum Erstellen des Docker-Images für Ihre Python-Anwendung. Sie beginnt mit dem Basis-Image python:3.9-slim, setzt das Arbeitsverzeichnis auf /app, kopiert die Anwendungsdateien in den Container, installiert die benötigten Abhängigkeiten und führt das Skript app.py aus.

4. Erstellen Sie eine neue Datei namens requirements.txt und fügen Sie die folgende Abhängigkeit hinzu:

   flask

5. Erstellen Sie das Docker-Image mit folgendem Befehl:

   $ docker build -t my-python-app .

   Dieser Befehl erstellt das Docker-Image mit dem Tag my-python-app.

Ausführen der Python-Anwendung in einem Docker-Container

Sobald Sie das Docker-Image haben, können Sie die Python-Anwendung in einem Docker-Container mit folgendem Befehl ausführen:

$ docker run -p 5000:5000 my-python-app

Dieser Befehl führt den Container my-python-app aus und ordnet den Port 5000 des Containers dem Port 5000 des Hostsystems zu.

Sie können die Python-Anwendung nun aufrufen, indem Sie einen Webbrowser öffnen und zu http://localhost:5000 navigieren. Sie sollten die Meldung "Hello, LabEx!" angezeigt bekommen.

Bereitstellung des Docker-Containers

Hochladen des Docker-Images in ein Repository

Um Ihren Docker-Container bereitzustellen, müssen Sie zuerst das Docker-Image in ein Repository wie Docker Hub oder ein privates Repository hochladen. Dadurch können Sie Ihre Anwendung mit anderen Umgebungen teilen und verteilen.

So laden Sie Ihr my-python-app-Image auf Docker Hub hoch:

1. Erstellen Sie ein Docker Hub-Konto (falls noch nicht vorhanden) unter https://hub.docker.com.

2. Melden Sie sich mit dem Befehl docker login bei Docker Hub an:

   $ docker login

   Geben Sie Ihren Docker Hub-Benutzernamen und Ihr Passwort ein, wenn Sie dazu aufgefordert werden.

3. Markieren Sie Ihr lokales my-python-app-Image mit Ihrem Docker Hub-Benutzernamen und einem Tag (z. B. latest):

   $ docker tag my-python-app username/my-python-app:latest

4. Laden Sie das markierte Image auf Docker Hub hoch:

   $ docker push username/my-python-app:latest

Jetzt ist Ihr Docker-Image im Docker Hub-Repository verfügbar und kann auf anderen Systemen gezogen und bereitgestellt werden.

Bereitstellung des Docker-Containers

Um den Docker-Container in einer Produktionsumgebung bereitzustellen, können Sie eine Container-Orchestrierungsplattform wie Kubernetes oder Docker Swarm verwenden. Diese Plattformen bieten Funktionen zum Skalieren, Lastausgleich und zur Verwaltung des Lebenszyklus Ihrer Container.

Hier ist ein Beispiel dafür, wie Sie den my-python-app-Container mit Docker Swarm bereitstellen können:

1. Initialisieren Sie einen Docker Swarm-Cluster:

   $ docker swarm init

2. Erstellen Sie einen neuen Dienst für den my-python-app-Container:

   $ docker service create --name my-python-app -p 5000:5000 username/my-python-app:latest

   Dieser Befehl erstellt einen neuen Dienst namens my-python-app und führt das Image username/my-python-app:latest aus, wobei der Port 5000 des Containers dem Port 5000 des Hostsystems zugeordnet wird.

3. Skalieren Sie den Dienst auf mehrere Replikate:

   $ docker service scale my-python-app=3

   Dieser Befehl skaliert den Dienst my-python-app auf 3 Replikate, wodurch eine hohe Verfügbarkeit und ein Lastausgleich für die Anwendung gewährleistet werden.

4. Überwachen Sie den Dienststatus:

   $ docker service ls
   $ docker service logs my-python-app

   Diese Befehle ermöglichen es Ihnen, den Status des Dienstes my-python-app anzuzeigen und die Protokolle zu überprüfen.

Mit einer Container-Orchestrierungsplattform wie Docker Swarm können Sie Ihre Docker-Container in einer Produktionsumgebung einfach verwalten, skalieren und bereitstellen.

Zusammenfassung

Am Ende dieses Tutorials verfügen Sie über ein fundiertes Verständnis von Docker und die Fähigkeit, Ihre Python-Anwendung zu containerisieren. Sie lernen, wie Sie ein Docker-Image erstellen, den Container ausführen und Ihre Anwendung konsistent, zuverlässig und skalierbar bereitstellen. Die Beherrschung von Docker für die Python-Entwicklung wird Ihren Workflow optimieren und Ihre Anwendung portabler und einfacher zu verwalten machen.