Docker-Orchestration mit Swarm und Compose

Mit der Container-Plattform Docker verteilen Sie Anwendungen als Tasks schnell, komfortabel und ressourcensparend im Netzwerk. Alles, was Sie dazu benötigen, ist der Cluster-Manager Swarm, der seit Docker-Version 1.12.0 als „Swarm-Mode“ nativer Teil der Docker-Engine und damit der Kernsoftware der Container-Plattform ist. Docker Swarm erlaubt es Ihnen, Container-Anwendungen zu skalieren, indem Sie diese in beliebig vielen Instanzen auf beliebig vielen Knoten Ihres Netzwerks betreiben. Möchten Sie hingegen eine Multi-Container-Anwendung – bei Docker „Stack“genannt – im Cluster ausführen, greifen Sie auf das Docker-ToolComposezurück. Wir erklären Ihnen die Grundkonzepte der Docker-Orchestrierung mit Swarm und Compose und verdeutlichen die Implementierung anhand von Codebeispielen.

Docker Swarm

Bei Swarm handelt es sich um eine Software der Docker-Entwickler, die eine beliebige Anzahl von Docker-Hosts zu einem Cluster zusammenfasst und ein zentrales Cluster-Management sowie die Orchestrierung von Containern ermöglicht. Bis Docker-Version 1.11 musste Swarm als separates Tool implementiert werden. Neuere Versionen der Container-Plattform unterstützen einen nativen Swarm-Mode. Der Cluster-Manager steht somit jedem Docker-Nutzer mit Installation der Docker-Engine zur Verfügung.

Docker Swarm liegt eine Master-Slave-Architektur zugrunde. Jedes Docker-Cluster (der Schwarm) besteht aus mindestens einem Manager- und beliebig vielen Worker-Knoten. Während der Swarm-Manager für die Verwaltung des Clusters und die Delegation von Aufgaben verantwortlich ist, übernehmen die Swarm-Worker die Ausführung von Arbeitseinheiten („Tasks“). Dabei werden Container-Anwendungen als sogenannte „Services“ auf beliebig viele Docker-Konten verteilt.

In der Docker-Terminologie bezeichnet der Begriff „Service“ eine abstrakte Struktur, mit der Sie Aufgaben definieren, die im Cluster ausgeführt werden sollen. Jeder Service besteht aus einem Set einzelner Tasks, die jeweils in einem eigenen Container auf einem der Knoten im Cluster bearbeitet werden. Wenn Sie einen Service erstellen, bestimmen Sie, welches Container-Image diesem zugrunde liegt und welche Befehle in dem Container laufen, der auf Basis des Images ausgeführt wird. Docker Swarm unterstützt zwei Modi, in denen Swarm-Services definiert werden: Wählen Sie zwischen replizierten und globalen Services.

  • Replizierte Services: Bei einem replizierten Service handelt es sich um einen Task, der in einer benutzerdefinierten Anzahl von Replikaten ausgeführt wird. Jedes Replikat ist eine Instanz des im Service definierten Docker-Containers. Replizierte Services lassen sich skalieren, indem Nutzer weitere Replikate erzeugen. Ein Webserver wie NGINX lässt sich beispielsweise je nach Bedarf mit einer einzigen Befehlszeile auf 2, 4 oder 100 Instanzen skalieren.

  • Globale Services: Wird ein Service im globalen Modus ausgeführt, startet jeder verfügbare Knoten im Cluster einen Task für den entsprechenden Service. Wird dem Cluster ein neuer Knoten hinzugefügt, teilt der Swarm-Manager diesem unverzüglich einen Task für den globalen Service zu. Globale Services eignen sich beispielsweise für Monitoring-Anwendungen oder Antivirenprogramme.

Ein zentrales Anwendungsfeld von Docker Swarm ist die Lastenverteilung. Im Swarm-Modus verfügt Docker über integrierte Load-Balancing-Funktionen. Führen Sie beispielweise einen NGINX-Webserver mit 4 Instanzen aus, verteilt Docker eingehende Anfragen intelligent auf die zur Verfügung stehenden Webserver-Instanzen.

Docker Compose

Docker Compose ermöglicht es Ihnen, Multi-Container-Anwendungen – sogenannte „Stacks“ – zu definieren und wahlweise auf einem einzelnen Docker-Knoten oder im Cluster auszuführen. Dabei stellt das Tool Kommandozeilenbefehle bereit, mit denen Sie den gesamten Lebenszyklus Ihrer Anwendungen verwalten.

Docker definiert Stacks als Gruppen miteinander verknüpfter Services, die Software-Abhängigkeiten teilen und gemeinsam orchestriert und skaliert werden. Ein Docker-Stack erlaubt es Ihnen, verschiedene Funktionalitäten einer Anwendung in einer zentralen Datei – der docker-compose.yml –zu definieren, aus dieser heraus zu starten, gemeinsam in einer isolierten Laufzeitumgebung auszuführen und zentral zu verwalten.

Je nachdem, auf welchem Betriebssystem Sie Docker betreiben, muss Compose eventuell separat installiert werden.

Nutzen Sie die Container-Plattform Docker im Rahmen der Desktop-Installationen Docker for Mac oder Docker for Windows, ist Docker Compose bereits im Funktionsumfang enthalten. Das Gleiche gilt für die Docker-Toolbox, die für ältere Mac- oder Windows-Systeme zur Verfügung steht. Verwenden Sie Docker hingegen unter Linux oder auf dem Windows Server 2016, ist eine manuelle Installation des Tools erforderlich.

Compose-Installation unter Linux

Öffnen Sie das Terminal und führen Sie folgenden Befehl aus, um die Compose-Binärdateien aus dem GitHub-Repositorium herunterzuladen:

sudo curl -L https://github.com/docker/compose/releases/download/1.18  
.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

Räumen Sie allen Benutzern das Recht ein, die Binärdateien auszuführen:

sudo chmod +x /usr/local/bin/docker-compose

Ob das Tool korrekt installiert wurde, testen Sie mit dem Befehl:

docker-compose -version

War die Installation erfolgreich, erhalten Sie die Versionsnummer des Tools als Terminalausgabe.

Compose-Installation unter Windows Server 2016 (nur Docker EE for Windows)

Starten Sie die PowerShell als Administrator und führen Sie den folgenden Befehl aus, um den Download der Compose-Binärdateien aus dem GitHub-Repositorium zu starten:

Invoke-WebRequest 
"https://github.com/docker/compose/releases/download/1.18.0/docker-compose-
Windows-x86_64.exe" -UseBasicParsing -OutFile
$Env:ProgramFiles\docker\docker-compose.exe

Starten Sie die ausführbare Datei, um Docker Compose zu installieren.

Hinweis

Weitere Informationen zu Docker-Tools wie Swarm und Compose finden Sie in unserem Artikel über das Docker-Ökosystem.

Tutorial: Docker Swarm und Compose in der Anwendung

Um Multi-Container-Apps mit Docker im Cluster betreiben zu können, benötigen Sie einen Schwarm – ein Cluster von Docker-Engines im Swarm-Mode – sowie das Docker-Tool Compose.

Wie Sie mit Docker in wenigen Schritten zum eigenen Schwarm gelangen, erfahren Sie im ersten Teil unseres Tutorials. Das Erstellen von Multi-Container-Apps mit Docker Compose sowie das Deployment im Cluster sind Thema des zweitens Teils.

Tipp

Eine Einführung zu Docker sowie eine Schritt-für-Schritt Anleitung zur Installation der Docker-Engine unter Linux finden Sie in unserem Grundlagenartikel zur Container-Plattform.

Teil 1: Docker im Swarm-Mode

Bei einem Schwarm handelt es sich um eine beliebige Anzahl von Docker-Engines im Swarm-Mode. Jede Docker-Engine läuft auf einem separaten Knoten und bindet diesen ins Cluster ein.

Die Erstellung von Docker-Clustern umfasst drei Schritte:

  1. Docker-Hosts bereitstellen
  2. Swarm initialisieren
  3. Docker-Hosts in den Schwarm einbinden
Hinweis

Alternativ kann eine einzelne Docker-Engine in einer lokalen Entwicklungsumgebung in den Swarm-Mode versetzt werden. Man spricht in diesem Fall von einem Single-Node-Swarm.

Schritt 1: Docker-Hosts bereitstellen

Für die Bereitstellung von Docker-Knoten empfiehlt es sich, auf das Provisionierungs-Tool https://docs.docker.com/machine/overview/Docker Machinezurückzugreifen. Dieses vereinfacht die Implementierung von Docker-Hosts (auch „Dockerized hosts“, virtuelle Hosts inklusive Docker-Engine). Mit Docker Machine stellen Sie Konten für Ihren Schwarm auf beliebiger Infrastruktur bereit und verwalten diese per Remote.

Treiber-Plug-ins für Docker Machine werden von diversen Cloud-Plattformen bereitgestellt. Dies reduziert den Aufwand für die Provisionierung von Docker-Hosts bei Anbietern wie Amazon Web Services (AWS) oder Digital Ocean auf eine einfache Codezeile.

Nutzen Sie folgenden Code, um einen Docker-Host (hier: docker-sandbox) in der Infrastruktur von Digital Ocean zu erstellen.

$ docker-machine create --driver digitalocean --digitalocean-access-token xxxxx docker-sandbox

Bei AWS erstellen Sie einen Docker-Host (hier: aws-sandbox) mit folgendem Befehl:

$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws-sandbox
Hinweis

Die Zeichen xxxxx und ****** fungieren als Platzhalter für individuelle Zugangstoken bzw. Schlüssel, die Sie über Ihren Kunden-Account beim jeweiligen Anbieter generieren.

Schritt 2: Swarm initialisieren

Haben Sie die gewünschte Anzahl virtueller Hosts für ihren Schwarm bereitgestellt, können Sie diese via Docker Machine verwalten und mit Docker Swarm zu einem Cluster zusammenfassen. Greifen Sie zunächst auf den Knoten zu, den sie als Swarm-Manager nutzen möchten. Docker Machine bietet dazu folgenden Befehl, um eine SSH-verschlüsselte Verbindung zum Docker-Host aufzubauen.

docker-machine ssh MACHINE-NAME
Hinweis

Ersetzen Sie den Platzhalter MACHINE-NAME durch den Namen des Docker-Hosts, auf den Sie zugreifen möchten.

Steht die Verbindung zum gewünschten Knoten, nutzen Sie folgenden Befehl, um einen Schwarm zu initialisieren.

docker swarm init [OPTIONS]

Der Befehl docker swarm init – wahlweise mit Optionen (siehe Dokumentation) – definiert den aktuell ausgewählten Knoten als Swarm-Manager und erzeugt zwei zufällige Token: einen Manager-Token und einen Worker-Token.

Swarm initialized: current node (1ia0jlt0ylmnfofyfj2n71w0z) is now a manager.

To add a worker to this swarm, run the following command:

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Zudem generiert der Befehl docker swarm init eine Terminal-Ausgabe, die alle Informationen umfasst, die Sie benötigen, um Ihrem Schwarm weitere Konten hinzuzufügen.

Hinweis

In der Regel wird docker swarm init mit dem Flag --advertise-addr verwendet.Dieses gibt an, welche IP-Adresse für API-Zugriffe und Overlay-Networking verwendet werden soll. Wurde die IP-Adresse nicht explizit definiert, prüft Docker automatisch, unter welcher IP-Adresse das ausgewählte System erreichbar ist, und wählt diese aus. Hat ein Knoten mehr als eine IP-Adresse, muss das entsprechende Flag gesetzt werden. Sofern nichts anderes angegeben wurde, verwendet Docker den Port 2377.

Schritt 3: Docker-Hosts in den Schwarm einbinden

Nachdem Sie Ihren Schwarm mit dem ausgewählten Knoten als Swarm-Manager initialisiert haben, fügen Sie beliebig viele Knoten als Manager oder Worker hinzu. Nutzen Sie dazu den Befehl docker swarm join in Kombination mit dem entsprechenden Token.

3.1 Worker-Knoten hinzufügen: Möchten Sie Ihrem Schwarm einen Worker-Knoten hinzufügen, greifen Sie via docker-machine auf den entsprechenden Knoten zu und führen folgenden Befehl aus:

docker swarm join [OPTIONS] HOST:PORT

Pflichtbestandteil des Befehls docker swarm join ist das Flag --token,das den Token für den Zugang zum Cluster enthält.

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377

Im aktuellen Beispiel enthält der Befehl den zuvor generierten Worker-Token sowie die IP-Adresse, unter der der Swarm-Manager zur Verfügung steht.

Haben sie den entsprechen Token gerade nicht zur Hand, ermitteln sie diesen via docker swarm join-token worker.

3.2 Master-Knoten hinzufügen: Möchten Sie Ihrem Schwarm einen weiteren Manager-Knoten hinzufügen, ermitteln Sie zunächst den Manager-Token. Führen Sie dazu den Befehl docker swarm join-token manager auf dem Manager-Konten aus, auf dem sie den Schwarm initialisiert haben, und folgenden Sie der Anweisung auf dem Terminal.

Docker generiert einen Manager-Token, der in Kombination mit dem Befehl docker swarm join und der von Ihnen definierten IP-Adresse auf einem beliebigen Docker-Host ausgeführt werden kann, um diesen als Manager in den Schwarm einzubinden.

$ sudo docker swarm join-token manager
To add a manager to this swarm, run the following command:

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-ed2ct6pg5rc6vp8bj46t08d0i \
10.0.2.15:2377

3.3 Übersicht aller Knoten im Schwarm: Eine Übersicht über alle in Ihren Schwarm eingebundenen Knoten erhalten Sie, indem Sie den Management-Befehl docker node ls auf einem Ihrer Manager-Knoten ausführen.

ID                           HOSTNAME  STATUS  AVAILABILITY  MANAGER
jhy7ur9hvzvwd4o1pl8veqms3    worker2   Ready   Active
jukrzzii3azdnub9jia04onc5    worker1   Ready   Active
1ia0jlt0ylmnfofyfj2n71w0z *  osboxes   Ready   Active        Leader

Manager-Knoten werden in der Übersicht als Leader gekennzeichnet.

Hinweis

Möchten Sie einen Knoten aus Ihrem Schwarm entfernen, loggen Sie sich in den entsprechen Host ein und führen den Befehl docker swarm leave aus. Handelt es sich bei dem Knoten um einen Swarm-Manager, müssen Sie die Ausführung des Befehls mit dem Flag --force erzwingen.

Teil 2: Multi-Container-App im Cluster ausführen

Im ersten Teil unseres Docker-Tutorials haben Sie Docker-Hosts mit Docker Machine bereitgestellt und im Swarm-Mode als Cluster zusammengefasst. Nun zeigen wir Ihnen, wie Sie verschiedene Services mithilfe von Docker Compose als kompakte Multi-Container-Apps definieren und im Cluster ausführen.

Die Bereitstellung von Multi-Container-Apps im Cluster erfolgt in fünf Schritten:

  1. Lokale Docker-Registry erstellen
  2. Multi-Container-App als Stack definieren
  3. Multi-Container-App mit Compose testen
  4. Image in die Registry laden
  5. Stack im Cluster ausführen

Schritt 1: Lokale Docker-Registry als Service starten

Da ein Docker-Schwarm aus einer beliebigen Anzahl von Docker-Engines besteht, lassen sich Anwendungen nur dann im Cluster betreiben, wenn alle beteiligten Docker-Engines Zugriff auf das Image der Anwendung haben. Sie benötigen somit einen zentralen Service, der es Ihnen ermöglicht, Images zu verwalten und im Cluster bereitzustellen. Ein solcher Service wird Registry genannt.

Hinweis

Bei einem Image handelt es sich um ein kompaktes, ausführbares Abbild einer Anwendung. Dieses beinhaltet zusätzlich zum Anwendungscode sämtliche Abhängigkeiten (Laufzeitumgebung, Bibliotheken, Umgebungsvariablen und Konfigurationsdateien), die Docker benötigt, um die entsprechende Anwendung als Container auszuführen. Jeder Container ist somit eine Laufzeitinstanz eines Images.

1.1 Registry als Service im Cluster starten: Nutzen Sie den Befehl docker service create nach folgendem Schema, um einen lokalen Registry-Server als Service im Cluster zu starten.

docker service create --name registry --publish 5000:5000 registry:2

Der Befehl weist Docker an einen Service mit dem Namen registry zu starten, der an Port 5000lauscht. Der erste Wert hinter dem Flag --publish gibt den Host-Port an, der zweite den Port des Containers. Dem Service liegt das Image registry:2 zugrunde, das eine Implementierung der Docker Registry HTTP API V2 enthält und frei über das Docker-Hub bezogen werden kann.

1.2 Status des Registry-Service prüfen: Nutzen Sie den Befehl docker service ls, um den Status des soeben gestarteten Registry-Service zu überprüfen.

$ sudo docker service ls
ID            NAME      MODE        REPLICAS  IMAGE          PORTS
K2hq2ivnwuq4  registry  replicated  1/1       registry:2     *:5000->5000/tcp

Der Befehl docker service ls gibt Ihnen eine Liste alle laufenden Services in Ihrem Docker-Cluster aus.

1.3 Verbindung zur Registry mit cURL prüfen: Stellen Sie sicher, dass Sie via cURL auf Ihre Registry zugreifen können. Geben Sie dazu folgenden Befehl ein:

$ curl http://localhost:5000/v2/

Funktioniert Ihre Registry wie beabsichtigt, sollte cURL folgende Terminalausgabe liefern:

{}
Hinweis

Bei cURL handelt es sich um ein Kommandozeilenprogramm, mit dem sich Webadressen aufrufen und Dateien hoch- oder herunterladen lassen. Mehr zu cURL erfahren Sie auf der Projekt-Website der Open-Source-Software: curl.haxx.se.

Schritt 2: Multi-Container-App erstellen und als Stack definieren

Im nächsten Schritt erstellen Sie alle Dateien, die für das Deployment eines Stacks im Docker-Cluster benötigt werden, und legen diese in einem gemeinsamen Projektverzeichnis ab.

2.1 Projektordner anlegen: Legen Sie ein Projektverzeichnis mit beliebigem Namen an – beispielsweise stackdemo.

$ mkdir stackdemo

Navigieren Sie in Ihr Projektverzeichnis.

$ cd stackdemo

Ihr Projektverzeichnis fungiert als Sammelordner für alle Dateien, die sie für den Betrieb Ihrer Multi-Container-App benötigen. Diese umfassen eine Datei mit dem Quellcode der App, eine Textdatei, in der Sie definieren, welche Software Sie für den Betrieb Ihrer App voraussetzen, sowie eine Dockerfile und eine Compose-File.

2.2 App erstellen: Erstellen Sie eine Python-Anwendung mit folgendem Inhalt und legen Sie diese unter dem Namen app.py im Projektverzeichnis ab.

from flask import Flask
from redis import Redis

app = Flask(__name__)
redis = Redis(host='redis', port=6379)

@app.route('/')
def hello():
    count = redis.incr('hits')
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, debug=True)

Bei der Beispielanwendung app.py handelt es sich um eine einfache Webanwendung, deren Startseite den Gruß „Hello World!“ zeigt, inklusive einer Angabe, wie oft die App aufgerufen wurde. Die Grundlage bilden das quelloffene Web-Framework Flask und die Open-Source-In-Memory-DatenbankRedis.

2.3 Voraussetzungen definieren: Erstellen Sei eine Textdatei requirements.txt mit folgendem Inhalt und legen Sie diese im Projektverzeichnis ab.

flask
redis

In der requirements.txt definieren Sie, auf welcher Software Ihre Anwendung aufbaut.

2.4 Dockerfile erstellen: Erstellen Sie eine weitere Textdatei mit dem Namen Dockerfile, fügen Siefolgenden Inhalt ein und legen Sie diese ebenfalls im Projektordner ab.

FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

Die Dockerfile enthält alle Instruktionen, die benötigt werden, um ein Image einer Anwendung zu erstellen. Beispielsweise verweist die Dockerfile auf die requirements.txt und gibt somit an, welche Software für den Betrieb der Anwendung installiert werden muss.

Die Dockerfile im Beispiel ermöglicht es, ein Image der Webanwendung app.py inklusive aller Voraussetzungen (Flask und Redis) zu erstellen.

2. 5 Compose-File erstellen: Erstellen Sie eine Konfigurations-Datei mit folgendem Inhalt und speichern Sie diese als docker-compose.yml.

version: '3'

services:
  web:
    image: 127.0.0.1:5000/stackdemo
    build: .
    ports:
      - "8000:8000"
  redis:
    image: redis:alpine

Die docker-compose.yml ermöglicht es, verschiedene Services miteinander zu verknüpfen und als Einheit gemeinsam auszuführen und zentral zu verwalten.

Hinweis

Die Compose-File wird in YAML notiert, einer vereinfachten Auszeichnungssprache, die der Abbildung strukturierter Daten dient und in erster Linie in Konfigurationsdateien verwendet wird. Bei Docker dient die docker-compose.yml der zentralen Konfiguration von Services einer Multi-Container-Anwendung.

Im aktuellen Beispiel definieren wir zwei Services: einen Web-Service und einen Redis-Service.

  • Web-Service: Grundlage des Web-Service ist ein Image, das auf Basis der von Ihnen erstellten Dockerfile im Verzeichnis stackdemo erzeugt wird.
  • Redis-Service: Für den Redis-Service nutzen wir kein eigenes Image. Stattdessen greifen wir auf ein öffentlich zugängliches Redis-Image (redis:alpine)zurück, das über das Docker-Hub zur Verfügung steht.

Schritt 3: Multi-Container-App mit Compose testen

Testen Sie die Multi-Container-App zunächst lokal, indem Sie diese auf Ihrem Manager-Knoten ausführen.

3.1 App starten: Nutzen Sie den Befehl docker-compose up in Kombination mit dem Flag -d, um Ihr Stack zu starten. Das Flag aktiviert den „Detached mode“, wodurch alle Container im Hintergrund ausgeführt werden. Ihr Terminal ist somit bereit für weitere Befehlseingaben.

$ sudo docker-compose up -d
WARNING: The Docker Engine you're using is running in swarm mode.

Compose does not use swarm mode to deploy services to multiple nodes in a swarm. All containers will be scheduled on the current node.

To deploy your application across the swarm, use the bundle feature of the Docker experimental build.

More info:
https://docs.docker.com/compose/bundles

Creating network "stackdemo_default" with the default driver
Creating stackdemo_web_1
Creating stackdemo_redis_1

3.2 Status des Stacks prüfen: Führen Sie den Befehl docker-compose ps aus, um den Status Ihres Stacks zu überprüfen. Sie erhalten eine Terminalausgabe, die in etwa folgendem Beispiel entspricht:

$ sudo docker-compose ps
      Name             Command             State              Ports       
-------------------------------------------------------------------------
stackdemo_redis_   docker-            Up                 6379/tcp         
1                  entrypoint.sh                                          
                   redis ...                                              
stackdemo_web_1    python app.py      Up                 0.0.0.0:8000->80 
                                                         00/tcp           

Der Befehl docker-compose ps gibt Ihnen eine Übersicht aller Container aus, die ihm Rahmen Ihrer Multi-Container-Anwendung gestartet wurden. Im aktuellen Beispiel umfasst die Liste zwei Container – jeweils einen für die Services Redis und Web.

3.3 Stack mit cURL testen: Testen Sie Ihr Stack, indem Sie das Kommandozeilenprogramm cURL mit der Lokalhostadresse (localhost oder 127.0.0.1) ausführen.

$ curl http://localhost:8000
Hello World! I have been seen 1 times.

$ curl http://localhost:8000
Hello World! I have been seen 2 times.

$ curl http://localhost:8000
Hello World! I have been seen 3 times.

Alternativ lässt sich die Webanwendung im Webbrowser aufrufen.

3.4 App abschalten: Möchten Sie das Stack abschalten, führen Sie den Befehl docker-compose down mit dem Flag --volumes aus.

$ sudo docker-compose down --volumes
Stopping stackdemo_redis_1 ... done
Stopping stackdemo_web_1 ... done
Removing stackdemo_redis_1 ... done
Removing stackdemo_web_1 ... done
Removing network stackdemo_default

Schritt 4: Image in die Registry laden

Bevor Sie Ihre Multi-Container-App als verteilte Anwendung im Cluster ausführen können, müssen Sie alle dafür benötigten Images über den Registry-Service bereitstellen. Im aktuellen Beispiel umfasst dies lediglich das selbsterstellte Image des Web-Service (das Redis-Image steht über eine öffentliche Registry im Docker-Hub zur Verfügung).

Der Upload eines lokal erstellten Images in eine zentrale Registry wird bei Docker „push“ genannt. Docker Compose stellt dafür den Befehl docker-compose push zur Verfügung. Führen Sie diesen in Ihrem Projektverzeichnis aus.

Alle in der docker-compose.yml aufgeführten Images, die lokal erstellt wurden, werden in die Registry geladen.

$ sudo docker-compose push
Pushing web (127.0.0.1:5000/stackdemo:latest)...
The push refers to a repository [127.0.0.1:5000/stackdemo]
5b5a49501a76: Pushed
be44185ce609: Pushed
bd7330a79bcf: Pushed
c9fc143a069a: Pushed
011b303988d2: Pushed
latest: digest: sha256:a81840ebf5ac24b42c1c676cbda3b2cb144580ee347c07e1bc80e35e5ca76507 size: 1372

Im aktuellen Beispiel lädt docker-compose push das Image des Stacks stackdemo mit dem Tag latest in die lokale Registry unter 127.0.0.1:5000.

Schritt 5: Stack im Cluster ausführen.

Steht das Image Ihres Stacks über den lokalen Registry-Service zur Verfügung, kann die Multi-App-Anwendung im Cluster ausgeführt werden.

5.1 Stack im Cluster ausführen: Auch im Cluster führen Sie Stacks mit einer einfachen Kommandozeile aus. Die Container-Plattform hält dazu folgenden Befehl bereit:

docker stack deploy [OPTIONS] STACK
Hinweis

Setzen Sie anstelle des Platzhalters STACK den Namen des Stack-Images ein, das Sie ausführen möchten.

Führen Sie den Befehl docker stack deploy auf einem der Manager-Knoten ihres Schwarms aus.

$ sudo docker stack deploy --compose-file docker-compose.yml stackdemo
Ignoring unsupported options: build

Creating network stackdemo_default
Creating service stackdemo_web
Creating service stackdemo_redis

Das Flag --compose-file gibt den Pfad zur Compose-File an.

5.2 Status des Stacks abrufen: Nutzen Sie folgenden Befehl, um den Status ihres Stacks abzurufen:

docker stack services [OPTIONS] STACK

Docker gibt Ihnen die IDs, Namen, Modi, Replikate, Images sowie die Ports aller Services aus, die im Rahmen Ihres Stacks ausgeführt werden.

$ sudo docker stack services stackdemo
ID                  NAME                MODE                REPLICAS            IMAGE                             PORTS
cxyp7srukffy        stackdemo_web       replicated          1/1                 127.0.0.1:5000/stackdemo:latest   *:8000->8000/tcp
z0i2rtjbrj9s        stackdemo_redis     replicated          1/1                 redis:alpine                     

5.3 App mit cURL testen: Um Ihre Multi-Container-App zu testen, rufen Sie diese über die Localhost-Adresse an Port 8000 auf.

$ curl http://localhost:8000
Hello World! I have been seen 1 times.

$ curl http://localhost:8000
Hello World! I have been seen 2 times.

$ curl http://localhost:8000
Hello World! I have been seen 3 times.

Alternativ zu cURL lässt sich die App über den Webbrowser aufrufen. Nutzen Sie dazu die Localhost-Adresse oder die Adresse eines beliebigen Knotens. Dank des internen Routing-Netzes können Sie auf jeden Knoten Ihres Schwarms an Port 8000 zugreifen, um zu Ihrer App weitergeleitet zu werden.

 

5.4 Stack abschalten: Möchten Sie Ihr Stack abschalten, nutzen Sie den Befehl docker stack rm in Kombination mit dem Namen des Stacks.

$ docker stack rm stackdemo

Removing service stackdemo_web
Removing service stackdemo_redis
Removing network stackdemo_default

5.5 Registry-Service abschalten: Möchten Sie den Registry-Service abschalten, nutzen Sie den Befehl docker service rm mit dem Namen des Service – hier: registry.

$ docker service rm registry

Fazit

Docker Swarm und Compose erweitern die Kernfunktionalität der Container-Plattform um Tools, die es Ihnen ermöglichen, komplexe Anwendungen mit geringem Verwaltungsaufwand in verteilten Systemen zu betreiben. Der Marktführer im Bereich der Container-Virtualisierung bietet Anwendern somit eine Komplettlösung für die Container-Orchestrierung aus einer Hand. Beide Tools sind gut dokumentiert und werden in regelmäßigen Abständen aktualisiert. Swarm und Compose positionieren sich damit als gute Alternative zu etablierten Drittanbieter-Werkzeugen wie Kubernetes oder Panamax.


Auf dem Laufenden bleiben?

Jetzt für unseren Newsletter anmelden und gratis Online-Marketing Whitepaper für lokale Anbieter sichern!