Training Module

Docker Swarm Hands-on: Vom Cluster-Aufbau zum produktiven Stack

Die Swarm-Architektur – Manager-/Worker-Nodes, Raft-Konsens, Services/ Tasks, Overlay-Netz, Routing-Mesh-Konzept – ist bereits Teil des Vorgängermoduls und wird hier nicht wiederholt. In diesem 2¼-Stunden- Modul baut ihr das komplette Hands-on selbst auf: einen eigenen Swarm-Cluster mit docker swarm init, eine lokale Registry, und einen Mehrdienste-Stack aus Vue/Nginx-Frontend, Node-API, Redis und einem dreifachen MongoDB-Replica-Set – per docker stack deploy ausgerollt und mit rs.initiate initialisiert. Danach skaliert ihr einen Service im laufenden Betrieb und setzt eine Placement Constraint an einer echten Datenbank-Instanz per Node-Label um, inklusive des Fehlerbilds, wenn die Constraint keinen passenden Node findet. Das komplette Hands-on läuft als Single-Node-Swarm auf einem einzigen Host – real durchspielbar, ohne Cloud-Account und ohne Kostenwirkung. Routing Mesh über echte Netzwerkgrenzen und Self-Healing bei echtem Host-Ausfall bleiben ein konzeptioneller Block mit Video-Ausschnitt, weil beides einen echten Mehr-Host-Cluster braucht, den eine einzelne Sandbox nicht ehrlich abbilden kann.

Academy Briefing vereinbaren

Oder sofort per Mail an kontakt@codecraft.academy

Format

Ca. 2 Stunden 15 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Absolvent:innen von “Docker Sicherheit & Orchestrierung mit Swarm” bzw. “Docker Fortgeschritten”/“Docker Betrieb” oder gleichwertige Vorkenntnisse

Voraussetzungen

Swarm-Architektur-Grundbegriffe (Manager/Worker, Services/Tasks, Overlay-Netz) aus dem Vorgängermodul, lauffähige lokale Docker-Umgebung mit Docker Compose. Keine Cloud-/AWS-Kostenwirkung – der komplette Cluster läuft als Single-Node-Swarm auf dem eigenen Rechner.

Warum dieses Training für deine Organisation wirkt

Vom Konzept zur eigenen Hand

Swarm-Architektur war im Vorgängermodul Input und Live-Demo. Hier baut jede:r Teilnehmende den eigenen Cluster tatsächlich auf – docker swarm init, eine eigene Registry, ein echter Stack, keine Folie.

Ein echter Mehrdienste-Stack

Vue/Nginx-Frontend, Node-API, Redis und ein dreifach repliziertes MongoDB-Cluster laufen zusammen über docker stack deploy – inklusive der Replica-Set-Initialisierung, die eine Datenbank im Swarm-Kontext erst zum funktionierenden Cluster macht.

Skalieren und platzieren, nicht nur zusehen

docker service scale im laufenden Betrieb und eine Placement Constraint per Node-Label an einer echten Datenbank-Instanz – inklusive des Moments, in dem eine falsch gesetzte Constraint einen Task einfach hängen lässt.

Was Teilnehmende mitnehmen

  • Einen Docker-Swarm-Cluster mit docker swarm init aufbauen und eine lokale Registry als Swarm-Service betreiben.
  • Einen Mehrdienste-Stack (Vue/Nginx-Frontend, Node-API, Redis, MongoDB-Replica-Set) über docker stack deploy ausrollen.
  • Ein MongoDB-Replica-Set im Swarm-Kontext mit rs.initiate initialisieren und über die API gegen alle drei Replicas verifizieren.
  • Einen Service im laufenden Betrieb mit docker service scale skalieren und die Tasks-Verteilung mit docker service ps prüfen.
  • Eine Placement Constraint per Node-Label an einer echten Datenbank-Instanz anwenden – inklusive des Fehlerbilds, wenn keine passende Node existiert.
  • Einordnen, warum Routing Mesh über echte Netzwerkgrenzen und Self-Healing bei echtem Host-Ausfall in diesem Single-Node-Setup nicht ehrlich als eigenes Hands-on zeigbar sind – als konzeptioneller Block mit Video-Ausschnitt statt als Übung.

Für wen dieses Modul ideal ist

  • • Absolvent:innen von “Docker Sicherheit & Orchestrierung mit Swarm” oder Teams mit gleichwertigen Swarm-Grundkenntnissen
  • • Teams, die die Swarm-Architektur bereits kennen und jetzt selbst einen Stack aufbauen, skalieren und gezielt platzieren wollen
  • • Alle, die Cluster-Aufbau, Stack-Deployment und Placement erst risikofrei auf einem Host üben wollen, bevor ein echter Mehr-Host-Cluster ansteht

Rahmendaten

  • • Dauer: ca. 2 Stunden 15 Minuten live (remote oder vor Ort)
  • • Format: Input, Hands-on-Übung mit eigenem Single-Node-Swarm-Cluster
  • • Voraussetzungen: abgeschlossenes Modul “Docker Sicherheit & Orchestrierung mit Swarm” oder gleichwertige Swarm-Grundkenntnisse, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Begrüßung & Abgrenzung (10 min): kurzer Rückblick auf die Swarm-Architektur-Grundlagen aus dem Vorgängermodul, klare Abgrenzung, was hier neu dazukommt – das komplette Hands-on ab Cluster-Aufbau –, Hinweis auf das Single-Node-Setup.

  2. Registry & Cluster-Aufbau (25 min): docker swarm init, docker node ls, eine lokale Registry als eigener Swarm-Service auf Port 5000.

  3. Stack deployen inkl. Replica-Set-Init (50 min, Kern, Hands-on): stack.yaml mit Frontend, API, Redis und dreifachem MongoDB-Replica-Set, Images bauen und in die eigene Registry pushen, docker stack deploy, Replica-Set-Initialisierung mit rs.initiate.

  4. Skalierung & Placement Constraints (25 min): docker service scale im laufenden Betrieb, docker service ps zur Tasks-Verteilung, ein Node-Label setzen und eine Placement Constraint an einer Datenbank-Instanz anwenden – inklusive des Fehlerbilds bei falschem Label.

  5. Ausfallsicherheit & Routing Mesh – Einordnung (20 min, konzeptionell/Video-Ausschnitt): warum echtes Routing Mesh über Netzwerkgrenzen und Self-Healing bei Host-Ausfall auf einem einzelnen Host nicht ehrlich zeigbar sind, was ein echter Mehr-Host-Cluster dafür bräuchte.

  6. Aufräumen & Ausblick (5 min): docker stack rm, docker swarm leave –force, Ausblick auf den Betrieb über mehrere echte Hosts hinweg.

Die Swarm-Architektur – Manager-/Worker-Nodes, Raft-Konsens, Services/ Tasks, Overlay-Netz, Routing-Mesh-Konzept – sowie eine ehrliche Swarm-vs.-Kubernetes-Einordnung sind bereits Teil von Docker Sicherheit & Orchestrierung mit Swarm. Dieses Modul setzt diese Grundlagen voraus und wiederholt sie nicht, sondern beginnt direkt mit dem eigenen Cluster-Aufbau.

Hands-on Inhalte (Auszug)

Registry & Cluster-Aufbau

  • docker swarm init und docker node ls auf dem eigenen Host
  • Eine lokale Registry als Swarm-Service (registry:2) auf Port 5000
  • Eigene Images bauen und in die eigene Registry pushen

Stack-Deployment (Kern-Hands-on)

  • stack.yaml mit Frontend, API, Redis und dreifachem MongoDB-Replica-Set
  • docker stack deploy und docker service ls zur Deployment-Prüfung
  • Replica-Set-Initialisierung mit rs.initiate, verifiziert über die eigene API

Skalierung & Placement Constraints

  • docker service scale im laufenden Betrieb, docker service ps zur Verteilung der Tasks
  • Node-Label setzen und Placement Constraint an einer Datenbank-Instanz anwenden
  • Das Fehlerbild bei falschem Label: Task bleibt Pending, bis die Constraint wieder passt

Ausfallsicherheit & Ausblick

  • Routing Mesh über echte Netzwerkgrenzen und Self-Healing bei Host-Ausfall als konzeptioneller Block mit Video-Ausschnitt, nicht als eigenes Hands-on
  • docker stack rm und docker swarm leave –force zum Aufräumen
  • Was für den Betrieb über mehrere echte Hosts hinweg zusätzlich dazukommt

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum lauffähigen Stack, Ergebnis der Replica-Set-Initialisierung) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen die Hands-on-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen