Benutzerdefinierte Docker-Images erstellen

Warum sollten Sie eigene Images erstellen? Sie können damit Ihre spezifische Anwendung, ihre Abhängigkeiten und ihre Konfiguration in einer einzigen portablen Einheit paketieren. Das ist entscheidend für Konsistenz und eine einfache Bereitstellung.

Wie dieses Image erstellt wird, definieren Sie mit einer Datei namens Dockerfile.

Wir containerisieren eine sehr einfache Python-Flask-Web-App. Sie gibt beim Aufrufen ihrer Webadresse lediglich „Hello from Docker!“ zurück.

Stellen Sie sich vor, dass sich folgende Dateien in einem Verzeichnis befinden:

• app.py: Der Python-Anwendungscode
• requirements.txt: Listet die Python-Abhängigkeiten auf
• Dockerfile: Anweisungen zum Erstellen des Images

Dies ist unsere einfache Python-Flask-Anwendung. Sie überwacht Port 5000 und antwortet mit „Hello from Docker!“.

Sie können sie lokal ausführen (nach der Installation von Flask), um sie in Aktion zu sehen!

Unsere Anwendung benötigt die Flask-Bibliothek. Wir führen sie in requirements.txt auf. Diese Datei teilt Docker (und dem Paketmanager von Python, pip) mit, was installiert werden soll.

Dadurch wird sichergestellt, dass unser Image alle für die Ausführung der Anwendung erforderlichen Bibliotheken enthält.

Ein Dockerfile ist eine Textdatei mit Anweisungen zum Erstellen eines Images. Jede Anweisung erstellt eine Ebene. Wir verwenden folgende Anweisungen:

• FROM: Gibt das Basis-Image an (z. B. Python).
• WORKDIR: Legt das Arbeitsverzeichnis innerhalb des Containers fest.
• COPY: Kopiert Dateien vom lokalen Computer in das Image.
• RUN: Führt Befehle aus (z. B. zum Installieren von Abhängigkeiten).
• EXPOSE: Informiert Docker über die Ports, die der Container überwacht.
• CMD: Legt den Standardbefehl fest, der beim Start des Containers ausgeführt wird.

Hier sehen Sie das vollständige Dockerfile für unsere Flask-Anwendung. Legen Sie diese Datei im selben Verzeichnis wie app.py und requirements.txt ab.

Jetzt erstellen wir unser Image! Öffnen Sie Ihr Terminal in dem Verzeichnis, in dem sich Ihr Dockerfile und die Anwendungsdateien befinden.

Das Flag -t versieht unser Image mit einem Namen (my-flask-app) und einer Version (1.0). Der Punkt . weist Docker an, das aktuelle Verzeichnis als Build-Kontext zu verwenden.

docker build -t my-flask-app:1.0 .

Nach Abschluss des Builds können Sie überprüfen, ob Ihr neues Image vorhanden ist, indem Sie alle lokalen Docker-Images auflisten.

Suchen Sie in der Ausgabe nach my-flask-app mit dem Tag 1.0.

docker images

Jetzt können Sie Ihre Anwendung in Aktion sehen! Verwenden Sie docker run, um aus Ihrem Image einen Container zu erstellen und zu starten.

-p 5000:5000 ordnet Port 5000 auf Ihrem Hostcomputer Port 5000 innerhalb des Containers zu. -d führt den Container im Detached-Modus (im Hintergrund) aus.

docker run -d -p 5000:5000 my-flask-app:1.0

Rufen Sie http://localhost:5000 in Ihrem Browser auf, um „Hello from Docker!“ zu sehen.

Tags sind entscheidend für die Verwaltung verschiedener Versionen Ihrer Images. Üblicherweise verwendet man semantische Versionierung (z. B. 1.0.0, 2.1.5>) und zusätzlich ein latest-Tag.

Mit docker tag können Sie einem Image mehrere Tags zuweisen:

docker tag my-flask-app:1.0 my-flask-app:latest

So können Sie auf dasselbe Image unter verschiedenen Namen verweisen, was es für Deployments flexibel einsetzbar macht.

Betrachten Sie das folgende Dockerfile und den Build-Befehl:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

Welche der folgenden Aussagen über den Befehl docker build -t my-app:v1 . ist RICHTIG?

Sehr gut! Sie haben gelernt, wie Sie:

• eine einfache Anwendung für die Containerisierung vorbereiten;
• ein grundlegendes Dockerfile mit wichtigen Anweisungen (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD) schreiben;
• mit docker build -t ein benutzerdefiniertes Docker-Image erstellen;
• Ihr Image mit docker images überprüfen;
• mit docker run -p einen Container aus Ihrem benutzerdefinierten Image starten;
• die Bedeutung von Image-Tags und Versionierung verstehen.

Als Nächstes sehen wir uns genauer an, wie Docker-Images mit Ebenen strukturiert sind und mit welchen Techniken sich ihre Größe und Build-Zeiten optimieren lassen!