Wie man ein Python-Skript beim Start eines Docker-Containers ausführt

DockerDockerBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

Docker ist ein leistungsstarkes Werkzeug zur Containerisierung von Anwendungen, das die Entwicklung, Bereitstellung und Verwaltung von Software vereinfacht. In diesem Tutorial werden wir untersuchen, wie man ein Python-Skript beim Start eines Docker-Containers ausführt. Dieser Ansatz ermöglicht es Ihnen, Ihre Anwendungsbereitstellung zu automatisieren und Ihren Entwicklungsworkflow zu optimieren. Am Ende dieses Labors werden Sie in der Lage sein, einen Docker-Container zu erstellen, der Ihr Python-Skript automatisch beim Start ausführt.

Erstellen eines einfachen Python-Skripts

In diesem ersten Schritt erstellen wir ein einfaches Python-Skript, das beim Start unseres Docker-Containers ausgeführt wird. Dieses Skript gibt eine Nachricht sowie das aktuelle Datum und die aktuelle Uhrzeit aus.

Beginnen wir damit, ein neues Verzeichnis für unser Projekt zu erstellen:

mkdir -p ~/project/python-docker
cd ~/project/python-docker

Nun erstellen wir ein einfaches Python-Skript namens app.py mit dem Texteditor nano:

nano app.py

Fügen Sie im Nano-Editor den folgenden Python-Code hinzu:

import datetime
import time

print("Hello from the Docker container!")
print(f"Current date and time: {datetime.datetime.now()}")

## Keep the container running to demonstrate it's working
print("Container is running...")
while True:
    print("Container still running... Press Ctrl+C to stop.")
    time.sleep(10)

Speichern Sie die Datei, indem Sie Ctrl+O, dann Enter drücken, und beenden Sie Nano mit Ctrl+X.

Dieses Skript wird:

  1. Eine Willkommensnachricht ausgeben
  2. Das aktuelle Datum und die aktuelle Uhrzeit anzeigen
  3. Den Container mit einer Meldung alle 10 Sekunden am Laufen halten

Testen wir unser Python-Skript, um sicherzustellen, dass es korrekt funktioniert:

python3 app.py

Sie sollten eine ähnliche Ausgabe sehen wie:

Hello from the Docker container!
Current date and time: 2023-10-12 14:30:45.123456
Container is running...
Container still running... Press Ctrl+C to stop.

Drücken Sie Ctrl+C, um das Skript zu stoppen.

Nachdem wir nun ein funktionierendes Python-Skript haben, können wir damit fortfahren, einen Docker-Container zu erstellen, der dieses Skript beim Start ausführt.

Erstellen eines Dockerfiles

Nachdem unser Python-Skript nun fertig ist, erstellen wir ein Dockerfile, um zu definieren, wie unser Docker-Container gebaut werden soll.

Ein Dockerfile ist eine Textdatei, die alle Befehle enthält, die zum Erstellen eines Docker-Images benötigt werden. Dieses Image enthält unser Python-Skript und alle notwendigen Abhängigkeiten.

Erstellen Sie im selben Verzeichnis (~/project/python-docker) eine neue Datei namens Dockerfile:

nano Dockerfile

Fügen Sie den folgenden Inhalt zum Dockerfile hinzu:

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

## Set working directory
WORKDIR /app

## Copy the Python script to the container
COPY app.py .

## Command to run when the container starts
CMD ["python", "app.py"]

Speichern und beenden Sie Nano, indem Sie Ctrl+O, dann Enter und dann Ctrl+X drücken.

Lassen Sie uns verstehen, was jede Zeile im Dockerfile tut:

  1. FROM python:3.9-slim: Dies gibt das zu verwendende Basis-Image an. Wir verwenden das offizielle Python 3.9-Image mit einer Slim-Variante, um die Größe gering zu halten.

  2. WORKDIR /app: Dies setzt das Arbeitsverzeichnis innerhalb des Containers auf /app.

  3. COPY app.py .: Dies kopiert unser Python-Skript von der Host-Maschine in das aktuelle Arbeitsverzeichnis im Container (also /app).

  4. CMD ["python", "app.py"]: Dies gibt den Befehl an, der beim Start des Containers ausgeführt werden soll. In diesem Fall wird unser Python-Skript ausgeführt.

Nun erstellen wir unser Docker-Image mit diesem Dockerfile:

docker build -t python-app .

Dieser Befehl erstellt ein Docker-Image aus dem Dockerfile im aktuellen Verzeichnis (.) und taggt es mit dem Namen python-app (-t steht für Tag).

Sie sollten eine ähnliche Ausgabe sehen wie:

Sending build context to Docker daemon  3.072kB
Step 1/4 : FROM python:3.9-slim
 ---> 1bc6a8a2a52f
Step 2/4 : WORKDIR /app
 ---> Using cache
 ---> 2a3b7a28c9e5
Step 3/4 : COPY app.py .
 ---> Using cache
 ---> 9a0b7a1c8c2d
Step 4/4 : CMD ["python", "app.py"]
 ---> Using cache
 ---> 3b0c7a2d9f1e
Successfully built 3b0c7a2d9f1e
Successfully tagged python-app:latest

Die Ausgabe kann variieren, aber Sie sollten die Meldungen "Successfully built" und "Successfully tagged" sehen, wenn alles gut gelaufen ist.

Sie haben nun erfolgreich ein Docker-Image erstellt, das Ihr Python-Skript enthält und es ausführt, wenn ein Container von diesem Image gestartet wird.

Ausführen des Docker-Containers

Nachdem wir nun unser Docker-Image erstellt haben, können wir einen Container basierend auf diesem Image ausführen. Der Container führt beim Start automatisch unser Python-Skript aus.

Um einen Container von unserem Image auszuführen, verwenden Sie den folgenden Befehl:

docker run --name python-container python-app

Dieser Befehl startet einen neuen Container namens python-container aus dem Image python-app, das wir im vorherigen Schritt erstellt haben.

Sie sollten eine ähnliche Ausgabe sehen wie:

Hello from the Docker container!
Current date and time: 2023-10-12 15:45:30.123456
Container is running...
Container still running... Press Ctrl+C to stop.
Container still running... Press Ctrl+C to stop.

Der Container läuft jetzt und führt unser Python-Skript aus. Das Skript ist so konzipiert, dass es unbegrenzt weiterläuft und alle 10 Sekunden eine Nachricht ausgibt.

Drücken Sie Ctrl+C, um die Anzeige der Protokolle zu beenden, aber beachten Sie, dass der Container weiterhin im Hintergrund läuft.

Um zu überprüfen, ob der Container läuft, verwenden Sie den folgenden Befehl:

docker ps

Sie sollten Ihren Container in der Liste der laufenden Container sehen:

CONTAINER ID   IMAGE        COMMAND           CREATED         STATUS         PORTS     NAMES
1a2b3c4d5e6f   python-app   "python app.py"   1 minute ago    Up 1 minute              python-container

Um den Container zu stoppen, verwenden Sie den folgenden Befehl:

docker stop python-container

Um den Container erneut zu starten, verwenden Sie:

docker start python-container

Und um die Protokolle des laufenden Containers anzuzeigen:

docker logs python-container

Dies zeigt die Ausgabe unseres Python-Skripts. Sie können Ctrl+C drücken, um die Protokollansicht zu verlassen.

Um den Container zu entfernen, wenn Sie fertig sind, stoppen Sie ihn zuerst, falls er läuft, und entfernen Sie ihn dann:

docker stop python-container
docker rm python-container

Sie haben nun erfolgreich einen Docker-Container erstellt und ausgeführt, der beim Start ein Python-Skript ausführt.

Verwenden von Umgebungsvariablen mit Python in Docker

Umgebungsvariablen sind eine großartige Möglichkeit, Ihre Anwendung zu konfigurieren, ohne den Code zu ändern. In diesem Schritt ändern wir unser Python-Skript, um Umgebungsvariablen zu verwenden, und aktualisieren unser Dockerfile, um diese Variablen bereitzustellen.

Zuerst aktualisieren wir unser Python-Skript, um eine Umgebungsvariable zu lesen:

nano app.py

Ändern Sie das Skript, um die Unterstützung für Umgebungsvariablen einzuschließen:

import datetime
import time
import os

## Get the environment variable with a default value if not set
user_name = os.environ.get('USER_NAME', 'Guest')

print(f"Hello, {user_name}, from the Docker container!")
print(f"Current date and time: {datetime.datetime.now()}")

## Keep the container running to demonstrate it's working
print("Container is running...")
while True:
    print("Container still running... Press Ctrl+C to stop.")
    time.sleep(10)

Speichern und beenden Sie Nano, indem Sie Ctrl+O, dann Enter und dann Ctrl+X drücken.

Nun aktualisieren wir unser Dockerfile, um eine Umgebungsvariable einzuschließen:

nano Dockerfile

Aktualisieren Sie das Dockerfile, um die Umgebungsvariable einzuschließen:

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

## Set working directory
WORKDIR /app

## Set environment variable
ENV USER_NAME="Docker User"

## Copy the Python script to the container
COPY app.py .

## Command to run when the container starts
CMD ["python", "app.py"]

Speichern und beenden Sie Nano und erstellen Sie dann das Docker-Image neu:

docker build -t python-app-env .

Führen Sie nun einen Container mit der Standard-Umgebungsvariablen aus:

docker run --name python-env-container python-app-env

Sie sollten eine Begrüßung mit "Docker User" in der Ausgabe sehen:

Hello, Docker User, from the Docker container!
Current date and time: 2023-10-12 16:30:45.123456
Container is running...

Drücken Sie Ctrl+C, um die Anzeige der Protokolle zu beenden.

Stoppen und entfernen Sie den Container:

docker stop python-env-container
docker rm python-env-container

Sie können die Umgebungsvariable auch beim Ausführen des Containers überschreiben:

docker run --name python-env-container -e USER_NAME="LabEx Student" python-app-env

Dieses Mal sollten Sie Ihren benutzerdefinierten Namen in der Begrüßung sehen:

Hello, LabEx Student, from the Docker container!
Current date and time: 2023-10-12 16:35:15.789012
Container is running...

Drücken Sie Ctrl+C, um die Anzeige der Protokolle zu beenden.

Stoppen und entfernen Sie den Container:

docker stop python-env-container
docker rm python-env-container

Die Verwendung von Umgebungsvariablen ist eine gängige Praxis in Docker, um Ihre Container konfigurierbarer zu machen, ohne das Image für kleine Änderungen neu erstellen zu müssen.

Verwendung von ENTRYPOINT vs. CMD in Dockerfile

In Docker gibt es zwei Anweisungen, um anzugeben, welcher Befehl beim Start eines Containers ausgeführt werden soll: CMD und ENTRYPOINT. Sie haben unterschiedliche Zwecke und Verhaltensweisen, und das Verständnis des Unterschieds ist wichtig für die Containerverwaltung.

Verstehen von ENTRYPOINT und CMD

  • ENTRYPOINT: Definiert die ausführbare Datei, die beim Start des Containers ausgeführt wird. Es ist schwieriger, sie zur Laufzeit zu überschreiben.
  • CMD: Stellt Standardargumente für den ENTRYPOINT bereit oder kann den gesamten Befehl angeben, wenn ENTRYPOINT nicht verwendet wird. Es ist einfach, sie zur Laufzeit zu überschreiben.

Lassen Sie uns den Unterschied untersuchen, indem wir zwei verschiedene Dockerfiles erstellen.

Erstellen Sie zuerst ein neues Python-Skript, das Befehlszeilenargumente akzeptiert:

nano greeting.py

Fügen Sie den folgenden Code hinzu:

import sys

print("Script started!")

if len(sys.argv) > 1:
    print(f"Arguments provided: {sys.argv[1:]}")
    for arg in sys.argv[1:]:
        print(f"- {arg}")
else:
    print("No arguments provided.")

print("Script finished!")

Speichern und beenden Sie Nano.

Erstellen wir nun ein Dockerfile, das CMD verwendet:

nano Dockerfile.cmd

Fügen Sie den folgenden Inhalt hinzu:

FROM python:3.9-slim

WORKDIR /app

COPY greeting.py .

CMD ["python", "greeting.py", "default", "arguments"]

Speichern und beenden Sie Nano.

Erstellen Sie das Image:

docker build -t python-cmd -f Dockerfile.cmd .

Erstellen Sie nun ein weiteres Dockerfile, das ENTRYPOINT verwendet:

nano Dockerfile.entrypoint

Fügen Sie den folgenden Inhalt hinzu:

FROM python:3.9-slim

WORKDIR /app

COPY greeting.py .

ENTRYPOINT ["python", "greeting.py"]
CMD ["default", "arguments"]

Speichern und beenden Sie Nano.

Erstellen Sie das Image:

docker build -t python-entrypoint -f Dockerfile.entrypoint .

Testen von CMD vs. ENTRYPOINT

Lassen Sie uns Container von beiden Images ausführen und die Unterschiede beobachten.

Führen Sie zuerst einen Container mit dem CMD-Image ohne zusätzliche Argumente aus:

docker run --name cmd-container python-cmd

Die Ausgabe sollte ähnlich sein wie:

Script started!
Arguments provided: ['default', 'arguments']
- default
- arguments
Script finished!

Führen Sie nun einen Container mit dem CMD-Image aus, aber geben Sie benutzerdefinierte Argumente an:

docker run --name cmd-container-custom python-cmd hello world

Ausgabe:

Script started!
No arguments provided.
Script finished!

Beachten Sie, dass der gesamte Befehl durch hello world ersetzt wurde, die nicht als Argumente an unser Skript übergeben werden.

Führen wir nun einen Container mit dem ENTRYPOINT-Image ohne zusätzliche Argumente aus:

docker run --name entrypoint-container python-entrypoint

Ausgabe:

Script started!
Arguments provided: ['default', 'arguments']
- default
- arguments
Script finished!

Führen Sie abschließend einen Container mit dem ENTRYPOINT-Image aus und geben Sie benutzerdefinierte Argumente an:

docker run --name entrypoint-container-custom python-entrypoint hello world

Ausgabe:

Script started!
Arguments provided: ['hello', 'world']
- hello
- world
Script finished!

Dieses Mal werden unsere Argumente ordnungsgemäß an das Python-Skript übergeben, da ENTRYPOINT die ausführbare Datei definiert und alle zusätzlichen Argumente, die an docker run übergeben werden, an diese ausführbare Datei übergeben werden.

Best Practices

  • Verwenden Sie ENTRYPOINT für Container, die immer einen bestimmten Befehl ausführen sollen (wie unser Python-Skript).
  • Verwenden Sie CMD, um Standardargumente bereitzustellen, die leicht überschrieben werden können.
  • Kombinieren Sie beides, indem Sie ENTRYPOINT für den Befehl und CMD für Standardargumente verwenden.

Bereinigen Sie die Container:

docker rm cmd-container cmd-container-custom entrypoint-container entrypoint-container-custom

Sie haben nun den Unterschied zwischen CMD und ENTRYPOINT in Docker gelernt, was für die Steuerung der Ausführung Ihrer Python-Skripte beim Start eines Containers unerlässlich ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Python-Skripte ausführen, wenn ein Docker-Container startet. Hier ist, was Sie erreicht haben:

  1. Erstellung eines einfachen Python-Skripts, das in einem Docker-Container ausgeführt wird
  2. Erstellung eines Docker-Images mit einem Dockerfile
  3. Ausführung eines Docker-Containers, der das Python-Skript automatisch ausführt
  4. Verwendung von Umgebungsvariablen zur Konfiguration Ihrer Python-Anwendung in Docker
  5. Verständnis des Unterschieds zwischen CMD und ENTRYPOINT in Dockerfiles

Diese Fähigkeiten sind grundlegend für die Containerisierung von Python-Anwendungen und die Automatisierung ihrer Bereitstellung. Sie können jetzt:

  • Ihre Python-Anwendungen mit all ihren Abhängigkeiten verpacken
  • Ihre Anwendungen mithilfe von Umgebungsvariablen konfigurieren
  • Steuern, wie Ihre Anwendungen innerhalb von Docker-Containern gestartet werden
  • Den geeigneten Startmechanismus (CMD oder ENTRYPOINT) für Ihren spezifischen Anwendungsfall auswählen

Mit diesem Wissen können Sie komplexere Docker-Anwendungen erstellen, die Python-Skripte automatisch beim Start ausführen, wodurch Ihr Bereitstellungsprozess effizienter und zuverlässiger wird.