So installierst du Docker Swarm auf Ubuntu 22.04

Docker Swarm ist eine Container-Orchestrierung, die auf der Docker Engine aufbaut. Sie ermöglicht es dir, einen Cluster von Docker-Knoten auf mehreren Servern zu erstellen und einzusetzen. Docker Swarm vereinfacht die Bereitstellung deiner containerisierten Anwendung in einem Dienst. Es bietet eine einfache und unkomplizierte Möglichkeit, Container zu verwalten und zu orchestrieren.

Docker Swarm bietet ein hohes Maß an verfügbaren Anwendungen. In Docker Swarm kannst du eine einzelne Anwendung oder einen Dienst auf mehreren Nodes ausführen, die „Worker Nodes“ genannt werden. Außerdem gibt es einen Knoten namens „Swarm Manager“, der die zentrale Verwaltung und Orchestrierung des Docker Swarms übernimmt.

In diesem Tutorial zeigen wir dir Schritt für Schritt, wie du die Docker Swarm Software auf Ubuntu 22.04 Servern installierst.

Voraussetzungen

Um diese Anleitung durchzuführen, musst du über folgende Voraussetzungen verfügen:

• 3 Ubuntu 22.04 Server – Einer wird als Swarm Master/Manager und zwei Server werden als Worker Nodes verwendet.
• Einen Nicht-Root-Benutzer mit sudo-Administrator-Rechten.

Einrichten der Systeme

Bevor du Docker installierst und Docker Swarm konfigurierst, musst du deine Systeme vorbereiten, indem du die folgenden Aufgaben erledigst:

• Öffne Ports für Docker Swarm: Du musst einige Ports, die von Docker Swarm verwendet werden, auf allen deinen Servern öffnen. Das kannst du über die UFW (Uncomplicated Firewall) erreichen.
• Hinzufügen des Docker-Repositorys: Du wirst das offizielle Docker Repository verwenden, um die Docker Engine auf all deinen Servern zu installieren.

Ports für Docker Swarm öffnen

Im folgenden Abschnitt öffnest du Port 22 für SSH und die Ports 2377, 7946 und 4789 für Docker Swarm über die UFW (Uncomplicated Firewall) auf dem Swarm Master/Manager und den Swarm Nodes. Die UFW ist standardmäßig installiert, aber noch nicht gestartet.

Führe zunächst den unten stehenden ufw-Befehl aus, um das OpenSSH-Anwendungsprofil hinzuzufügen und den standardmäßigen SSH-Port 22 zu öffnen. Starte dann die UFW und aktiviere sie.

sudo ufw allow OpenSSH
sudo ufw enable

Gib y ein, um fortzufahren, und du solltest die Ausgabe Firewall ist aktiv und beim Systemstart aktiviert erhalten.

Führe nun den folgenden Befehl aus, um die Ports zu öffnen, die von den Diensten deines Swarm-Einsatzes verwendet werden sollen. In diesem Fall wirst du den Diensten Ports zwischen 30000 und 35000 zuweisen.

sudo ufw allow 30000:35000/tcp

Als Nächstes führst du den folgenden Befehl aus, um Ports für Docker Swarm zu öffnen.

for ports in 2377/tcp 7946/tcp 7946/udp 4789/udp
do
sudo ufw allow $ports
done

Zum Schluss lädst du UFW neu und überprüfst den UFW-Status, indem du den folgenden Befehl ausführst.

sudo ufw reload
sudo ufw status

Du solltest sehen, dass das OpenSSH-Anwendungsprofil und die Ports für Docker Swarm (2377, 7946 und 4789) auf der UFW aktiviert sind.

Hinzufügen des Docker-Repositorys

Nachdem du die UFW konfiguriert hast, musst du das offizielle Docker-Repository zu deinen Servern hinzufügen. Du wirst das offizielle Docker Repository für die Installation der Docker Engine verwenden.

Führe den unten stehenden Befehl aus, um einige grundlegende Pakete auf deinen Ubuntu-Servern zu installieren.

sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release -y

Als Nächstes führst du den unten stehenden Befehl aus, um den Docker GPG-Schlüssel und das Repository zu deinen Systemen hinzuzufügen.

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Zum Schluss aktualisierst du dein Ubuntu-Repository auf jedem Server, indem du den unten stehenden Befehl ausführst.

sudo apt update

Du solltest sehen, dass das Docker-Repository während des Vorgangs abgerufen wird.

Installation der Docker-Engine

Nachdem du deine Ubuntu-Systeme vorbereitet hast, installierst du die Docker Engine auf diesen Servern.

Installiere die Docker Engine auf deinen Ubuntu-Systemen mit dem unten stehenden Befehl. Gib y ein, um die Installation zu bestätigen.

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Sobald die Installation abgeschlossen ist, führe den folgenden systemctl-Befehl aus, um den Docker-Dienst zu überprüfen und sicherzustellen, dass der Dienst läuft.

sudo systemctl is-enabled docker
sudo systemctl status docker

In der folgenden Ausgabe solltest du sehen, dass der Dockerdienst läuft und aktiviert ist.

(Optional): Erlaube Nicht-Root das Ausführen von Docker Containern

Wenn du Docker Swarm einsetzt und Container mit einem Nicht-Root-Benutzer ausführst, musst du deinen Benutzer zur Docker-Gruppe hinzufügen, damit er den Docker-Befehl ausführen und Container starten kann.

Führe den Befehl usermod aus, um deinen aktuellen Benutzer zur Docker-Gruppe hinzuzufügen.

sudo usermod -aG docker username

Melde dich nun als Nicht-Root-Benutzer an und führe den unten stehenden docker-Befehl aus, um deine Konfiguration zu überprüfen.

su - username
docker run hello-world

Wenn die Konfiguration erfolgreich war, solltest du in der Lage sein, den Container hello-world auszuführen und die folgende Ausgabe zu erhalten:

Docker Swarm erstellen

Jetzt, wo du die Docker Engine installiert hast, kannst du Docker mit deinen Ubuntu-Servern erstellen und starten. In diesem Beispiel werden wir einen Server als Swarm Master/Manager und zwei Server als Worker Nodes verwenden.

Führe die folgenden Aufgaben aus, um Docker Swarm einzurichten:

• Initialisierung des Swarm-Modus auf dem Master/Manager.
• Hinzufügen von Worker Nodes zum Docker Swarm.

Los geht’s.

Initialisierung des Swarm-Modus auf dem Master/Manager

Um Docker Swarm zu initialisieren, führe den folgenden Befehl docker swarm init aus. Der zusätzliche Parameter –advertise-addr bindet den Docker Swarm an eine bestimmte IP-Adresse, und der Parameter –default-addr-pool legt die interne IP-Adresse für die Container fest, die im Swarm laufen.

In diesem Beispiel bindet sich der Docker Swarm an die IP-Adresse 192.168.5.30 und der IP-Adresspool für Container ist 10.20.0.0/16.

docker swarm init --advertise-addr 192.168.5.30 --default-addr-pool 10.20.0.0/16

Wenn der Initialisierungsprozess erfolgreich ist, wird die folgende Ausgabe angezeigt. In der Ausgabe solltest du das generierte Token für das Hinzufügen von Nodes zu Docker Swarm sehen.

Als Nächstes führst du den folgenden Befehl aus, um den Status des Swarm-Modus zu überprüfen.

docker info

Wenn der Swarm-Modus aktiviert ist, solltest du die Ausgabe Swarm: active mit Details zur NodeID und dem Status von Manager und Node erhalten.

Führe abschließend den folgenden Befehl aus, um die Liste der Knoten im Docker Swarm zu überprüfen.

docker node ls

Zu diesem Zeitpunkt ist nur ein Knoten in deinem Docker Swarm verfügbar, nämlich der Swarm Master/Manager.

Hinzufügen von Worker Nodes zu Docker Swarm

Wenn der Docker Swarm initialisiert ist, kannst du deinem Docker Swarm Worker Nodes hinzufügen.

Führe zunächst den unten stehenden Befehl aus, um das generierte Token für den Worker Node anzuzeigen.

docker swarm join-token worker

Du solltest Anweisungen zum Hinzufügen von Worker Nodes sehen, die auch das Token enthalten.

Gehe nun zu dem Worker Node und füge ihn dem Docker Swarm hinzu, indem du den unten stehenden Befehl docker swarm join ausführst.

docker swarm join --token SWMTKN-1-0i6kbe2oek1iw19jfpvd2j5l0dhfmssz4w505aeihx7ouz8wqc-2dbk7cnmo12uunj53eywwnqr7 192.168.5.30:2377

Wenn der Vorgang erfolgreich war, wird die Ausgabe „Dieser Node ist einem Swarm als Worker beigetreten“ auf deinem Bildschirm erscheinen.

Gehe dann zurück zum Swarm Master/Manager und führe den unten stehenden Befehl aus, um die Liste der verfügbaren Nodes zu überprüfen.

docker node ls

Wenn alles klappt, sind drei Server im Docker Swarm verfügbar: 1 der Swarm Manager und 2 Worker Nodes mit dem Status Ready and availability is running.

Dienst in Docker Swarm ausführen

Jetzt hast du erfolgreich einen Docker Swarm mit drei Ubuntu-Servern erstellt. Jetzt erfährst du, wie du deine Anwendung in den Docker Swarm deployen kannst, was als Service bezeichnet wird. Ein Service ist ein Abbild deiner Microservice-Anwendung. Das kann ein HTTP-Server, ein Datenbankserver oder eine andere Anwendung sein.

In diesem Beispiel wirst du einen einfachen HTTP-Dienst mit einem Nginx-Image bereitstellen.

Führe den unten stehenden Befehl aus, um einen neuen Dienst in deinem Swarm zu erstellen. In diesem Beispiel erstellst du einen neuen Dienst test-nginx mit 1 Replikat, dem Port 30001 und dem Image nginx:alpine.

docker service create --replicas 1 --name test-nginx -p 30001:80 nginx:alpine

Überprüfe nun die Details des Dienstes test-nginx mit dem unten stehenden Befehl.

docker service inspect test-nginx
docker service inspect --pretty test-nginx

Du solltest detaillierte Informationen über den test-nginx-Dienst wie die folgenden sehen.

Als Nächstes überprüfst du die Liste der Docker-Dienste im Docker Swarm mit dem unten stehenden Befehl.

docker service ls
docker service ps test-nginx

Wenn dies erfolgreich war, solltest du sehen, dass der Dienst test-nginx auf dem NODE Manager mit 1 Replikat und dem Port 30001 läuft.

Greife schließlich mit dem folgenden curl-Befehl über die IP-Adresse des Hosts mit Port 30001 auf den test-nginx-Dienst zu.

curl 192.168.5.30:30001
curl -I 192.168.5.30:30001

Du solltest die index.html Quellcode-Seite und die Details der HTTP-Header sehen.

Dienst in Docker Swarm skalieren

Nachdem du den Docker-Dienst bereitgestellt hast, besteht die nächste Aufgabe darin, den Dienst in Docker Swarm zu skalieren. Dadurch wird die gewünschte Replikation deiner Dienste über die Worker Nodes hinweg erreicht.

Um einen Dienst zu skalieren, führst du den unten stehenden Befehl docker service scale aus. In diesem Fall skalierst du den Dienst test-nginx auf 3 Replikate.

docker service scale test-nginx=3

Führe nun den folgenden Befehl aus, um den test-nginx-Dienst zu überprüfen. Wenn der Dienst test-nginx skaliert wurde, solltest du zwei weitere Dienste sehen, die von Docker erstellt wurden und auf beiden Worker Nodes laufen.

docker service ps test-nginx

Gehe zum Terminal des Arbeiterknotens und führe den folgenden Befehl aus, um sicherzustellen, dass der Dienst test-nginx läuft.

docker ps
curl 192.168.5.31:30001

Wenn alles gut läuft, solltest du den Container test-nginx.RANDOM-STRING mit dem Status Up auf jedem der Worker Nodes sehen.

Löschen des Dienstes in Docker Swarm

Um deine Umgebung aufzuräumen, löschst du den Dienst test-nginx aus Docker Swarm und entfernst das Docker-Image nginx:alpine.

Lösche den Dienst test-nginx und überprüfe die Liste der verfügbaren Dienste in Docker Swarm mit dem folgenden Befehl.

docker service rm test-nginx
docker service ps

Entferne nun das nginx:alpine-Image und überprüfe die Liste der heruntergeladenen Images für jeden Server mit dem folgenden Befehl.

docker rmi nginx:alpine
docker images

Fazit

Zum Schluss hast du Docker Swarm unter Ubuntu 22.04 Schritt für Schritt erfolgreich installiert. Du hast Docker Swarm mit drei Ubuntu-Servern eingerichtet und gelernt, wie du Anwendungen oder Dienste in Docker Swarm einrichten, skalieren und entfernen kannst.