Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten

DockerDockerBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab erhalten Sie praktische Erfahrungen mit dem Befehl docker service create zur Bereitstellung und Verwaltung von Diensten in einem Docker Swarm. Sie werden lernen, wie Sie verschiedene Arten von Diensten erstellen und untersuchen, darunter einfache replizierte Dienste für Hochverfügbarkeit und Skalierbarkeit sowie globale Dienste, die auf jedem Knoten ausgeführt werden.

Darüber hinaus werden Sie erweiterte Dienstkonfigurationen erkunden, wie z. B. das Implementieren von Rolling-Update-Strategien für nahtlose Bereitstellungen, die Nutzung von Bind-Mounts und Umgebungsvariablen für Datenpersistenz und Konfiguration sowie das Anwenden von Platzierungsbeschränkungen und -präferenzen, um zu steuern, wo Ihre Dienstaufgaben innerhalb des Swarms ausgeführt werden. Durch die Durchführung dieser Schritte werden Sie ein solides Verständnis dafür entwickeln, wie Sie containerisierte Anwendungen in einer Docker-Swarm-Umgebung effektiv verwalten können.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") subgraph Lab Skills docker/run -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/ls -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/ps -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/exec -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/inspect -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/create -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} docker/pull -.-> lab-555224{{"Wie man den docker service create-Befehl verwendet, um Dienste zu deployen und zu verwalten"}} end

Erstellen eines einfachen replizierten Dienstes

In diesem Schritt lernen Sie, wie Sie einen einfachen replizierten Dienst in Docker Swarm erstellen. Ein replizierter Dienst ist ein Dienst, der mehrere identische Aufgaben im gesamten Swarm ausführt. Dies sorgt für Hochverfügbarkeit und Skalierbarkeit.

Zunächst stellen wir sicher, dass Docker läuft und dass Sie sich im richtigen Verzeichnis befinden.

docker version
pwd

Sie sollten eine Ausgabe sehen, die die Docker-Version und Ihr aktuelles Verzeichnis als /home/labex/project anzeigt.

Bevor wir einen Dienst erstellen, müssen wir das erforderliche Docker-Image herunterladen. Wir verwenden für dieses Beispiel das nginx-Image.

docker pull nginx:latest

Dieser Befehl lädt die neueste Version des nginx-Images von Docker Hub herunter.

Jetzt erstellen wir einen einfachen replizierten Dienst namens my-nginx-service mit 3 Replikaten.

docker service create --name my-nginx-service --replicas 3 nginx:latest

Dieser Befehl erstellt einen neuen Dienst namens my-nginx-service unter Verwendung des nginx:latest-Images und setzt die Anzahl der gewünschten Replikate auf 3. Docker Swarm verteilt dann diese 3 Aufgaben auf die verfügbaren Knoten im Swarm.

Um den Status des Dienstes und seiner Aufgaben zu überprüfen, können Sie die Befehle docker service ls und docker service ps verwenden.

docker service ls
docker service ps my-nginx-service

Der Befehl docker service ls listet alle im Swarm laufenden Dienste auf und zeigt deren ID, Namen, Modus, Replikate und Image an. Der Befehl docker service ps my-nginx-service zeigt die mit dem my-nginx-service verknüpften Aufgaben an, einschließlich ihres Zustands (z. B. "Running", "Shutdown"), des gewünschten Zustands und des Knotens, auf dem sie ausgeführt werden. Sie sollten 3 Aufgaben im Zustand "Running" sehen.

Erstellen eines globalen Dienstes und Überprüfen seiner Aufgaben

In diesem Schritt lernen Sie, wie Sie einen globalen Dienst in Docker Swarm erstellen. Im Gegensatz zu replizierten Diensten, die eine festgelegte Anzahl von Aufgaben ausführen, führt ein globaler Dienst genau eine Aufgabe auf jedem Knoten im Swarm aus, der die Einschränkungen des Dienstes erfüllt. Dies ist nützlich für Dienste wie Überwachungsagenten oder Protokollsammler, die auf jedem Knoten laufen müssen.

Wir verwenden für dieses Beispiel das busybox-Image. Zunächst laden wir das Image herunter.

docker pull busybox:latest

Dieser Befehl lädt die neueste Version des busybox-Images herunter.

Jetzt erstellen wir einen globalen Dienst namens my-global-service.

docker service create --name my-global-service --mode global busybox:latest sleep infinity

Dieser Befehl erstellt einen neuen Dienst namens my-global-service unter Verwendung des busybox:latest-Images. Die Option --mode global gibt an, dass es sich um einen globalen Dienst handelt. Der Befehl sleep infinity wird verwendet, um den Container unbegrenzt lang laufen zu lassen.

Um die Aufgaben des globalen Dienstes zu überprüfen, können Sie den Befehl docker service ps verwenden.

docker service ps my-global-service

Dieser Befehl zeigt die mit my-global-service verknüpften Aufgaben an. Da es sich um einen globalen Dienst handelt, sollten Sie für jeden Knoten in Ihrem Swarm eine Aufgabe sehen. In dieser Lab-Umgebung werden Sie wahrscheinlich nur eine Aufgabe sehen, da es nur einen Knoten gibt. Die Ausgabe zeigt den Zustand der Aufgabe, den gewünschten Zustand und den Knoten, auf dem sie ausgeführt wird.

Sie können auch die Dienstkonfiguration mit dem Befehl docker service inspect überprüfen.

docker service inspect my-global-service

Dieser Befehl liefert detaillierte Informationen über den Dienst, einschließlich seines Modus, der Replikate (die in der Dienstliste für einen globalen Dienst 0 sein werden, aber docker service ps zeigt die Aufgaben pro Knoten an) und anderer Konfigurationsdetails.

Erstellen eines Dienstes mit Replikaten und einer Rolling-Update-Richtlinie

In diesem Schritt lernen Sie, wie Sie einen replizierten Dienst erstellen und seine Rolling-Update-Richtlinie konfigurieren. Rolling Updates ermöglichen es Ihnen, Ihren Dienst auf eine neue Version zu aktualisieren, ohne Ausfallzeiten, indem Sie die Aufgaben schrittweise durch die neue Version ersetzen.

Wir verwenden weiterhin das nginx-Image. Erstellen wir einen replizierten Dienst namens my-nginx-update-service mit 5 Replikaten und einer Rolling-Update-Richtlinie.

docker service create \
  --name my-nginx-update-service \
  --replicas 5 \
  --update-delay 10s \
  --update-parallelism 2 \
  nginx:latest

Dieser Befehl erstellt einen Dienst mit folgenden Konfigurationen:

  • --name my-nginx-update-service: Legt den Namen des Dienstes fest.
  • --replicas 5: Legt die gewünschte Anzahl der Replikate auf 5 fest.
  • --update-delay 10s: Legt die Verzögerung zwischen der Aktualisierung jeder Gruppe von Aufgaben auf 10 Sekunden fest.
  • --update-parallelism 2: Legt die Anzahl der gleichzeitig zu aktualisierenden Aufgaben auf 2 fest.

Diese Update-Parameter definieren, wie der Dienst aktualisiert wird, wenn Sie eine neue Version des Images bereitstellen. Docker Swarm wird jeweils 2 Aufgaben aktualisieren und 10 Sekunden warten, bevor es die nächste Gruppe aktualisiert.

Sie können den Status des Dienstes und seine Aufgaben mit den Befehlen docker service ls und docker service ps überprüfen.

docker service ls
docker service ps my-nginx-update-service

Sie sollten my-nginx-update-service mit 5/5 Replikaten und die Aufgaben im Zustand "Running" sehen.

Jetzt simulieren wir eine Aktualisierung, indem wir das Image auf eine andere Version ändern. Wir verwenden das nginx:1.21-Image. Zunächst laden wir das Image herunter.

docker pull nginx:1.21

Jetzt aktualisieren wir den Dienst, um das nginx:1.21-Image zu verwenden.

docker service update --image nginx:1.21 my-nginx-update-service

Dieser Befehl initiiert ein Rolling Update. Docker Swarm beginnt, die nginx:latest-Aufgaben durch nginx:1.21-Aufgaben gemäß den zuvor konfigurierten Einstellungen für --update-parallelism und --update-delay zu ersetzen.

Sie können den Rolling-Update-Prozess beobachten, indem Sie wiederholt docker service ps my-nginx-update-service ausführen.

docker service ps my-nginx-update-service

Sie werden sehen, wie Aufgaben vom Zustand "Running" mit dem alten Image in den Zustand "Shutdown" wechseln und dann neue Aufgaben mit dem neuen Image starten und in den Zustand "Running" gelangen. Die Aktualisierung erfolgt in Gruppen zu je 2 Aufgaben mit einer Verzögerung von 10 Sekunden zwischen den Gruppen.

Erstellen eines Dienstes mit Bind-Mounts und Umgebungsvariablen

In diesem Schritt lernen Sie, wie Sie einen Dienst erstellen, der Bind-Mounts zur Datenpersistenz und Umgebungsvariablen zur Konfiguration der Anwendung im Container verwendet. Bind-Mounts ermöglichen es Ihnen, eine Datei oder ein Verzeichnis von der Hostmaschine in einen Container einzubinden, sodass die Daten für den Container zugänglich und auch nach Entfernen des Containers persistent bleiben. Umgebungsvariablen sind eine gängige Methode, um Konfigurationsinformationen an Anwendungen zu übergeben.

Zunächst erstellen wir ein Verzeichnis auf der Hostmaschine, das wir in den Container einbinden werden.

mkdir -p ~/project/html

Dieser Befehl erstellt ein Verzeichnis namens html in Ihrem ~/project-Verzeichnis.

Jetzt erstellen wir eine einfache HTML-Datei in diesem Verzeichnis.

echo "<h1>Hello from Bind Mount!</h1>" > ~/project/html/index.html

Dieser Befehl erstellt eine Datei namens index.html im ~/project/html-Verzeichnis mit dem Inhalt "

Hello from Bind Mount!

".

Wir verwenden erneut das nginx-Image. Erstellen wir einen replizierten Dienst namens my-nginx-volume-service mit 1 Replikat, indem wir das ~/project/html-Verzeichnis an das Standard-Webroot-Verzeichnis von Nginx im Container (/usr/share/nginx/html) binden und eine Umgebungsvariable festlegen.

docker service create \
  --name my-nginx-volume-service \
  --replicas 1 \
  --publish published=8080,target=80 \
  --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html \
  --env MY_VARIABLE=hello \
  nginx:latest

Lassen Sie uns die neuen Optionen analysieren:

  • --publish published=8080,target=80: Dies bildet Port 8080 auf der Hostmaschine auf Port 80 im Container ab, sodass Sie den Nginx-Webserver von Ihrer Hostmaschine aus zugreifen können.
  • --mount type=bind,source=/home/labex/project/html,target=/usr/share/nginx/html: Dies erstellt einen Bind-Mount. type=bind gibt den Mount-Typ an. source=/home/labex/project/html ist der Pfad auf der Hostmaschine. target=/usr/share/nginx/html ist der Pfad im Container, an dem das Host-Verzeichnis eingebunden wird.
  • --env MY_VARIABLE=hello: Dies legt eine Umgebungsvariable namens MY_VARIABLE mit dem Wert hello im Container fest.

Überprüfen Sie den Dienststatus und die Aufgaben:

docker service ls
docker service ps my-nginx-volume-service

Warten Sie, bis die Aufgabe im Zustand "Running" ist.

Jetzt können Sie den in einem Container laufenden Nginx-Webserver über http://localhost:8080 in einem Webbrowser oder mit curl aufrufen.

curl http://localhost:8080

Sie sollten den Inhalt der von Ihnen erstellten index.html-Datei sehen: <h1>Hello from Bind Mount!</h1>. Dies bestätigt, dass der Bind-Mount korrekt funktioniert.

Um die Umgebungsvariable zu überprüfen, können Sie einen Befehl im laufenden Container ausführen. Zunächst finden Sie die Task-ID des laufenden Dienstes.

docker service ps my-nginx-volume-service

Notieren Sie sich die Task-ID aus der Ausgabe. Verwenden Sie dann docker exec, um einen Befehl im Container auszuführen. Ersetzen Sie <task_id> durch die tatsächliche Task-ID.

docker exec < task_id > env | grep MY_VARIABLE

Dieser Befehl führt den env-Befehl im Container aus, der der Task-ID zugeordnet ist, und leitet die Ausgabe an grep MY_VARIABLE weiter, um die Umgebungsvariable zu finden. Sie sollten MY_VARIABLE=hello in der Ausgabe sehen.

Erstellen eines Dienstes mit Platzierungsbeschränkungen und -präferenzen

In diesem Schritt lernen Sie, wie Sie Platzierungsbeschränkungen und -präferenzen nutzen, um zu steuern, wo Ihre Dienstaufgaben innerhalb des Docker Swarms deployed werden. Platzierungsbeschränkungen sind harte Anforderungen, die ein Knoten erfüllen muss, damit eine Aufgabe auf ihm geplant werden kann. Platzierungspräferenzen sind weiche Anforderungen, die die Planung beeinflussen, aber nicht verhindern, dass eine Aufgabe geplant wird, wenn kein Knoten die Präferenz erfüllt.

Zunächst lassen Sie uns den aktuellen Knoten untersuchen, um seine Labels (Bezeichnungen) zu sehen. Labels sind Schlüssel-Wert-Paare, die Sie an Knoten anhängen können, um Metadaten bereitzustellen.

docker node inspect self --format '{{ .Spec.Labels }}'

Dieser Befehl untersucht den aktuellen Knoten (identifiziert durch self) und formatiert die Ausgabe, um seine Labels anzuzeigen. Standardmäßig gibt es möglicherweise keine benutzerdefinierten Labels.

Fügen wir dem aktuellen Knoten ein Label hinzu. Wir werden das Label node_type=app hinzufügen.

docker node update --label-add node_type=app self

Dieser Befehl aktualisiert den aktuellen Knoten und fügt das Label node_type=app hinzu.

Jetzt überprüfen wir, ob das Label hinzugefügt wurde.

docker node inspect self --format '{{ .Spec.Labels }}'

Sie sollten map[node_type:app] in der Ausgabe sehen, was darauf hinweist, dass das Label erfolgreich hinzugefügt wurde.

Jetzt erstellen wir einen replizierten Dienst namens my-constrained-service mit einer Platzierungsbeschränkung, die erfordert, dass der Knoten das Label node_type=app hat. Wir verwenden das nginx-Image.

docker service create \
  --name my-constrained-service \
  --replicas 1 \
  --constraint 'node.labels.node_type == app' \
  nginx:latest

Dieser Befehl erstellt einen Dienst mit einer Beschränkung. --constraint 'node.labels.node_type == app' gibt an, dass Aufgaben für diesen Dienst nur auf Knoten geplant werden können, bei denen das Label node_type gleich app ist. Da wir dieses Label dem aktuellen Knoten hinzugefügt haben, sollte die Aufgabe hier geplant werden.

Überprüfen Sie den Dienststatus und die Aufgaben:

docker service ls
docker service ps my-constrained-service

Sie sollten my-constrained-service aufgeführt sehen und seine Aufgabe auf dem aktuellen Knoten laufen.

Jetzt erstellen wir einen anderen Dienst mit einer Platzierungspräferenz. Platzierungspräferenzen werden verwendet, um den Scheduler (Planer) zu leiten, werden aber nicht streng 强制执行。Wir verwenden das busybox-Image und bevorzugen Knoten mit dem Label node_type=database. Da unser aktueller Knoten dieses Label nicht hat, wird die Aufgabe dennoch auf dem aktuellen Knoten geplant, aber wenn es andere Knoten mit diesem Label gäbe, würde der Scheduler diese bevorzugen.

Zunächst laden wir das busybox-Image herunter.

docker pull busybox:latest

Jetzt erstellen wir den Dienst mit einer Platzierungspräferenz.

docker service create \
  --name my-preferred-service \
  --replicas 1 \
  --placement-pref 'spread=node.labels.node_type' \
  busybox:latest sleep infinity

Die Option --placement-pref 'spread=node.labels.node_type' teilt dem Scheduler mit, die Aufgaben auf Knoten zu verteilen, basierend auf dem Wert des node_type-Labels. In einem Multi-Knoten-Swarm mit verschiedenen node_type-Labels würde dies die Aufgaben gleichmäßiger verteilen. In dieser Ein-Knoten-Umgebung wird die Aufgabe einfach auf dem verfügbaren Knoten geplant.

Überprüfen Sie den Dienststatus und die Aufgaben:

docker service ls
docker service ps my-preferred-service

Sie sollten my-preferred-service aufgeführt sehen und seine Aufgabe auf dem aktuellen Knoten laufen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl docker service create verwendet, um Dienste in Docker Swarm zu deployen und zu verwalten. Wir haben begonnen, indem wir einen einfachen replizierten Dienst mit dem nginx-Image erstellt haben und dabei die gewünschte Anzahl von Replikaten für Hochverfügbarkeit und Skalierbarkeit angegeben haben. Anschließend haben wir docker service ls und docker service ps verwendet, um den Status des Dienstes zu überprüfen und seine laufenden Aufgaben zu untersuchen.

Anschließend haben wir die Erstellung eines globalen Dienstes untersucht und verstanden, wie er auf jedem geeigneten Knoten im Swarm eine Aufgabe ausführt. Dies hat die Flexibilität von Docker Swarm bei der Bereitstellung von Diensten basierend auf verschiedenen Anforderungen gezeigt.