So verwenden Sie den docker stack deploy-Befehl, um Swarm-Services zu verwalten

Einführung

In diesem Lab lernen Sie, wie Sie Docker Swarm-Services effektiv mit dem Befehl docker stack deploy verwalten können. Wir beginnen damit, eine einfache docker-compose.yml-Datei vorzubereiten, die als Blaupause für unseren Anwendungsstack dient.

Nach der Vorbereitung stellen Sie diesen Stack in Ihrem Docker Swarm bereit, überprüfen, ob die definierten Services erfolgreich bereitgestellt wurden, und erkunden dann, wie Sie den Stack aktualisieren können, indem Sie die Compose-Datei ändern. Abschließend lernen Sie, wie Sie Services bereinigen können, die in der aktualisierten Konfiguration nicht mehr referenziert werden, um sicherzustellen, dass Ihr Swarm sauber und effizient bleibt.

Skills Graph

Vorbereitung einer einfachen docker-compose-Datei für die Swarm-Bereitstellung

In diesem Schritt bereiten wir eine einfache docker-compose.yml-Datei vor, die wir verwenden werden, um einen Stack in einem Docker Swarm bereitzustellen. Bevor wir docker-compose verwenden können, müssen wir es installieren.

Zunächst installieren wir docker-compose. Wir laden die Binärdatei herunter und machen sie ausführbar.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Dieser Befehl lädt die docker-compose-Binärdatei von der offiziellen GitHub-Releases-Seite herunter und speichert sie unter /usr/local/bin/docker-compose. Die Teile $(uname -s) und $(uname -m) erkennen automatisch Ihr Betriebssystem und Ihre Architektur. Der Befehl chmod +x macht die heruntergeladene Datei ausführbar.

Jetzt überprüfen wir die Installation, indem wir die Version prüfen.

docker-compose --version

Sie sollten die installierte Version von docker-compose in der Konsole sehen.

Als Nächstes erstellen wir eine einfache docker-compose.yml-Datei im Verzeichnis ~/project. Diese Datei wird einen einzelnen Service mithilfe des nginx-Images definieren.

nano ~/project/docker-compose.yml

Fügen Sie den folgenden Inhalt in den nano-Editor ein:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Lassen Sie uns diese docker-compose.yml-Datei analysieren:

• version: '3.8' gibt die Version des Compose-Dateiformats an. Version 3.8 ist für Swarm-Bereitstellungen geeignet.
• services: definiert die Services, die Ihre Anwendung bilden.
• web: ist der Name unseres Services. Sie können jeden beliebigen Namen wählen.
• image: nginx:latest gibt das Docker-Image an, das für diesen Service verwendet werden soll. Wir verwenden die neueste Version des offiziellen nginx-Images.
• ports: bildet Ports zwischen dem Host und dem Container ab. "80:80" bildet Port 80 auf dem Host auf Port 80 im Container ab.

Speichern Sie die Datei, indem Sie Strg + X, dann Y und anschließend Enter drücken.

Bevor wir diesen Service bereitstellen können, müssen wir sicherstellen, dass das nginx:latest-Image lokal verfügbar ist. Wir können das Image mit dem Befehl docker pull herunterladen.

docker pull nginx:latest

Dieser Befehl lädt das nginx:latest-Image von Docker Hub auf Ihren lokalen Rechner herunter.

Jetzt haben Sie eine einfache docker-compose.yml-Datei für die Bereitstellung vorbereitet und das erforderliche Image heruntergeladen.

Bereitstellung eines Stacks in einem Swarm mithilfe der Compose-Datei

In diesem Schritt werden wir den in unserer docker-compose.yml-Datei definierten Stack in einem Docker Swarm bereitstellen. Bevor wir einen Stack bereitstellen können, müssen wir einen Docker Swarm initialisieren.

Zunächst initialisieren wir den Swarm. Da wir eine einzelne virtuelle Maschine (VM) verwenden, initialisieren wir ihn als Ein-Knoten-Swarm.

docker swarm init

Dieser Befehl initialisiert einen neuen Swarm und macht den aktuellen Knoten zu einem Manager-Knoten. Sie sollten eine Ausgabe sehen, die anzeigt, dass der Swarm initialisiert wurde.

Nachdem der Swarm initialisiert ist, können wir unseren Stack mit dem Befehl docker stack deploy bereitstellen. Wir geben unserem Stack einen Namen, beispielsweise mywebstack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Lassen Sie uns diesen Befehl analysieren:

• docker stack deploy ist der Befehl, der verwendet wird, um einen Stack in einem Swarm bereitzustellen.
• -c ~/project/docker-compose.yml gibt die Compose-Datei an, die für die Bereitstellung verwendet werden soll. Wir verwenden die Datei, die wir im vorherigen Schritt erstellt haben.
• mywebstack ist der Name, den wir unserem Stack geben. Dieser Name wird verwendet, um die Services und Container, die zu diesem Stack gehören, innerhalb des Swarms zu identifizieren.

Nachdem Sie diesen Befehl ausgeführt haben, wird Docker Swarm die in der docker-compose.yml-Datei definierten Services erstellen. Sie sollten eine Ausgabe sehen, die anzeigt, dass die Services erstellt oder aktualisiert werden.

Um zu überprüfen, ob der Stack bereitgestellt wurde, können wir die laufenden Stacks auflisten.

docker stack ls

Dieser Befehl zeigt Ihnen eine Liste aller in Ihrem Swarm bereitgestellten Stacks an. Sie sollten mywebstack in der Liste sehen.

Wir können auch die innerhalb unseres Stacks laufenden Services auflisten.

docker stack services mywebstack

Dieser Befehl zeigt Ihnen die Services an, die mit dem mywebstack-Stack verknüpft sind. Sie sollten den mywebstack_web-Service in der Liste sehen, zusammen mit Informationen über seine Replikate und das Image.

Abschließend überprüfen wir den Status der Service-Tasks.

docker service ps mywebstack_web

Dieser Befehl zeigt die Tasks (laufende Container) für den mywebstack_web-Service an. Sie sollten mindestens einen Task mit dem Status Running sehen.

Sie haben nun erfolgreich einen Docker Swarm initialisiert und einen Stack mithilfe einer docker-compose.yml-Datei bereitgestellt.

Überprüfung der bereitgestellten Services

In diesem Schritt überprüfen wir, ob die im vorherigen Schritt bereitgestellten Services korrekt laufen und erreichbar sind. Wir haben einen Nginx-Webserver bereitgestellt, der auf Port 80 lauschen sollte.

Zunächst verwenden wir den Befehl docker service ls, um die Liste der im Swarm laufenden Services anzuzeigen.

docker service ls

Sie sollten den mywebstack_web-Service in der Liste sehen, mit 1/1 Replikaten, was darauf hinweist, dass eine Instanz des Services läuft.

Als Nächstes können wir curl verwenden, um auf den im Container laufenden Nginx-Webserver zuzugreifen. Da wir Port 80 auf dem Host auf Port 80 im Container gemappt haben, können wir ihn über localhost auf Port 80 erreichen.

curl localhost:80

Dieser Befehl sendet eine HTTP-Anfrage an localhost auf Port 80. Wenn der Nginx-Server korrekt läuft, sollten Sie die Standard-Nginx-Willkommensseite im HTML-Format als Ausgabe erhalten. Dies bestätigt, dass der Service läuft und vom Host-Rechner aus erreichbar ist.

Um den laufenden Container für den web-Service genauer zu untersuchen, können wir den Befehl docker ps verwenden.

docker ps

Dieser Befehl listet alle laufenden Container auf. Sie sollten einen Container sehen, der das nginx-Image ausführt, mit einem Namen ähnlich wie mywebstack_web.1.<task_id>. Die Spalte PORTS sollte 0.0.0.0:80->80/tcp anzeigen, was die Portzuordnung bestätigt.

Wir können auch die Details des Services mithilfe des Befehls docker service inspect untersuchen.

docker service inspect mywebstack_web

Dieser Befehl liefert detaillierte Informationen über den mywebstack_web-Service, einschließlich seiner Konfiguration, Tasks und Netzwerkeinstellungen. Sie können durch die Ausgabe scrollen, um verschiedene Details über den Service zu sehen.

Durch diese Prüfungen haben wir bestätigt, dass unser bereitgestellter Nginx-Service wie erwartet läuft und erreichbar ist.

Aktualisierung des Stacks mit einer geänderten Compose-Datei

In diesem Schritt werden wir unsere docker-compose.yml-Datei ändern, um den bereitgestellten Stack zu aktualisieren. Wir werden die Version des Nginx-Images ändern und einen zweiten Service hinzufügen.

Zunächst bearbeiten wir die docker-compose.yml-Datei.

nano ~/project/docker-compose.yml

Ändern Sie die Datei so, dass ein zweiter Service, beispielsweise ein alpine-Service, hinzugefügt wird, und ändern Sie die Version des Nginx-Images auf 1.21.6. Die aktualisierte Datei sollte wie folgt aussehen:

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"
  alpine:
    image: alpine:latest
    command: ["sleep", "infinity"]

Schauen wir uns die Änderungen an:

• Wir haben das image für den web-Service von nginx:latest auf nginx:1.21.6 geändert.
• Wir haben einen neuen Service namens alpine hinzugefügt.
• Der alpine-Service verwendet das alpine:latest-Image.
• Der Befehl command: ["sleep", "infinity"] lässt den alpine-Container unendlich lang laufen.

Speichern Sie die geänderte Datei, indem Sie Strg + X, dann Y und anschließend Enter drücken.

Bevor wir den aktualisierten Stack bereitstellen, müssen wir die neuen nginx:1.21.6- und alpine:latest-Images herunterladen.

docker pull nginx:1.21.6
docker pull alpine:latest

Jetzt können wir den aktualisierten Stack mit demselben docker stack deploy-Befehl und demselben Stacknamen bereitstellen. Docker Swarm erkennt die Änderungen in der docker-compose.yml-Datei und aktualisiert den vorhandenen Stack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm führt ein Rolling Update für den web-Service durch, indem es den alten nginx:latest-Container durch einen neuen mit nginx:1.21.6 ersetzt. Es erstellt auch den neuen alpine-Service und den entsprechenden Container. Sie sollten eine Ausgabe sehen, die anzeigt, dass die Services aktualisiert oder erstellt werden.

Um die Aktualisierung zu überprüfen, listen wir die Services im Stack erneut auf.

docker stack services mywebstack

Sie sollten jetzt sowohl den mywebstack_web- als auch den mywebstack_alpine-Service in der Liste sehen. Der mywebstack_web-Service sollte das aktualisierte Image nginx:1.21.6 anzeigen.

Sie haben Ihren bereitgestellten Stack erfolgreich aktualisiert, indem Sie die docker-compose.yml-Datei geändert und erneut bereitgestellt haben.

Entfernen von Services, die nicht mehr in der Compose-Datei referenziert werden

In diesem Schritt werden wir erneut unsere docker-compose.yml-Datei ändern, diesmal indem wir einen Service entfernen. Wenn wir den Stack erneut bereitstellen, erkennt Docker Swarm, dass ein Service nicht mehr in der Compose-Datei definiert ist und entfernt ihn. Dieser Prozess wird manchmal als "Pruning" (Entfernen) von Services bezeichnet.

Zunächst bearbeiten wir die docker-compose.yml-Datei, um den alpine-Service zu entfernen.

nano ~/project/docker-compose.yml

Entfernen Sie den gesamten alpine:-Abschnitt aus der Datei. Die Datei sollte wieder in ihren ursprünglichen Zustand zurückkehren und nur den web-Service definieren:

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"

Speichern Sie die geänderte Datei, indem Sie Strg + X, dann Y und anschließend Enter drücken.

Jetzt stellen wir den Stack erneut mit der geänderten docker-compose.yml-Datei bereit.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm vergleicht den aktuellen Zustand des mywebstack-Stacks mit der Definition in der aktualisierten docker-compose.yml-Datei. Es wird feststellen, dass der alpine-Service nicht mehr in der Datei vorhanden ist und wird den entsprechenden Service und seine Tasks aus dem Swarm entfernen. Sie sollten eine Ausgabe sehen, die anzeigt, dass der alpine-Service entfernt wird.

Um zu überprüfen, dass der alpine-Service entfernt wurde, listen wir die Services im Stack erneut auf.

docker stack services mywebstack

Sie sollten jetzt nur den mywebstack_web-Service in der Liste sehen. Der mywebstack_alpine-Service sollte verschwunden sein.

Schließlich können wir, um die Swarm-Umgebung aufzuräumen, den gesamten Stack entfernen.

docker stack rm mywebstack

Dieser Befehl entfernt den mywebstack-Stack, einschließlich aller seiner Services und Tasks. Sie sollten eine Ausgabe sehen, die die Entfernung bestätigt.

Um zu überprüfen, dass der Stack entfernt wurde, listen wir die Stacks erneut auf.

docker stack ls

Der mywebstack sollte nicht mehr in der Liste erscheinen.

Sie haben erfolgreich einen Service aus Ihrem Stack entfernt, indem Sie ihn aus der docker-compose.yml-Datei gelöscht und den Stack erneut bereitgestellt haben, und haben dann die Umgebung aufgeräumt, indem Sie den gesamten Stack entfernt haben.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl docker stack deploy verwendet, um Docker Swarm-Services zu verwalten. Wir haben begonnen, indem wir eine einfache docker-compose.yml-Datei vorbereitet haben, die der Standardweg ist, um Mehr-Service-Anwendungen für Docker zu definieren. Dies beinhaltete die Installation von docker-compose und die Erstellung einer grundlegenden YAML-Datei, die einen einzelnen Nginx-Service mit Portzuordnung definiert.

Nach der Vorbereitung haben wir diesen Stack mit docker stack deploy in einem Docker Swarm bereitgestellt, die erfolgreiche Bereitstellung des Services überprüft und dann das Aktualisieren des Stacks geübt, indem wir die docker-compose.yml-Datei geändert und erneut bereitgestellt haben. Schließlich haben wir gelernt, wie man Services entfernt, die nicht mehr in der aktualisierten Compose-Datei definiert sind, um sicherzustellen, dass unsere Swarm-Umgebung sauber bleibt und die aktuelle Anwendungsdefinition widerspiegelt.