Einführung
Docker-Container sind die Grundbausteine der modernen Anwendungsbereitstellung. In diesem Labor werden wir fortgeschrittene Techniken der Container-Verwaltung untersuchen, die Ihr Verständnis der Möglichkeiten von Docker vertiefen. Wir behandeln das Ausführen von Containern in verschiedenen Modi, die Verwaltung ihres Lebenszyklus, die Inspektion von Container-Details, die Arbeit mit Protokollen (Logs), das Ausführen von Befehlen innerhalb von Containern, das Kopieren von Dateien, das Festlegen von Umgebungsvariablen und die Begrenzung von Container-Ressourcen. Am Ende dieses Labors werden Sie ein umfassendes Verständnis dafür haben, wie Sie effektiv mit Docker-Containern arbeiten.
Ausführen von Containern in verschiedenen Modi
Docker ermöglicht es Ihnen, Container in verschiedenen Modi auszuführen, um unterschiedlichen Anwendungsfällen gerecht zu werden. Wir werden zwei gängige Modi untersuchen: den Detached-Modus (Hintergrundmodus) und den interaktiven Modus.
Lassen Sie uns zuerst einen Container im Detached-Modus starten:
docker run -d --name nginx-detached nginx
Dieser Befehl bewirkt Folgendes:
-d: Führt den Container im Detached-Modus (im Hintergrund) aus.--name nginx-detached: Weist dem Container den Namen "nginx-detached" zu.nginx: Gibt das zu verwendende Image an (es wird vom Docker Hub heruntergeladen, falls es lokal nicht verfügbar ist).
Sie sollten eine lange Zeichenfolge als Ausgabe sehen, die die Container-ID darstellt.
Sie können den Status des Containers überprüfen, indem Sie Folgendes ausführen:
docker ps
Lassen Sie uns nun einen Container im interaktiven Modus ausführen:
docker run -it --name ubuntu-interactive ubuntu /bin/bash
Dieser Befehl bewirkt Folgendes:
-it: Führt den Container im interaktiven Modus mit einem Pseudo-TTY aus.--name ubuntu-interactive: Weist dem Container den Namen "ubuntu-interactive" zu.ubuntu: Gibt das zu verwendende Image an./bin/bash: Der Befehl, der im Container ausgeführt werden soll (in diesem Fall eine Bash-Shell).
Sie sollten sich nun innerhalb des Ubuntu-Containers befinden. Sie können den Container verlassen, indem Sie exit eingeben.
Lassen Sie uns unsere laufenden Container auflisten:
docker ps
Sie sollten den nginx-detached-Container laufen sehen, aber nicht den ubuntu-interactive-Container (da wir ihn beendet haben).
Verwaltung des Container-Lebenszyklus
Das Verständnis dafür, wie man Container startet, stoppt und neu startet, ist für eine effektive Container-Verwaltung von entscheidender Bedeutung.
Beginnen wir damit, den nginx-detached-Container zu stoppen:
docker stop nginx-detached
Überprüfen wir nun den Status unserer Container:
docker ps -a
Sie sollten sehen, dass sich der nginx-detached-Container nun im Zustand "Exited" befindet.
Lassen Sie ihn uns wieder starten:
docker start nginx-detached
Überprüfen Sie den Status erneut:
docker ps
Sie sollten sehen, dass der nginx-detached-Container nun wieder den Zustand "Up" hat.
Wir können einen laufenden Container auch neu starten:
docker restart nginx-detached
Um den aktuellen Zustand all unserer Container zu sehen, einschließlich der gestoppten, verwenden Sie:
docker ps -a
Sie sollten sowohl den nginx-detached- als auch den ubuntu-interactive-Container in der Liste sehen, zusammen mit ihrem aktuellen Status.
Lassen Sie uns den gestoppten ubuntu-interactive-Container entfernen:
docker rm ubuntu-interactive
Und verifizieren wir, dass er entfernt wurde:
docker ps -a
Der ubuntu-interactive-Container sollte nicht mehr in der Liste erscheinen.
Inspektion von Container-Details
Docker bietet leistungsstarke Werkzeuge zur Inspektion der Details Ihrer Container. Lassen Sie uns diese erkunden.
Um detaillierte Informationen über einen Container zu erhalten, verwenden Sie den Befehl inspect:
docker inspect nginx-detached
Dieser Befehl gibt ein JSON-Array mit ausführlichen Informationen über den Container aus. Da dies sehr umfangreich sein kann, verwenden wir einen Filter, um gezielte Informationen zu erhalten.
So ermitteln Sie die IP-Adresse des Containers:
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' nginx-detached
So sehen Sie den aktuellen Status des Containers:
docker inspect -f '{{.State.Status}}' nginx-detached
Diese Befehle verwenden Go-Templates, um die Ausgabe zu filtern. Das Flag -f ermöglicht es uns, ein Format-Template anzugeben.
Lassen Sie uns auch die Port-Zuweisungen überprüfen:
docker port nginx-detached
Port-Mapping ermöglicht es Containern, mit dem Host-System oder externen Netzwerken zu kommunizieren. Es leitet einen Port am Host-System an einen Port innerhalb des Containers weiter. Dies ist entscheidend, um auf Dienste, die in Containern laufen, von außerhalb der Docker-Umgebung zuzugreifen.
Wenn keine Ports zugewiesen sind, erzeugt dieser Befehl keine Ausgabe. In unserem Fall haben wir für den nginx-detached-Container keine Ports explizit zugewiesen, daher werden Sie wahrscheinlich keine Ausgabe sehen.
Um das Port-Mapping zu demonstrieren, erstellen wir einen neuen Nginx-Container mit einer Port-Zuweisung:
docker run -d --name nginx-with-port -p 8080:80 nginx
Dieser Befehl leitet Port 8080 auf dem Host an Port 80 im Container weiter. Wenn wir nun die Port-Zuweisungen prüfen:
docker port nginx-with-port
Sollten Sie eine Ausgabe ähnlich dieser sehen:
80/tcp -> 0.0.0.0:8080
Das bedeutet, dass Datenverkehr an Port 8080 Ihres Host-Rechners an Port 80 im Container weitergeleitet wird, wo Nginx auf Anfragen wartet.
Arbeiten mit Container-Protokollen
Der Zugriff auf und das Verständnis von Container-Protokollen (Logs) ist für die Fehlersuche und Überwachung Ihrer Anwendungen unerlässlich.
Lassen Sie uns die Logs unseres Nginx-Containers ansehen:
docker logs nginx-detached
Dies zeigt alle Protokolle seit dem Start des Containers an. Um nur die aktuellsten Einträge zu sehen, können Sie die Option --tail verwenden:
docker logs --tail 10 nginx-detached
Dies zeigt nur die letzten 10 Log-Zeilen an.
Um die Logs in Echtzeit zu verfolgen (ähnlich wie tail -f), verwenden Sie die Option -f:
docker logs -f nginx-detached
Dadurch werden neue Log-Einträge kontinuierlich gestreamt, sobald sie generiert werden. Drücken Sie Strg+C, um den Log-Stream zu beenden.
Sie können sich auch Zeitstempel für Ihre Log-Einträge anzeigen lassen:
docker logs --timestamps nginx-detached
Dies kann besonders nützlich sein, um zeitkritische Probleme zu debuggen.
Ausführen von Befehlen in laufenden Containern
Docker ermöglicht es Ihnen, Befehle innerhalb eines laufenden Containers auszuführen, was für Debugging und Wartung unglaublich nützlich ist.
Führen wir zunächst einen einfachen Befehl in unserem Nginx-Container aus:
docker exec nginx-detached echo "Hello from inside the container"
Sie sollten "Hello from inside the container" in Ihrem Terminal sehen.
Holen wir uns nun eine interaktive Shell innerhalb des Containers:
docker exec -it nginx-detached /bin/bash
Sie befinden sich nun im Container. Lassen Sie uns ein wenig auf Entdeckungstour gehen:
ls /etc/nginx
cat /etc/nginx/nginx.conf
exit
Diese Befehle listen den Inhalt des Nginx-Konfigurationsverzeichnisses auf und zeigen die Hauptkonfigurationsdatei von Nginx an. Der Befehl exit bringt Sie zurück zur Shell Ihres Host-Systems.
Kopieren von Dateien zu und von Containern
Docker bietet eine Möglichkeit, Dateien zwischen Ihrem Host-System und Containern zu kopieren. Dies ist nützlich für Aufgaben wie das Aktualisieren von Konfigurationsdateien oder das Abrufen von Protokollen.
Erstellen wir zuerst eine einfache HTML-Datei auf unserem Host-System:
echo "<html><body><h1>Hello from host</h1></body></html>" > hello.html
Kopieren wir nun diese Datei in unseren Nginx-Container:
docker cp hello.html nginx-detached:/usr/share/nginx/html/hello.html
Wir können überprüfen, ob die Datei kopiert wurde, indem wir einen Befehl im Container ausführen:
docker exec nginx-detached cat /usr/share/nginx/html/hello.html
Sie sollten den Inhalt der HTML-Datei sehen.
Kopieren wir nun eine Datei vom Container auf unseren Host:
docker cp nginx-detached:/etc/nginx/nginx.conf ~/project/nginx.conf
Dies kopiert die Nginx-Konfigurationsdatei aus dem Container in unser aktuelles Verzeichnis auf dem Host.
Sie können die Kopie verifizieren:
ls -l ~/project/nginx.conf
Die Datei nginx.conf sollte in der Liste erscheinen.
Festlegen von Umgebungsvariablen in Containern
Umgebungsvariablen sind ein zentraler Weg, um Anwendungen zu konfigurieren, die in Containern laufen. Lassen Sie uns untersuchen, wie man sie setzt und verwendet.
Zuerst führen wir einen neuen Container mit einer Umgebungsvariablen aus:
docker run --name env-test -e MY_VAR="Hello, Environment" -d ubuntu sleep infinity
Dieser Befehl bewirkt Folgendes:
--name env-test: Benennt den Container "env-test".-e MY_VAR="Hello, Environment": Setzt eine Umgebungsvariable namens MY_VAR.-d: Führt den Container im Detached-Modus aus.ubuntu: Verwendet das Ubuntu-Image.sleep infinity: Hält den Container unbegrenzt am Laufen.
Verifizieren wir nun, dass unsere Umgebungsvariable gesetzt wurde:
docker exec env-test env | grep MY_VAR
Sie sollten MY_VAR=Hello, Environment in der Ausgabe sehen.
Wir können Umgebungsvariablen auch über eine Datei festlegen. Erstellen Sie eine Datei namens env_file mit folgendem Inhalt.
Sie können nano oder vim verwenden, um die Datei zu erstellen:
nano env_file
ANOTHER_VAR=From a file
YET_ANOTHER_VAR=Also from the file
Beenden Sie den Editor und speichern Sie die Datei, indem Sie Strg+X, dann Y und Enter drücken.
Starten wir nun einen weiteren Container unter Verwendung dieser Datei:
docker run --name env-file-test --env-file env_file -d ubuntu sleep infinity
Überprüfen Sie die Umgebungsvariablen in diesem neuen Container:
docker exec env-file-test env | grep -E "ANOTHER_VAR|YET_ANOTHER_VAR"
Sie sollten beide Variablen aus der Datei in der Ausgabe sehen.
Begrenzung von Container-Ressourcen
Docker ermöglicht es Ihnen, die Ressourcen (CPU und Arbeitsspeicher) zu begrenzen, die ein Container verbrauchen darf. Dies ist entscheidend für die Verwaltung der Ressourcenverteilung in Umgebungen mit mehreren Containern.
Starten wir einen Container mit Speicher- und CPU-Limits:
docker run --name limited-nginx -d --memory=512m --cpus=0.5 nginx
Dieser Befehl bewirkt Folgendes:
--name limited-nginx: Benennt den Container "limited-nginx".-d: Führt den Container im Detached-Modus aus.--memory=512m: Begrenzt den Container auf 512 Megabyte Arbeitsspeicher.--cpus=0.5: Begrenzt den Container auf maximal einen halben CPU-Kern.nginx: Verwendet das Nginx-Image.
Wir können diese Limits mit dem Befehl inspect verifizieren:
docker inspect -f '{{.HostConfig.Memory}}' limited-nginx
docker inspect -f '{{.HostConfig.NanoCpus}}' limited-nginx
Der erste Befehl gibt 536870912 aus (512 MB in Bytes), und der zweite gibt 500000000 aus (0,5 CPU in Nano-Einheiten).
Um zu sehen, wie sich diese Limits in Echtzeit auf den Container auswirken, können wir den Befehl stats verwenden:
docker stats limited-nginx
Dies zeigt einen Live-Stream der Statistiken zur Ressourcennutzung. Drücken Sie Strg+C, um die Statistik-Ansicht zu verlassen.
Zusammenfassung
In diesem Labor haben wir fortgeschrittene Techniken der Container-Verwaltung in Docker untersucht. Wir haben gelernt, wie man Container in verschiedenen Modi ausführt, ihren Lebenszyklus verwaltet, Container-Details inspiziert, mit Protokollen arbeitet, Befehle in laufenden Containern ausführt, Dateien kopiert, Umgebungsvariablen setzt und Container-Ressourcen begrenzt. Diese Fähigkeiten bilden eine solide Grundlage für die Arbeit mit Docker-Containern in komplexeren Szenarien.
Denken Sie daran, dass eine effektive Container-Verwaltung entscheidend für den Aufbau skalierbarer und wartbarer containerisierter Anwendungen ist. Während Sie Ihre Reise mit Docker fortsetzen, werden sich diese Fähigkeiten als unschätzbar wertvoll für das Debugging, die Optimierung und die Verwaltung Ihrer Container-Umgebungen erweisen.
Üben Sie diese Befehle weiter und erkunden Sie die Möglichkeiten von Docker. Je mehr Sie mit Containern arbeiten, desto sicherer und kompetenter werden Sie. Viel Erfolg beim Containerisieren!
