Docker Run Befehlsparameter

Einführung

In diesem Lab konzentrieren wir uns ausschließlich auf den Befehl docker run und seine vielfältigen Parameter. Der Befehl docker run ist die Basis aller Docker-Operationen. Er ermöglicht es uns, Container mit spezifischen Konfigurationen zu erstellen und zu starten.

Indem Sie die Parameter dieses Befehls beherrschen, erhalten Sie eine präzisere Kontrolle über Ihre containerisierten Anwendungen und verbessern Ihre Fähigkeiten, Docker-Container effektiv bereitzustellen und zu verwalten.

Wir werden ein breites Spektrum an Parametern abdecken, darunter solche für die Benennung, den Hintergrundmodus (Detached Mode), Port-Mapping, Volume-Mounting, Umgebungsvariablen, Ressourcenbeschränkungen und mehr.

Einige dieser Parameter werden Ihnen vielleicht schon bekannt vorkommen, während andere neu für Sie sein könnten.

Grundlagen von Docker Run und Container-Benennung

Beginnen wir mit den Grundlagen von docker run und schauen uns an, wie wir unsere Container benennen können.

Starten Sie zunächst einen einfachen Nginx-Container:

docker run nginx

Dieser Befehl führt einen Nginx-Container im Vordergrund aus. Sie sehen einen Stream von Log-Ausgaben in Ihrem Terminal. Das liegt daran, dass der Container im Vordergrund läuft und Ihnen die Protokolle direkt anzeigt.

Um diesen Container zu stoppen, drücken Sie Strg+C. Sie werden bemerken, dass es einige Sekunden dauert, bis er stoppt – das ist normal, da Docker dem Container Zeit gibt, sich ordnungsgemäß herunterzufahren.

Nun führen wir ihn im Hintergrundmodus (Detached Mode) aus und geben ihm einen Namen:

docker run -d --name my-nginx nginx

Lassen Sie uns diesen Befehl aufschlüsseln:

• docker run: Dies ist der Basisbefehl zum Ausführen eines Containers.
• -d: Diese Option führt den Container im Detached-Modus aus, was bedeutet, dass er im Hintergrund läuft. Sie sehen keine Ausgabe in Ihrem Terminal.
• --name my-nginx: Dies weist dem Container den Namen "my-nginx" zu. Wenn Sie keinen Namen angeben, weist Docker einen zufälligen Namen zu.
• nginx: Dies ist der Name des Images, das wir zur Erstellung des Containers verwenden.

Nach dem Ausführen dieses Befehls sehen Sie eine lange Zeichenfolge. Dies ist die Container-ID. Docker hat den Container im Hintergrund gestartet.

Falls Sie eine Fehlermeldung erhalten, dass der Name bereits vergeben ist, bedeutet dies, dass bereits ein Container mit diesem Namen existiert. Sie können entweder einen anderen Namen wählen oder den vorhandenen Container entfernen (wie das geht, lernen wir in späteren Labs).

Port-Mapping

Der Parameter -p in docker run ermöglicht es uns, Ports vom Container auf den Host-Rechner zu spiegeln. Dies ist entscheidend, um auf Dienste, die innerhalb des Containers laufen, von Ihrem Host-System aus zuzugreifen.

Starten Sie einen Nginx-Container mit Port-Mapping:

docker run -d --name nginx-mapped -p 8080:80 nginx

Hier sind die neuen Teile dieses Befehls:

• -p 8080:80: Dies mappt den Port 8080 auf Ihrem Host auf den Port 80 im Container. Das Format ist immer Host-Port:Container-Port.

Nginx läuft standardmäßig auf Port 80 innerhalb des Containers. Durch das Mapping auf Port 8080 auf unserem Host können wir darauf zugreifen, indem wir localhost:8080 in einem Webbrowser aufrufen.

Lassen Sie uns nun überprüfen, ob die Nginx-Willkommensseite erreichbar ist. Wir verwenden dazu den Befehl curl, mit dem wir HTTP-Anfragen über die Kommandozeile stellen können:

curl http://localhost:8080

Sie sollten den HTML-Inhalt der Nginx-Willkommensseite sehen. Falls curl nicht installiert ist, können Sie es hiermit nachholen:

sudo apt-get update && sudo apt-get install -y curl

Falls Sie die Seite immer noch nicht aufrufen können, prüfen Sie bitte Folgendes:

1. Stellen Sie sicher, dass der Container läuft: docker ps | grep nginx-mapped
2. Prüfen Sie, ob der Port tatsächlich gemappt ist: docker port nginx-mapped
3. Wenn Sie einen Cloud-Server verwenden, stellen Sie sicher, dass die Firewall den Datenverkehr auf Port 8080 zulässt.

Volume-Mounting

Der Parameter -v in docker run erlaubt es uns, Volumes einzubinden (Mounting), um Daten zwischen dem Host und dem Container zu teilen. Dies ist äußerst nützlich, um Daten dauerhaft zu speichern oder dem Container Konfigurationsdateien zur Verfügung zu stellen.

Zuerst erstellen wir eine einfache Verzeichnisstruktur auf unserem Host:

mkdir -p ~/project/nginx-data
echo "<html><body><h1>Hello from mounted volume</h1></body></html>" > ~/project/nginx-data/index.html

Diese Befehle bewirken Folgendes:

1. Erstellen eines neuen Verzeichnisses nginx-data innerhalb des Ordners project in Ihrem Home-Verzeichnis.
2. Erstellen einer einfachen HTML-Datei namens index.html in diesem neuen Verzeichnis.

Nun starten wir einen Nginx-Container und binden dieses Verzeichnis ein:

docker run -d --name nginx-volume -p 8081:80 -v ~/project/nginx-data:/usr/share/nginx/html nginx

Lassen Sie uns diesen Befehl analysieren:

• docker run: Der Befehl zum Starten eines neuen Containers.
• -d: Führt den Container im Hintergrund aus.
• --name nginx-volume: Weist unserem Container den Namen "nginx-volume" zu.
• -p 8081:80: Mappt Port 8081 des Hosts auf Port 80 des Containers.
• -v ~/project/nginx-data:/usr/share/nginx/html: Dies bindet das Verzeichnis nginx-data von unserem Host in das Verzeichnis /usr/share/nginx/html im Container ein. Dort sucht Nginx nach Inhalten, die ausgeliefert werden sollen.
• nginx: Das verwendete Image.

Überprüfen wir nun, ob die benutzerdefinierte Seite ausgeliefert wird:

curl http://localhost:8081

Sie sollten den Inhalt Ihrer eigenen HTML-Datei sehen: "Hello from mounted volume!"

Falls Sie Ihren Inhalt nicht sehen, prüfen Sie bitte:

1. Existiert die Datei ~/project/nginx-data/index.html auf Ihrem Host-System?
2. Läuft der Container? docker ps | grep nginx-volume
3. Prüfen Sie die Nginx-Logs auf Fehler: docker logs nginx-volume

Diese Methode, ein Host-Verzeichnis in einen Container einzubinden, nennt man "Bind Mount". Es ist ein direkter Weg, Dateien zu teilen. Beachten Sie dabei:

1. Der Pfad zum Host-Verzeichnis muss ein absoluter Pfad sein.
2. Wenn das Host-Verzeichnis nicht existiert, erstellt Docker es automatisch.
3. Änderungen an Dateien in diesem Verzeichnis (egal ob auf dem Host oder im Container) sind sofort für beide Seiten sichtbar.
4. Achten Sie auf Berechtigungen: Der Container läuft standardmäßig als Root, was dazu führen kann, dass Dateien erstellt werden, die Ihr Host-Benutzer nicht bearbeiten kann.

Durch das Einbinden eines Verzeichnisses (statt einer einzelnen Datei) vermeiden wir potenzielle Fehler und bleiben flexibel beim Hinzufügen oder Ändern von Dateien, ohne den Container neu erstellen zu müssen.

Umgebungsvariablen

Der Parameter -e in docker run ermöglicht es uns, Umgebungsvariablen im Container zu setzen. Dies ist hilfreich, um die im Container laufende Anwendung zu konfigurieren, ohne deren Code ändern zu müssen.

Starten Sie einen Container mit Umgebungsvariablen:

docker run -d --name nginx-env -e NGINX_HOST=mywebsite.com -e NGINX_PORT=80 nginx

Die neuen Bestandteile:

• -e NGINX_HOST=mywebsite.com: Setzt eine Umgebungsvariable namens NGINX_HOST mit dem Wert mywebsite.com.
• -e NGINX_PORT=80: Setzt eine weitere Variable NGINX_PORT mit dem Wert 80.

Umgebungsvariablen sind Schlüssel-Wert-Paare, auf die Prozesse innerhalb des Containers zugreifen können. Viele Docker-Images sind so konzipiert, dass sie bestimmte Variablen zur Konfiguration nutzen.

Sie können die Variablen wie folgt überprüfen:

docker exec nginx-env env | grep NGINX_

Dieser Befehl bewirkt:

• docker exec nginx-env: Weist Docker an, einen Befehl im laufenden Container nginx-env auszuführen.
• env: Dieser Befehl listet alle Umgebungsvariablen auf.
• | grep NGINX_: Filtert die Ausgabe, sodass nur Zeilen mit "NGINX_" angezeigt werden.

Sie sollten Ihre beiden gesetzten Variablen in der Liste sehen.

Falls nicht, prüfen Sie:

1. Läuft der Container? docker ps | grep nginx-env
2. Haben Sie die Variablennamen im docker run-Befehl korrekt geschrieben?

Ressourcenbeschränkungen

Docker erlaubt es Ihnen, Ressourcenbeschränkungen für Container über verschiedene Parameter in docker run festzulegen. Dies ist wichtig für die Performance und Stabilität Ihres Host-Systems, besonders wenn viele Container gleichzeitig laufen.

Starten Sie einen Container mit Speicher- und CPU-Limits:

docker run -d --name nginx-limited --memory 256m --cpus 0.5 nginx

Die neuen Parameter erklärt:

• --memory 256m: Begrenzt den Container auf 256 Megabyte Arbeitsspeicher. 'm' steht für Megabyte, 'g' stünde für Gigabyte.
• --cpus 0.5: Begrenzt den Container auf maximal die Hälfte eines CPU-Kerns.

Diese Limits verhindern, dass ein Container mehr Ressourcen beansprucht als zugewiesen, was verhindert, dass ein einzelner Prozess das gesamte Host-System lahmlegt.

Sie können die Anwendung der Limits überprüfen:

docker inspect -f '{{.HostConfig.Memory}}' nginx-limited
docker inspect -f '{{.HostConfig.NanoCpus}}' nginx-limited

Der erste Befehl sollte 268435456 (256MB in Bytes) ausgeben, der zweite 500000000 (0,5 CPU in Nano-Einheiten).

Hinweis: Zu niedrig angesetzte Limits können dazu führen, dass der Container schlecht läuft oder abstürzt. Erhöhen Sie die Limits, falls Probleme auftreten.

Netzwerkeinstellungen

Der Parameter --network in docker run ermöglicht es Ihnen, einen Container mit einem Netzwerk zu verbinden. Dies ist nützlich für die Kommunikation zwischen Containern und zur Isolierung von Container-Gruppen.

Erstellen Sie zuerst ein benutzerdefiniertes Bridge-Netzwerk:

docker network create my-custom-network

Dies erstellt ein neues Bridge-Netzwerk namens my-custom-network. Bridge-Netzwerke sind der am häufigsten verwendete Netzwerktyp in Docker.

Starten Sie nun einen Container, der mit diesem Netzwerk verbunden ist:

docker run -d --name nginx-networked --network my-custom-network nginx

Die Option --network my-custom-network verbindet den Container direkt beim Start mit dem soeben erstellten Netzwerk.

Container im selben Netzwerk können untereinander über ihre Containernamen als Hostnamen kommunizieren. Das macht die Verknüpfung von Diensten sehr einfach.

Neustart-Richtlinien

Der Parameter --restart in docker run erlaubt es Ihnen, eine Neustart-Richtlinie (Restart Policy) festzulegen. Dies stellt sicher, dass Ihre Container weiterlaufen, selbst wenn sie abstürzen oder der Docker-Dienst neu gestartet wird.

Starten Sie einen Container mit einer Neustart-Richtlinie:

docker run -d --name nginx-restart --restart unless-stopped nginx

Die Option --restart unless-stopped bewirkt, dass der Container automatisch neu gestartet wird, es sei denn, er wurde explizit vom Benutzer gestoppt.

Andere Richtlinien sind:

• no: Der Standardwert. Der Container wird nicht automatisch neu gestartet.
• on-failure: Neustart nur, wenn der Container mit einem Fehlerstatus (ungleich Null) beendet wird.
• always: Der Container wird immer neu gestartet, unabhängig vom Beendigungsstatus.

Überprüfen Sie die Richtlinie:

docker inspect -f '{{.HostConfig.RestartPolicy.Name}}' nginx-restart

Die Ausgabe sollte unless-stopped lauten.

Arbeitsverzeichnis und Befehle

In diesem Schritt untersuchen wir, wie man ein Arbeitsverzeichnis innerhalb eines Containers festlegt und benutzerdefinierte Befehle beim Start ausführt.

Der Parameter -w in docker run setzt das Arbeitsverzeichnis (Working Directory) im Container. Zudem können Sie nach dem Image-Namen einen spezifischen Befehl angeben.

Kombinieren wir diese Konzepte:

docker run -d --name nginx-custom -w /app nginx sh -c "mkdir -p /app && touch newfile.txt && nginx -g 'daemon off;'"

Analyse des Befehls:

• -d: Hintergrundmodus.
• --name nginx-custom: Name des Containers.
• -w /app: Setzt das Arbeitsverzeichnis im Container auf /app.
• nginx: Das zu verwendende Image.
• sh -c "...": Führt einen Shell-Befehl aus.
  • mkdir -p /app: Erstellt das Verzeichnis /app, falls es nicht existiert.
  • &&: Führt den nächsten Befehl nur bei Erfolg des vorherigen aus.
  • touch newfile.txt: Erstellt eine leere Datei namens newfile.txt.
  • nginx -g 'daemon off;': Startet Nginx im Vordergrund, damit der Container aktiv bleibt.

Überprüfen wir nun, ob der Container läuft und die Datei erstellt wurde:

docker ps | grep nginx-custom
docker exec nginx-custom ls -l /app/newfile.txt

Der erste Befehl zeigt den Status an, der zweite listet die Details der Datei newfile.txt im Verzeichnis /app des Containers auf.

Zusammenfassung

In diesem Lab haben wir uns intensiv mit dem Befehl docker run und seinen verschiedenen Parametern beschäftigt. Wir haben folgende Themen behandelt:

1. Grundlagen des Ausführens und Benennens von Containern.
2. Port-Mapping für den Zugriff auf Container-Dienste vom Host aus.
3. Volume-Mounting zum Datenaustausch zwischen Host und Container.
4. Setzen von Umgebungsvariablen zur Konfiguration.
5. Anwendung von Ressourcenbeschränkungen zur Kontrolle des Verbrauchs.
6. Netzwerkeinstellungen für die Kommunikation zwischen Containern.
7. Neustart-Richtlinien für eine höhere Zuverlässigkeit.
8. Festlegen von Arbeitsverzeichnissen und Startbefehlen.

Diese Parameter von docker run sind mächtige Werkzeuge zur Konfiguration und Verwaltung Ihrer Docker-Container. Wenn Sie diese Optionen beherrschen, können Sie anspruchsvollere und maßgeschneiderte Container-Umgebungen erstellen und genau steuern, wie diese mit dem Host-System interagieren und sich in verschiedenen Szenarien verhalten.