Eine Python-App mit Docker containerisieren

Docker ist eine kostenlose Open-Source-Lösung zum Entwickeln, Bereitstellen und Verwalten von Apps in leichtgewichtiger Virtualisierung auf Betriebssystemebene. In dieser Anleitung zeigen wir, wie Sie eine Python-App innerhalb eines Docker-Containers erstellen.

Voraussetzungen

Um die in dieser Anleitung gezeigten Schritte auszuführen, benötigen Sie die folgenden Komponenten:

• Ein Linux-System. Sehen Sie sich an, wie Sie Ihren eigenen Ubuntu-VPS auf CloudSigma konfigurieren.

• Die neueste Version von Docker ist installiert und konfiguriert. Erfahren Sie mehr über die Installation von Docker unter Ubuntu.

Docker-Container

Wenn verschiedene Programme in derselben Umgebung ausgeführt werden, können Dinge kaputtgehen – und das werden sie auch. Je mehr Programme Sie hinzufügen, desto instabiler wird die Umgebung. Für durchschnittliche Nutzer ist das möglicherweise kein großes Problem. Bei geschäftskritischen Anwendungen kann dies jedoch schwerwiegende Folgen haben.

Je mehr Apps in das System eingeführt werden, desto größer wird die Angriffsfläche. Eine einzelne kompromittierte App kann leicht zum Ausfall des gesamten Systems führen.

Um diese Probleme zu lösen, können wir Docker-Container für Sandboxing auf Softwareebene verwenden:

• Apps innerhalb des Containers haben nur eingeschränkten Zugriff auf Dateien.

• Containerisierte Apps können keine anderen im System laufenden Prozesse sehen.

• Dem Container kann eine bestimmte Menge an Hardware-Ressourcen zugewiesen werden.

• Netzwerkports eines Containers sind nicht nach außen exponiert.

• Konsistente Paketierung von nahezu allem über lokale und Produktionsumgebungen hinweg.

Zur Demonstration erstellen wir einen einfachen Python-Server innerhalb eines Docker-Containers, wandeln den Container in ein Image um und stellen das Image in einer Dummy-Produktionsumgebung bereit.

Schritt 1 – Dateisystemkonfiguration

Um das Projekt zu hosten, erstellen wir zunächst ein dediziertes Verzeichnis:

mkdir -pv python-server-container/

cd !$

Erstellen Sie innerhalb des Verzeichnisses ein Unterverzeichnis src, um unseren Code zu speichern:

mkdir -pv src/

Schritt 2 – Erstellen des Python-Servers

In diesem Schritt erstellen wir einen einfachen HTTP-Server in Python. Erstellen Sie die Datei server.py:

touch server.py

Öffnen Sie sie in einem Texteditor:

nano server.py

Geben Sie den folgenden Python-Code ein:

from http.server import HTTPServer, SimpleHTTPRequestHandler

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    """server entrypoint"""
    server_address = ("0.0.0.0", 8080)
    httpd = server_class(server_address, handler_class)
    print("starting server...")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Hierbei gilt:

• Wir verwenden die Klasse HTTPServer und fordern einen Handler aus der Standardbibliothek von Python an, wodurch das Programm einfach bleibt.

• Die Funktion run startet eine Instanz von HTTPserver.

• Wie die Argumente von server_address nahelegen, lauscht der Server auf Port 8080 auf jede eingehende Verbindung.

Nun überprüfen wir, ob der Server wie erwartet funktioniert. Starten Sie den Server:

python3 server.py

Von einem neuen Terminal aus können wir curl verwenden, um eine Anfrage an den Server zu senden:

curl -iv localhost:8080

Alternativ können Sie den Link in einem Webbrowser aufrufen:

http://localhost:8080

Schritt 3 – Erstellen eines Dockerfile

Ein Dockerfile enthält die notwendigen Anweisungen zum Erzeugen eines Docker-Images. Die Anweisungen in der Datei werden nacheinander ausgeführt. Erfahren Sie mehr über Dockerfile.

Erstellen Sie ein neues Dockerfile für unser Projekt:

touch Dockerfile

Nun fügen wir den erforderlichen Code ein. Öffnen Sie die Datei in einem Texteditor:

nano Dockerfile

Geben Sie den folgenden Code ein:

FROM python:latest

ENV SRC_DIR /usr/bin/src/test_server/src
COPY src/* ${SRC_DIR}/
WORKDIR ${SRC_DIR}

ENV PYTHONUNBUFFERED=1

CMD ["python", "server.py"]

Hierbei gilt:

• Jedes Dockerfile muss mit der Direktive FROM beginnen. In unserem Fall deklarieren wir Python als Basis des Docker-Images.

• Die Direktive ENV SRC_DIR gibt den Speicherort des Container-Verzeichnisses an.

• Die Direktive COPY kopiert die Dateien aus dem Verzeichnis src, in dem sich derzeit der Python-Server befindet.

• Die Variable PYTHONBUFFERED=1 legt fest, dass Python Ausgaben und Logs direkt nach STDOUT schreibt. Andernfalls würden die Logs nicht an einen Puffer gesendet.

• Die Direktive CMD legt einen Standardbefehl fest, der beim Ausführen des Containers gestartet wird. In diesem Fall verwenden wir die Direktive, um unseren Python-Server zu starten.

Schritt 4 – Docker-Image-Erzeugung

Wenn das Dockerfile bereit ist, können wir nun ein Image erstellen. Führen Sie den folgenden Docker-Befehl aus, um den Prozess zu starten:

docker build . -t python_server

Hierbei gilt:

• Das Flag -t wird verwendet, um unser Docker-Image als python_server zu taggen.

• Docker lädt alle notwendigen Komponenten herunter und kombiniert sie zu einem Image.

Schritt 5 – Ausführen des Images

Das Image ist bereit für die Bereitstellung. Wir können es mit dem folgenden Befehl ausführen:

docker run -p 8080:8080 python_server

Hier leiten wir Port 8080 vom lokalen Rechner mithilfe des Flags -p an das Docker-Image weiter.

Wir können mit curl ganz einfach überprüfen, ob der Server läuft:

curl -iv localhost:8080

Schritt 6 – Beenden des Servers

Drücken Sie im Terminal “Ctrl + C”, um den Docker-Prozess zu beenden:

Schritt 7 – Exportieren und Importieren des Docker-Images

Wir haben nun ein funktionierendes Docker-Image, das unseren Python-Server hostet. Mithilfe der Export- und Importfunktionen von Docker können wir es auf jedes andere System migrieren.

Prüfen Sie zunächst die Liste der Docker-Images im aktuellen System:

docker images

Unser Ziel ist das gerade erstellte Docker-Image python_server. Der folgende Befehl exportiert es als TAR-Archiv:

docker save python_server:latest > python_server.tar

Nachdem Sie die Datei python_server.tar auf den Zielrechner übertragen haben, verwenden Sie den folgenden Befehl, um das Docker-Image zu importieren:

docker load < python_server.tar

Abschließende Gedanken

In dieser Anleitung haben wir gezeigt, wie aus einer Python-Anwendung ein Docker-Image erstellt wird. Wir haben einen einfachen Python-Webserver erstellt und daraus ein Docker-Image gebaut. Das Docker-Image kann nun in jeder Umgebung bereitgestellt werden und ein konsistentes Verhalten liefern.

Möchten Sie mehr über Docker erfahren? Sehen Sie sich die folgenden Anleitungen an:

• Eine Flask-Anwendung mit Docker unter Ubuntu 20.04 erstellen und bereitstellen

• So sichern und skalieren Sie eine Django-Anwendung mit Docker, Nginx und Let’s Encrypt

• So stellen Sie WordPress mit Docker-Containern unter Ubuntu 20.04 bereit

• Daten zwischen Docker-Containern teilen

Viel Spaß beim Computing!