Docker Swarm Clustering – Hochverfügbarkeit mit Docker einrichten

Was ist Docker Swarm?

Docker Swarm ist die native Clustering- und Orchestrierungslösung von Docker. Mit Swarm können Sie mehrere Docker Hosts zu einem einzigen virtuellen Docker-Engine verbinden und Docker-Container über mehrere Maschinen hinweg verwalten und deployen. Swarm bietet built-in Load Balancing, Service-Discovery, Scheduling und Rolling Updates.

Docker Swarm vs Kubernetes Vergleich

Docker Swarm Konzepte

Manager Nodes

Manager Nodes sind für die Verwaltung des Swarm-Clusters zuständig. Sie verwalten den Cluster-State, planen Container auf Worker Nodes und koordinieren alle Operationen. Es ist beste Praxis, 3, 5 oder 7 Manager Nodes zu haben (immer eine ungerade Anzahl für Quorum).

Worker Nodes

Worker Nodes führen die eigentlichen Container aus. Sie führen keine Verwaltungsaufgaben durch und können skiert werden ohne das Cluster zu beeinflussen.

Services

Ein Service ist die Abstraktion einer Anwendung in Swarm. Ein Service definiert, welches Image verwendet werden soll, wie viele Replikationen benötigt werden und welche Ports exponiert werden.

Tasks

Ein Task ist eine einzelne Container-Instanz. Ein Service mit 3 Replikationen besteht aus 3 Tasks.

Overlay Network

Overlay Networks ermöglichen sichere Multi-Host-Kommunikation zwischen Containern auf verschiedenen Nodes.

Ingress Network

Das Ingress Network verteilt eingehende Anfragen auf alle Nodes, die einen Service bereitstellen.

Swarm Cluster initialisieren

# Swarm auf dem ersten Manager-Node initialisieren
docker swarm init --advertise-addr 192.168.1.10

# Die Ausgabe sollte ähnlich aussehen:
# Swarm initialized: current node is now a manager.
#
# To add a worker to this Swarm, run the following command:
#
#     docker swarm join --token SWMTKN-1-... 192.168.1.10:2377
#
# To add a manager to this Swarm, run 'docker swarm join-token manager' and start docker on a new node
# with 'docker swarm join' and the token as below:
#
#     docker swarm join --token SWMTKN-1-... 192.168.1.10:2377

# Cluster-Status überprüfen
docker info | grep -A 5 Swarm

# Alle Nodes im Cluster auflisten
docker node ls

Weitere Manager und Worker Nodes hinzufügen

# Worker Join Token abrufen
docker swarm join-token worker

# Manager Join Token abrufen
docker swarm join-token manager

# Auf dem neuen Worker-Node ausführen:
docker swarm join --token SWMTKN-1-... 192.168.1.10:2377

# Auf dem neuen Manager-Node ausführen:
docker swarm join --token SWMTKN-1-... 192.168.1.10:2377

# Nodes überprüfen
docker node ls

# Node-Details inspizieren
docker node inspect node-name

# Label zu Node hinzufügen
docker node update --label-add "type=worker" node-name
docker node update --label-add "storage=ssd" node-name

# Labels überprüfen
docker node inspect --pretty node-name

Services erstellen und verwalten

Service erstellen

# Einfacher Service mit 3 Replikationen
docker service create --replicas 3 --name web -p 80:80 nginx:latest

# Service mit mehr Optionen
docker service create \
  --name web \
  --replicas 3 \
  -p 80:80 \
  --update-delay 10s \
  --update-parallelism 1 \
  --update-failure-action rollback \
  --restart-condition on-failure \
  --restart-max-attempts 3 \
  nginx:latest

# Service mit Umgebungsvariablen
docker service create \
  --name myapp \
  --replicas 2 \
  -e DATABASE_URL="postgres://db:5432/mydb" \
  -e LOG_LEVEL="INFO" \
  myimage:latest

# Service mit Volume/Mount
docker service create \
  --name web \
  --mount type=bind,source=/data,target=/data \
  -p 80:80 \
  nginx:latest

# Service mit Resource Limits
docker service create \
  --name web \
  --limit-cpu 0.5 \
  --limit-memory 512m \
  --reserve-cpu 0.25 \
  --reserve-memory 256m \
  nginx:latest

Services auflisten und inspizieren

# Alle Services auflisten
docker service ls

# Service-Details
docker service inspect web

# Service Tasks anzeigen (welche Container auf welchen Nodes laufen)
docker service ps web

# Detaillierte Task-Informationen
docker service ps web --no-trunc

# Service-Logs anzeigen (alle Replicas)
docker service logs web

# Mit Follow (streaming)
docker service logs -f web

Services skalieren

# Service auf 5 Replikationen hochfahren
docker service scale web=5

# Mehrere Services gleichzeitig skalieren
docker service scale web=5 db=2 api=3

# Aktuelle Replicas überprüfen
docker service ps web

Rolling Updates

# Service Image aktualisieren
docker service update --image nginx:latest web

# Mit Update-Strategie
docker service update \
  --image nginx:latest \
  --update-delay 10s \
  --update-parallelism 1 \
  --update-failure-action rollback \
  web

# Update-Parameter erklären:
# --update-delay: Wartezeit zwischen Container-Updates (10s)
# --update-parallelism: Wie viele Container gleichzeitig aktualisieren (1)
# --update-failure-action: rollback bei Fehler oder pause

# Zu vorheriger Version zurückrollen
docker service update --image nginx:previous web

# Service-Update Status überprüfen
docker service ps web

# Einzelne Replicas aktualisieren überprüfen
docker service ps web --no-trunc

Constraints und Node-Label

Mit Constraints können Sie festlegen, auf welchen Nodes ein Service laufen darf.

# Node mit Label versehen
docker node update --label-add "environment=production" node-1
docker node update --label-add "environment=staging" node-2
docker node update --label-add "type=gpu" node-3

# Service nur auf Production-Nodes starten
docker service create \
  --name web \
  --constraint node.labels.environment==production \
  nginx:latest

# Service nur auf Worker Nodes starten (nicht auf Managern)
docker service create \
  --name web \
  --constraint node.role==worker \
  nginx:latest

# Service nur auf GPU-Nodes starten
docker service create \
  --name ai-app \
  --constraint node.labels.type==gpu \
  ai-model:latest

# Mehrere Constraints (AND-Logik)
docker service create \
  --name web \
  --constraint node.labels.environment==production \
  --constraint node.labels.storage==ssd \
  nginx:latest

# Service auf Managern starten (normalerweise nicht empfohlen)
docker service create \
  --name monitoring \
  --constraint node.role==manager \
  prometheus:latest

Overlay Networks für Multi-Host-Kommunikation

# Overlay Network erstellen
docker network create --driver overlay mynet

# Service mit spezifischem Network starten
docker service create \
  --name web \
  --network mynet \
  -p 80:80 \
  nginx:latest

# Zweiter Service im gleichen Network
docker service create \
  --name db \
  --network mynet \
  postgres:latest

# Die Services können sich per Hostname erreichen
# Web-Container kann sich zu "db" verbinden

# Netzwerk inspizieren
docker network inspect mynet

# Services im Netzwerk aufgelistet
docker network ls

# Netzwerk löschen
docker network rm mynet

# Netzwerk mit Custom Options
docker network create \
  --driver overlay \
  --subnet 10.0.9.0/24 \
  --gateway 10.0.9.1 \
  custom-net

Docker Stack: Multi-Service Deployment mit Compose

Ein Stack ist eine Gruppe von Services, die zusammen deployt werden. Die Definition erfolgt über Docker Compose Files.

docker-compose.yml für Stack

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
        failure_action: rollback
      restart_policy:
        condition: on-failure
        max_attempts: 3
    volumes:
      - /data/nginx:/etc/nginx/html
    networks:
      - frontend

  api:
    image: myapi:latest
    deploy:
      replicas: 2
      constraints:
        - node.role==worker
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
    environment:
      - DATABASE_URL=postgres://db:5432/mydb
      - REDIS_URL=redis://cache:6379
    networks:
      - frontend
      - backend
    depends_on:
      - db
      - cache

  db:
    image: postgres:15
    deploy:
      replicas: 1
      constraints:
        - node.labels.type==database
      restart_policy:
        condition: on-failure
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secure123
      POSTGRES_DB: mydb
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

  cache:
    image: redis:7
    deploy:
      replicas: 1
    networks:
      - backend

networks:
  frontend:
    driver: overlay
  backend:
    driver: overlay

volumes:
  db_data:
    driver: local

Stack deployen und verwalten

# Stack deployen
docker stack deploy -c docker-compose.yml myapp

# Stacks auflisten
docker stack ls

# Stack-Services anzeigen
docker stack services myapp

# Stack-Tasks anzeigen
docker stack ps myapp

# Service im Stack skalieren
docker service scale myapp_web=5

# Stack entfernen
docker stack rm myapp

# Service in Stack aktualisieren
docker service update --image myapi:v2.0 myapp_api

# Stack-Status überprüfen
docker stack ps myapp --no-trunc

Portainer für GUI-Management

Portainer ist eine webbasierte GUI zum Verwalten von Docker und Docker Swarm Clustern.

# Portainer als Stack deployen
docker stack deploy -c - portainer << 'EOF'
version: '3.8'

services:
  portainer:
    image: portainer/portainer-ce:latest
    command: -H unix:///var/run/docker.sock
    ports:
      - "9000:9000"
      - "8000:8000"
    deploy:
      placement:
        constraints:
          - node.role == manager
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    networks:
      - agent_network

  agent:
    image: portainer/agent:latest
    environment:
      AGENT_CLUSTER_ADDR: tasks.agent
      AGENT_PORT: 9001
      LOG_LEVEL: info
    ports:
      - target: 9001
        published: 9001
        protocol: tcp
        mode: host
    deploy:
      mode: global
      restart_policy:
        condition: on-failure
        max_attempts: 5
        window: 10s
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /var/lib/docker/volumes:/var/lib/docker/volumes
    networks:
      - agent_network

networks:
  agent_network:
    driver: overlay

volumes:
  portainer_data:
EOF

# Nach Deployment auf http://localhost:9000 zugreifen
# Admin-Passwort bei erstem Login setzen

Node-Wartung und Drain

Für Wartungsarbeiten können Sie einen Node in Drain-Modus versetzen. Dies verschiebt alle Container auf andere Nodes.

# Node in Drain-Modus versetzen (keine neuen Container mehr)
docker node update --availability drain node-name

# Node-Status überprüfen
docker node inspect --pretty node-name

# Damit Services auf andere Nodes verschoben werden
docker service update --force web

# Überprüfen, dass alle Tasks auf andere Nodes verschoben wurden
docker service ps web

# Node nach Wartung wieder aktivieren
docker node update --availability active node-name

# Node aus dem Cluster entfernen (vorher auf einem Manager)
docker swarm leave --force

# Node aus Cluster-Perspektive entfernen
docker node rm node-name

Monitoring und Fehlerbehebung

# Swarm Health Status
docker info

# Cluster-Events anzeigen
docker events --filter type=service

# Service Health überprüfen
docker service ps web --no-trunc

# Manager-Logs überprüfen (auf Manager-Node)
journalctl -u docker -f

# Docker Daemon-Logs
sudo journalctl -u docker -f

# Netzwerk-Verbindungen überprüfen
docker exec  netstat -tulpn

# Service-Discovery testen
docker exec  nslookup db

Sicherheit in Docker Swarm

# Swarm verfügt über mutual TLS für alle Kommunikation
# Dies ist automatisch aktiviert und kann nicht deaktiviert werden

# Zertifikate überprüfen
docker info | grep -A 2 "TLS"

# Manager CA Zertifikat rotieren
docker swarm ca --rotate

# Zertifikat mit Custom Expiration
docker swarm ca --rotate --cert-expiry 2160h

Weitere Ressourcen

• 📖 Kubernetes Grundlagen Einführung
• 📖 Docker Compose Grundlagen und Anleitung
• 📖 Portainer Docker Management Anleitung
• 📖 Container Networking Ueberblick
• 📖 Docker Security Best Practices
• 🔧 Sichere Server bei Enjyn mieten
• 🔧 Enjyn Server Monitor – Kostenlose Uptime-Überwachung

Letzte Aktualisierung: April 2026 | Docker Swarm Version 27.0+