Eine Python-App mit Docker containerisieren

Preslav Dobrev2023-03-07 · 6 min read

Eine Python-App mit Docker containerisieren

Docker ist eine kostenlose Open-Source-Lösung für die Entwicklung, Bereitstellung und Verwaltung von Apps in einer schlanken Virtualisierung auf Betriebssystemebene. In dieser Anleitung zeigen wir, wie man eine Python-App in einem Docker-Container erstellt.

Voraussetzungen

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

Ein Linux-System. Schauen 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 auf Ubuntu.

Docker-Container

Wenn verschiedene Programme in derselben Umgebung ausgeführt werden, kann (und wird) etwas schiefgehen. Je mehr Programme Sie hinzufügen, desto instabiler wird es. Für den Durchschnittsbürger mag das keine große Sache sein. Wenn es jedoch um geschäftskritische Anwendungen geht, kann dies schwerwiegende Folgen haben.

Je mehr Apps im System eingeführt werden, desto größer ist die Angriffsfläche. Eine einzige kompromittierte App kann leicht zum Absturz des gesamten Systems führen.

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

Apps innerhalb des Containers haben nur begrenzten Zugriff auf Dateien.
Containerisierte Apps können andere im System ausgeführte Prozesse nicht sehen.
Dem Container kann eine bestimmte Menge an Hardwareressourcen zugewiesen werden.
Netzwerkports eines Containers werden nicht nach außen freigegeben.
Konsistente Paketierung von fast allem über lokale und Produktionsumgebungen hinweg.

Zur Demonstration werden wir einen einfachen Python-Server in einem Docker-Container erstellen, den Container in ein Image umwandeln und das Image in einer Dummy-Produktionsumgebung bereitstellen.

Schritt 1 – Dateisystem-Konfiguration

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

mkdir -pv python-server-container/

1	mkdir -pv python-server-container/

cd !$

cd !$

Erstellen Sie in diesem Verzeichnis ein Unterverzeichnis src um unseren Code zu speichern:

mkdir -pv src/

1	mkdir -pv src/

Schritt 2 – Erstellen des Python-Servers

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

touch server.py

1	touch server.py

Öffnen Sie sie in einem Texteditor:

nano server.py

1	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()

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()

Hier:

Wir verwenden die Klasse HTTPServer und fordern einen Handler aus der Standard-Python-Bibliothek an, wodurch das Programm einfach gehalten wird.
Die Funktion run initiiert eine Instanz des HTTPserver.
Wie die Argumente von server_address nahelegen, lauscht der Server auf alle eingehenden Verbindungen auf Port 8080.

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

python3 server.py

1	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

1	curl -iv localhost:8080

Alternativ können Sie über einen Webbrowser auf den Link zugreifen:

http://localhost:8080

1	http://localhost:8080

Schritt 3 – Erstellen einer Dockerfile

Eine Dockerfile enthält die erforderlichen Anweisungen zur Erstellung eines Docker-Images. Die Anweisungen in der Datei werden nacheinander ausgeführt. Erfahren Sie mehr über Dockerfile.

Erstellen Sie eine neue Dockerfile für unser Projekt:

touch Dockerfile

1	touch Dockerfile

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

nano Dockerfile

1	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"]

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"]

Hier,

Jedes Dockerfile muss mit der FROM-Anweisung beginnen. In unserem Fall deklarieren wir Python als Basis des Docker-Images.
Die ENV SRC_DIR-Anweisung gibt den Speicherort des Container-Verzeichnisses an.
Die COPY-Anweisung kopiert die Dateien aus dem src-Verzeichnis, das derzeit den Python-Server hostet.
Die Variable PYTHONBUFFERED=1 gibt an, dass Python Ausgaben direkt an STDOUT ausgibt und protokolliert. Andernfalls würden die Protokolle an keinen Puffer gesendet.
Die CMD-Anweisung gibt einen Standardbefehl an, der beim Ausführen des Containers ausgeführt werden soll. In diesem Fall verwenden wir die Anweisung, um unseren Python-Server zu starten.

Schritt 4 – Docker-Image-Erstellung

Da 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

1	docker build . -t python_server

Hier,

Das -t-Flag wird verwendet, um unser Docker-Image als python_server.
zu taggen. Docker lädt alle erforderlichen Komponenten herunter und fügt sie zu einem Image zusammen.

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

1	docker run -p 8080:8080 python_server

Hier leiten wir den Port 8080 vom lokalen Rechner an das Docker-Image weiter, indem wir das -p-Flag verwenden.

Wir können leicht überprüfen, ob der Server läuft, indem wir curl:

curl -iv localhost:8080

1	curl -iv localhost:8080

Schritt 6 – Beenden des Servers

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

Schritt 7 – Exportieren und Importieren des Docker-Images

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

Überprüfen Sie zunächst die Liste der Docker-Images auf dem aktuellen System:

docker images

1	docker images

Unser Ziel ist das python_server-Docker-Image, das wir gerade erstellt haben. Der folgende Befehl exportiert es als TAR-Archiv:

docker save python_server:latest > python_server.tar

1	docker save python_server:latest > python_server.tar

Nach dem Übertragen der python_server.tar-Datei auf den Zielrechner verwenden Sie den folgenden Befehl, um das Docker-Image zu importieren:

docker load < python_server.tar

1	docker load < python_server.tar

Fazit

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

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

Viel Spaß beim Computing!

Preslav Dobrev

Autor · CloudSigma

Preslav Dobrev ist ein kreativer Designer bei CloudSigma und konzentriert sich auf eine konsistente Unternehmensidentität durch traditionelle und innovative Marketingkanäle. Er versteht es meisterhaft, künstlerische Vision mit strategischem Marketing zu verbinden, um wirkungsvolle Markengeschichten zu schaffen.