Einführung
In diesem Lab lernen Sie, wie Sie den Befehl docker stack ps effektiv nutzen können, um Aufgaben innerhalb eines Docker-Stacks aufzulisten und zu verwalten. Sie beginnen damit, einen Beispiel-Stack mit Docker Compose bereitzustellen, einem leistungsstarken Tool zur Definition und Ausführung von Anwendungen mit mehreren Containern.
Nach der Bereitstellung des Stacks werden Sie die verschiedenen Funktionen von docker stack ps erkunden. Dazu gehört das Auflisten aller Aufgaben im Stack, das Filtern von Aufgaben anhand ihrer Namen, das Formatieren der Ausgabe zur Anzeige bestimmter interessierender Felder und schließlich das Anzeigen nur der Aufgaben-IDs für eine kompakte Ansicht. Diese praktische Erfahrung wird Sie mit den Fähigkeiten ausstatten, den Zustand der Aufgaben in Ihrem Docker-Stack zu überwachen und zu verstehen.
Einen Beispiel-Stack bereitstellen
In diesem Schritt lernen Sie, wie Sie einen Beispiel-Stack mit Docker Compose bereitstellen können. Docker Compose ist ein Tool zur Definition und Ausführung von Docker-Anwendungen mit mehreren Containern. Mit Compose verwenden Sie eine YAML-Datei, um die Dienste Ihrer Anwendung zu konfigurieren. Anschließend können Sie mit einem einzigen Befehl alle Dienste aus Ihrer Konfiguration erstellen und starten.
Da Docker Compose in der LabEx-Umgebung nicht vorinstalliert ist, müssen Sie es zuerst installieren. Wir werden Docker Compose Version 1.29.2 installieren, die mit der installierten Docker-Version kompatibel ist.
Zuerst laden Sie die Docker Compose-Binary herunter:
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
Dieser Befehl lädt die Docker Compose-Binary aus dem offiziellen GitHub-Repository herunter und speichert sie unter /usr/local/bin/docker-compose. Die Teile $(uname -s) und $(uname -m) erkennen automatisch Ihr Betriebssystem und Ihre Architektur.
Als Nächstes geben Sie der Binary ausführbare Berechtigungen:
sudo chmod +x /usr/local/bin/docker-compose
Dieser Befehl macht die heruntergeladene Datei ausführbar.
Jetzt überprüfen Sie die Installation, indem Sie die Docker Compose-Version prüfen:
docker-compose --version
Sie sollten eine Ausgabe ähnlich wie docker-compose version 1.29.2, build 5becea4c sehen.
Nachdem Docker Compose installiert ist, erstellen wir eine einfache Docker Compose-Datei, um unseren Stack zu definieren. Wir werden eine Datei namens docker-compose.yml im Verzeichnis ~/project erstellen.
Verwenden Sie den nano-Editor, um die Datei zu erstellen und zu bearbeiten:
nano ~/project/docker-compose.yml
Fügen Sie den folgenden Inhalt in die docker-compose.yml-Datei ein:
version: "3.8"
services:
web:
image: nginx:latest
ports:
- "80:80"
app:
image: alpine:latest
command: echo "Hello from Alpine"
Diese docker-compose.yml-Datei definiert zwei Dienste:
web: Verwendet dasnginx:latest-Image und bildet Port 80 auf dem Host auf Port 80 im Container ab.app: Verwendet dasalpine:latest-Image und führt einen einfachenecho-Befehl aus.
Speichern Sie die Datei, indem Sie Strg + S drücken, und verlassen Sie den Editor, indem Sie Strg + X drücken.
Bevor Sie den Stack bereitstellen, holen wir die erforderlichen Images. Obwohl Docker Compose die Images während der Bereitstellung automatisch herunterladen kann, kann es manchmal hilfreich sein, sie vorher explizit zu holen.
Holen Sie das nginx:latest-Image:
docker pull nginx:latest
Holen Sie das alpine:latest-Image:
docker pull alpine:latest
Jetzt stellen Sie den Stack mit dem Befehl docker-compose up bereit. Die Option -d führt die Container im detached-Modus (im Hintergrund) aus.
Navigieren Sie in das Verzeichnis ~/project, in dem Sie die docker-compose.yml-Datei erstellt haben:
cd ~/project
Führen Sie dann den Befehl aus:
docker-compose up -d
Dieser Befehl liest die docker-compose.yml-Datei und erstellt und startet die definierten Dienste. Sie sollten eine Ausgabe sehen, die die Erstellung und den Start der Dienste web und app anzeigt.
Um zu überprüfen, ob die Dienste ausgeführt werden, können Sie die laufenden Container auflisten:
docker ps
Sie sollten zwei laufende Container sehen, einen für den web-Dienst (basierend auf nginx) und einen für den app-Dienst (basierend auf alpine).
Alle Aufgaben im Stack auflisten
In diesem Schritt lernen Sie, wie Sie alle Aufgaben (Container) auflisten können, die mit dem Stack verbunden sind, den Sie im vorherigen Schritt bereitgestellt haben. In Docker Swarm oder Kubernetes wird der Begriff "Aufgabe" (engl. "task") oft verwendet, um auf eine laufende Instanz eines Dienstes zu verweisen. Obwohl wir hier Docker Compose verwenden, das technisch gesehen nicht auf die gleiche Weise wie Swarm das Konzept der "Aufgabe" nutzt, können wir dennoch die Container auflisten, die unseren bereitgestellten Stack bilden.
Der Befehl docker-compose ps wird verwendet, um die von Docker Compose verwalteten Container für das aktuelle Projekt (das Verzeichnis, das die docker-compose.yml-Datei enthält) aufzulisten.
Stellen Sie sicher, dass Sie sich noch im Verzeichnis ~/project befinden, in dem sich Ihre docker-compose.yml-Datei befindet:
cd ~/project
Jetzt führen Sie den Befehl docker-compose ps aus:
docker-compose ps
Dieser Befehl zeigt eine Liste der in Ihrer docker-compose.yml-Datei definierten Container zusammen mit ihrem aktuellen Zustand, Befehl und Ports an.
Sie sollten eine Ausgabe ähnlich wie diese sehen (Containernamen und -IDs können variieren):
Name Command State Ports
--------------------------------------------------------------------------------
project_app_1 /bin/sh -c echo "Hello fr ... Exit 0
project_web_1 /docker-entrypoint.sh ngin ... Up 0.0.0.0:80->80/tcp
Diese Ausgabe zeigt die beiden in Ihrer docker-compose.yml definierten Dienste: app und web. Die Spalte State gibt an, ob der Container läuft (Up) oder beendet wurde (Exit 0). Die Spalte Ports zeigt die Portzuordnung für den web-Dienst an.
Der app-Container ist beendet, weil sein Befehl echo "Hello from Alpine" die Ausführung beendet hat. Der web-Container läuft noch, weil der Nginx-Server so konzipiert ist, dass er kontinuierlich läuft.
Dieser Befehl ist nützlich, um schnell zu sehen, welche Dienste in Ihrem Stack laufen und welchen grundlegenden Status sie haben.
Aufgaben nach Namen filtern
In diesem Schritt lernen Sie, wie Sie die Liste der von Docker Compose verwalteten Container anhand ihres Dienstnamens filtern können. Dies ist nützlich, wenn Sie einen großen Stack mit vielen Diensten haben und nur den Status eines bestimmten Dienstes sehen möchten.
Der Befehl docker-compose ps ermöglicht es Ihnen, den Dienstnamen als Argument anzugeben, um die Ausgabe zu filtern.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden:
cd ~/project
Um nur den Container für den web-Dienst aufzulisten, führen Sie den folgenden Befehl aus:
docker-compose ps web
Dieser Befehl zeigt nur die Informationen für den Container an, der mit dem in Ihrer docker-compose.yml definierten web-Dienst verknüpft ist.
Sie sollten eine Ausgabe ähnlich wie diese sehen:
Name Command State Ports
--------------------------------------------------------------------------------
project_web_1 /docker-entrypoint.sh ngin ... Up 0.0.0.0:80->80/tcp
In ähnlicher Weise können Sie nur den Container für den app-Dienst aufzulisten, indem Sie folgenden Befehl ausführen:
docker-compose ps app
Dies zeigt die Informationen für den app-Container an:
Name Command State Ports
--------------------------------------------------------------------------------
project_app_1 /bin/sh -c echo "Hello fr ... Exit 0
Das Filtern nach Dienstnamen ist eine einfache, aber effektive Methode, um einzelne Komponenten in Ihrem Docker Compose-Stack zu verwalten und zu überwachen.
Das Ausgabeformat anpassen, um bestimmte Felder anzuzeigen
In diesem Schritt lernen Sie, wie Sie die Ausgabe des docker-compose ps-Befehls formatieren können, um nur bestimmte Felder anzuzeigen. Dies ist nützlich, wenn Sie bestimmte Informationen über Ihre Dienste extrahieren müssen, wie beispielsweise ihre Namen oder ihren Status, für Skripte oder weitere Verarbeitung.
Der docker-compose ps-Befehl unterstützt die Option --format, mit der Sie das Ausgabeformat mithilfe von Go-Templates angeben können.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden:
cd ~/project
Um nur den Dienstnamen und den Containerzustand anzuzeigen, können Sie folgenden Befehl verwenden:
docker-compose ps --format "table {{.Service}}\t{{.State}}"
Lassen Sie uns die --format-Option genauer betrachten:
"table": Dies gibt an, dass die Ausgabe in Tabellenformat mit Kopfzeilen sein soll.{{.Service}}: Dies ist ein Go-Template-Platzhalter, der den Dienstnamen darstellt.\t: Dies ist ein Tabulatorzeichen, das hier verwendet wird, um die Spalten zu trennen.{{.State}}: Dies ist ein Go-Template-Platzhalter, der den Containerzustand darstellt.
Die Ausgabe sieht wie folgt aus:
SERVICE STATE
app Exit 0
web Up
Sie können auch andere Felder in der Formatzeichenkette aufnehmen. Beispielsweise können Sie den Dienstnamen, das Image und den Zustand anzeigen:
docker-compose ps --format "table {{.Service}}\t{{.Image}}\t{{.State}}"
Die Ausgabe lautet dann:
SERVICE IMAGE STATE
app alpine:latest Exit 0
web nginx:latest Up
Die Verwendung der --format-Option bietet Flexibilität bei der Anzeige und Verarbeitung der Informationen über Ihre Docker Compose-Dienste.
Nur Task-IDs anzeigen
In diesem Schritt lernen Sie, wie Sie nur die Container-IDs für die Dienste in Ihrem Docker Compose-Stack anzeigen können. Dies ist besonders nützlich, wenn Sie Container-IDs an andere Befehle übergeben müssen, um Automatisierung oder Skripting durchzuführen.
Wir werden erneut die --format-Option mit dem docker-compose ps-Befehl verwenden, aber diesmal geben wir nur das Feld für die Container-ID an.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden:
cd ~/project
Um nur die Container-IDs anzuzeigen, verwenden Sie folgenden Befehl:
docker-compose ps -q
Die -q-Option ist eine Abkürzung für --quiet, die nur die Container-IDs ausgibt.
Alternativ können Sie dasselbe Ergebnis mit der --format-Option erzielen:
docker-compose ps --format "{{.ID}}"
Dieser Befehl verwendet das Go-Template {{.ID}}, um nur die Container-ID für jeden Dienst zu extrahieren.
Die Ausgabe beider Befehle ist eine Liste von Container-IDs, eine pro Zeile:
<container_id_for_app>
<container_id_for_web>
(Die tatsächlichen IDs werden in Ihrer Umgebung unterschiedlich sein).
Das Anzeigen nur der IDs ist eine häufige Anforderung, wenn Sie programmgesteuert mit Ihren Containern interagieren müssen, beispielsweise, um sie zu stoppen oder zu entfernen.
Abschließend bereinigen wir den bereitgestellten Stack, indem wir ihn herunterfahren. Dadurch werden die von docker-compose up erstellten Container und Netzwerke gestoppt und entfernt.
Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden:
cd ~/project
Führen Sie folgenden Befehl aus:
docker-compose down
Dieser Befehl stoppt und entfernt die Container für die web- und app-Dienste. Sie sollten eine Ausgabe sehen, die anzeigt, dass die Container und das Netzwerk entfernt werden.
Nachdem Sie docker-compose down ausgeführt haben, können Sie überprüfen, ob die Container nicht mehr laufen, indem Sie docker ps verwenden:
docker ps
Dieser Befehl sollte jetzt keine laufenden Container anzeigen.
Zusammenfassung
In diesem Lab haben Sie gelernt, wie Sie einen Beispiel-Stack mit Docker Compose bereitstellen können. Dies beinhaltete die Installation von Docker Compose, die Erstellung einer docker-compose.yml-Datei zur Definition von Diensten und anschließend die Bereitstellung des Stacks.
Nach der Bereitstellung werden Sie lernen, wie Sie den docker stack ps-Befehl verwenden, um alle Tasks innerhalb des bereitgestellten Stacks aufzulisten. Sie werden auch untersuchen, wie Sie diese Tasks nach Namen filtern, die Ausgabe formatieren, um bestimmte Felder anzuzeigen, und nur die Task-IDs anzeigen können. Dies zeigt die Flexibilität des docker stack ps-Befehls für die Überwachung und Verwaltung von Stack-Tasks.
