Verwendung des docker container run Befehls zur Container-Verwaltung

Einführung

In diesem Lab erhalten Sie praktische Erfahrung mit dem Befehl docker container run, um Container effektiv zu verwalten. Sie lernen, wie Sie Container im Detached-Modus für die Ausführung im Hintergrund starten und benutzerdefinierte Namen zur einfacheren Identifizierung vergeben.

Darüber hinaus werden Sie untersuchen, wie Sie sich mit laufenden Containern verbinden können, während STDIN geöffnet bleibt, Container-Ports auf den Host veröffentlichen, um externen Zugriff zu ermöglichen, Volumes mounten, um Datenpersistenz sicherzustellen, sowie Container durch das Setzen von Umgebungsvariablen und das Hinzufügen von Host-Einträgen konfigurieren. Diese grundlegenden Fähigkeiten sind essenziell für den Aufbau und die Verwaltung von Docker-basierten Anwendungen.

Skills Graph

Container im Detached-Modus ausführen und benennen

In diesem Schritt lernen Sie, wie Sie einen Docker-Container im Detached-Modus ausführen und ihm einen benutzerdefinierten Namen zuweisen. Das Ausführen eines Containers im Detached-Modus bedeutet, dass der Container im Hintergrund läuft und Sie seine Ausgabe nicht direkt im Terminal sehen. Das Zuweisen eines Namens erleichtert die spätere Identifizierung und Verwaltung des Containers.

Zuerst laden wir das hello-world-Image. Dies ist ein sehr kleines Image, das nützlich ist, um zu testen, ob Docker korrekt funktioniert.

docker pull hello-world

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Image heruntergeladen wird, und dann eine Bestätigungsmeldung, dass es erfolgreich heruntergeladen wurde.

Nun führen wir den hello-world-Container im Detached-Modus aus. Wir verwenden das Flag -d für den Detached-Modus und das Flag --name, um einen Namen zuzuweisen. Nennen wir diesen Container my-hello-world.

docker run -d --name my-hello-world hello-world

Nach Ausführung dieses Befehls gibt Docker eine lange Zeichenkette aus, die die Container-ID ist. Dies zeigt an, dass der Container im Hintergrund gestartet wurde.

Um zu überprüfen, ob der Container läuft, können Sie den Befehl docker ps verwenden. Dieser Befehl listet alle aktuell laufenden Container auf.

docker ps

Sie sollten eine Liste der laufenden Container sehen, und einer davon sollte den Namen my-hello-world tragen. Die Spalte STATUS sollte anzeigen, dass der Container vor einigen Sekunden beendet wurde. Der hello-world-Container ist darauf ausgelegt, kurz zu laufen, eine Nachricht auszugeben und dann zu beenden. Obwohl er beendet wurde, wird er von docker ps aufgelistet, da er im Detached-Modus ausgeführt wurde.

Um alle Container anzuzeigen, einschließlich der beendeten, können Sie den Befehl docker ps -a verwenden.

docker ps -a

Dies zeigt my-hello-world in der Liste an, zusammen mit seinem Status (Exited).

Mit einem laufenden Container verbinden und STDIN offen halten

In diesem Schritt lernen Sie, wie Sie sich mit einem laufenden Container verbinden und die Standardeingabe (STDIN) offen halten. Dies ist nützlich für die Interaktion mit einem Container, der einen Prozess ausführt, der Eingaben erwartet, wie beispielsweise eine Shell.

Im vorherigen Schritt haben wir den hello-world-Container ausgeführt, der sofort beendet wurde. Um das Anhängen zu demonstrieren, benötigen wir einen Container, der aktiv bleibt. Eine einfache Möglichkeit hierfür ist das Ausführen einer interaktiven Shell in einem Container.

Lassen Sie uns zunächst das ubuntu-Image herunterladen, ein gängiges Basis-Image für viele Anwendungen.

docker pull ubuntu

Nun führen wir einen ubuntu-Container im Detached-Modus (-d) aus, weisen ein pseudo-TTY (-t) zu und halten STDIN offen (-i). Wir vergeben ihm auch den Namen my-ubuntu. Der Befehl, den wir im Container ausführen, ist /bin/bash, der Pfad zur Bash-Shell.

docker run -itd --name my-ubuntu ubuntu /bin/bash

Das Flag -i hält STDIN offen, sodass Sie Eingaben an den Container senden können. Das Flag -t weist ein pseudo-TTY zu, das für interaktive Shell-Sitzungen notwendig ist. Das Flag -d führt den Container im Detached-Modus aus.

Sie sollten die Container-ID in Ihrem Terminal sehen, was anzeigt, dass der Container im Hintergrund läuft.

Nun verbinden wir uns mit dem laufenden my-ubuntu-Container über den Befehl docker attach.

docker attach my-ubuntu

Nach Ausführung dieses Befehls sollten Sie die Eingabeaufforderung der Bash-Shell innerhalb des ubuntu-Containers sehen. Sie sind nun mit den Standard-Ein-/Ausgabe- und Fehlerströmen des Containers verbunden.

Sie können nun mit der Shell des Containers interagieren. Beispielsweise können Sie den Befehl ls ausführen, um die Dateien im aktuellen Verzeichnis des Containers aufzulisten.

ls

Sie sollten den Inhalt des Root-Verzeichnisses (/) des Ubuntu-Containers sehen.

Um sich vom Container zu trennen, ohne ihn zu stoppen, müssen Sie eine bestimmte Tastenkombination verwenden: STRG+p gefolgt von STRG+q. Versuchen Sie nun, STRG+p und dann STRG+q zu drücken.

Sie sollten zur Eingabeaufforderung Ihres Host-Rechners zurückkehren. Der Container läuft weiterhin im Hintergrund. Dies können Sie mit docker ps überprüfen.

docker ps

Sie sollten my-ubuntu als laufenden Container aufgelistet sehen.

Wenn Sie einfach STRG+c drücken würden, während Sie verbunden sind, würde dies ein Signal an den im Container laufenden Prozess (die Bash-Shell) senden, was wahrscheinlich zum Stoppen des Containers führen würde. Die Verwendung von STRG+p gefolgt von STRG+q ist die Standardmethode, um sich zu trennen, ohne den Container zu stoppen.

Container-Ports auf dem Host veröffentlichen

In diesem Schritt lernen Sie, wie Sie Ports von einem Docker-Container auf den Host-Rechner veröffentlichen. Dadurch können Sie auf Dienste zugreifen, die innerhalb des Containers laufen, über das Netzwerk Ihres Hosts.

Zuerst stoppen und entfernen wir den my-ubuntu-Container aus dem vorherigen Schritt, um Konflikte zu vermeiden.

docker stop my-ubuntu
docker rm my-ubuntu

Sie sollten nach jedem Befehl den Namen des Containers sehen, was bestätigt, dass er gestoppt und entfernt wurde.

Nun werden wir einen einfachen Webserver in einem Container ausführen und dessen Port auf dem Host veröffentlichen. Wir verwenden das nginx-Image, einen beliebten Webserver.

Laden wir zunächst das nginx-Image herunter.

docker pull nginx

Jetzt führen wir einen nginx-Container im Detached-Modus (-d) aus und veröffentlichen Port 80 innerhalb des Containers auf Port 8080 des Host-Rechners. Wir verwenden das -p-Flag für die Portveröffentlichung im Format host_port:container_port. Zusätzlich vergeben wir ihm den Namen my-nginx.

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

Der Teil -p 8080:80 mappt Port 80 innerhalb des Containers (wo Nginx standardmäßig lauscht) auf Port 8080 Ihres Host-Rechners.

Sie sollten die Container-ID sehen, was anzeigt, dass der Container im Hintergrund läuft.

Um zu überprüfen, ob der Port korrekt veröffentlicht wurde und der Webserver erreichbar ist, können Sie den curl-Befehl auf Ihrem Host-Rechner verwenden, um auf localhost Port 8080 zuzugreifen.

curl http://localhost:8080

Sie sollten die Standard-Nginx-Willkommensseite als HTML-Ausgabe in Ihrem Terminal sehen. Dies bestätigt, dass Sie auf den im Container laufenden Nginx-Webserver über Port 8080 Ihres Hosts zugreifen können.

Sie können auch docker ps verwenden, um den laufenden Container und seine veröffentlichten Ports anzuzeigen.

docker ps

In der Ausgabe sollten Sie my-nginx sehen, und in der Spalte PORTS sollte 0.0.0.0:8080->80/tcp stehen, was anzeigt, dass Port 80 im Container auf Port 8080 aller Host-Schnittstellen gemappt ist.

Ein Volume mounten um Daten persistent zu speichern

In diesem Schritt lernen Sie, wie Sie Docker Volumes verwenden können, um von Containern generierte und genutzte Daten persistent zu speichern. Standardmäßig sind Daten innerhalb eines Containers ephemer (flüchtig) - sie gehen verloren, wenn der Container entfernt wird. Volumes bieten eine Möglichkeit, Daten außerhalb des Container-Dateisystems zu speichern, sodass sie auch nach dem Stoppen oder Entfernen des Containers erhalten bleiben.

Zuerst stoppen und entfernen wir den my-nginx-Container aus dem vorherigen Schritt.

docker stop my-nginx
docker rm my-nginx

Nun erstellen wir ein Docker Volume. Volumes werden von Docker verwaltet und in einem speziellen Bereich auf dem Host-Rechner gespeichert.

docker volume create my-volume

Sie sollten den Namen des Volumes (my-volume) sehen, was die erfolgreiche Erstellung bestätigt.

Sie können vorhandene Volumes mit dem Befehl docker volume ls auflisten.

docker volume ls

In der Liste sollten Sie my-volume sehen.

Jetzt führen wir einen neuen nginx-Container aus und mounten my-volume in das standardmäßige Nginx Webroot-Verzeichnis (/usr/share/nginx/html) im Container. Dadurch werden alle Dateien in diesem Container-Verzeichnis tatsächlich im my-volume auf dem Host gespeichert.

Wir starten den Container im Detached-Modus (-d), veröffentlichen Port 80 des Containers auf Port 8081 des Hosts (-p 8081:80), vergeben ihm einen Namen (my-nginx-volume) und verwenden das -v-Flag zum Mounten des Volumes. Das Format für benannte Volumes ist volume_name:container_path.

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

Die ausgegebene Container-ID zeigt an, dass der Container läuft.

Nun legen wir eine einfache HTML-Datei im gemounteten Volume ab. Dazu führen wir einen Befehl im laufenden Container mit docker exec aus. Wir erstellen eine Datei index.html in /usr/share/nginx/html mit einfachem Inhalt.

docker exec my-nginx-volume sh -c 'echo "<h1>Hello from the volume!</h1>" > /usr/share/nginx/html/index.html'

Dieser Befehl führt eine Shell (sh -c) im Container aus und erstellt die index.html-Datei.

Jetzt greifen wir auf den Webserver auf Port 8081 zu, um den Inhalt unserer Datei zu sehen.

curl http://localhost:8081

Sie sollten <h1>Hello from the volume!</h1> sehen. Dies bestätigt, dass die Datei im gemounteten Volume gespeichert wurde.

Um die Persistenz zu demonstrieren, stoppen und entfernen wir den Container.

docker stop my-nginx-volume
docker rm my-nginx-volume

Nun starten wir einen neuen Container mit demselben Volume. Wir nennen ihn my-nginx-volume-new und veröffentlichen Port 80 auf Host-Port 8082.

docker run -d --name my-nginx-volume-new -p 8082:80 -v my-volume:/usr/share/nginx/html nginx

Der neue Container verwendet dasselbe Volume. Wir greifen auf Port 8082 zu:

curl http://localhost:8082

Sie sollten immer noch <h1>Hello from the volume!</h1> sehen, da die Datei im Volume gespeichert blieb. Dies zeigt die Persistenzfunktion von Volumes unabhängig vom Container-Lebenszyklus.

Umgebungsvariablen setzen und Host-Einträge hinzufügen

In diesem Schritt lernen Sie, wie Sie Umgebungsvariablen für einen Docker-Container setzen und benutzerdefinierte Einträge zur /etc/hosts-Datei eines Containers hinzufügen. Umgebungsvariablen sind eine gängige Methode zur Konfiguration von Anwendungen in Containern, und das Hinzufügen von Host-Einträgen kann für Service Discovery oder das Überschreiben der DNS-Auflösung innerhalb des Containers nützlich sein.

Zuerst stoppen und entfernen wir den my-nginx-volume-new-Container aus dem vorherigen Schritt.

docker stop my-nginx-volume-new
docker rm my-nginx-volume-new

Nun führen wir einen einfachen Container aus und setzen eine Umgebungsvariable. Wir verwenden wieder das ubuntu-Image und führen einen Befehl aus, der den Wert einer Umgebungsvariable ausgibt. Wir setzen die Variable MY_VARIABLE mit dem Wert hello_docker. Das -e-Flag dient zum Setzen von Umgebungsvariablen im Format VARIABLE_NAME=wert.

docker run --rm -e MY_VARIABLE=hello_docker ubuntu env | grep MY_VARIABLE

In diesem Befehl:

• --rm entfernt den Container automatisch nach Beendigung
• -e MY_VARIABLE=hello_docker setzt die Umgebungsvariable im Container
• ubuntu ist das verwendete Image
• env gibt alle Umgebungsvariablen aus
• | grep MY_VARIABLE filtert die Ausgabe nach unserer Variable

Sie sollten MY_VARIABLE=hello_docker in der Ausgabe sehen, was das erfolgreiche Setzen bestätigt.

Als Nächstes lernen wir, wie man benutzerdefinierte Host-Einträge hinzufügt. Dazu verwenden wir das --add-host-Flag im Format hostname:ip_adresse.

Wir führen einen weiteren ubuntu-Container aus und fügen einen Eintrag hinzu, der my-service auf 192.168.1.100 abbildet. Anschließend zeigen wir die /etc/hosts-Datei an:

docker run --rm --add-host my-service:192.168.1.100 ubuntu cat /etc/hosts | grep my-service

Hierbei:

• --rm entfernt den Container nach Beendigung
• --add-host my-service:192.168.1.100 fügt den Host-Eintrag hinzu
• ubuntu ist das Image
• cat /etc/hosts zeigt die Hosts-Datei an
• | grep my-service filtert nach unserem Eintrag

Die Ausgabe sollte 192.168.1.100 my-service zeigen, was den erfolgreichen Eintrag bestätigt.

Sie können das Setzen von Umgebungsvariablen und das Hinzufügen von Host-Einträgen auch in einem einzigen docker run-Befehl kombinieren.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den docker run-Befehl zur Verwaltung von Containern verwenden. Sie begannen damit, einen Container im Detached-Modus mit dem -d-Flag auszuführen und ihm mit dem --name-Flag einen benutzerdefinierten Namen zuzuweisen, wobei Sie seinen Status mit docker ps und docker ps -a überprüften.

Anschließend haben Sie untersucht, wie Sie sich an einen laufenden Container anbinden können, während STDIN geöffnet bleibt, Container-Ports mit dem -p-Flag auf den Host veröffentlichen, um die Netzwerkzugänglichkeit zu gewährleisten, ein Volume mit dem -v-Flag mounten, um Datenpersistenz über den Lebenszyklus des Containers hinaus sicherzustellen, sowie die Umgebung des Containers konfigurieren, indem Sie Umgebungsvariablen mit dem -e-Flag setzen und Host-Einträge mit dem --add-host-Flag hinzufügen.