Training Module

Docker & Kubernetes: Vom Compose-Stack zum lokalen Cluster

In diesem 2¼-Stunden-Modul steigt ihr von Docker in Kubernetes ein: warum es Orchestrierung überhaupt braucht, die Aufteilung in Control Plane und Worker Nodes, und der Pod als kleinste Einheit. Danach geht es praktisch weiter mit Minikube und dem docker-Treiber – ein “Container-in-Container”-Cluster ganz ohne virtuelle Maschine, ein erstes Deployment und ein NodePort-Service. Inhaltlicher Kern ist die Migration eines bestehenden Monitoring-Stacks aus Grafana, InfluxDB und Telegraf per kompose convert von Compose nach Kubernetes. Zum Abschluss das Kubernetes Dashboard, lokales Ingress-Routing unter einer eigenen Domain, und ein konzeptioneller Ausblick auf Managed Kubernetes bei AWS, Azure und Google Cloud. Die komplette Session – auch die Hands-on-Übung – läuft vollständig lokal über Minikube auf eurem eigenen Rechner, ohne Cloud-Account und ohne Kostenwirkung.

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 Fortgeschritten” oder gleichwertige Vorkenntnisse

Voraussetzungen

Sicherer Umgang mit compose.yaml sowie eine lauffähige lokale Docker-Umgebung (Docker Desktop, OrbStack oder Colima) mit ausreichend freien Ressourcen für einen Minikube-Cluster. Keine Cloud-/AWS-Kostenwirkung – der komplette Cluster läuft lokal über Minikube mit dem Docker-Treiber.

Warum dieses Training für deine Organisation wirkt

Vom Einzel-Host zum Cluster

Docker Compose orchestriert Container auf einem Host. Kubernetes löst die nächste Frage: automatischer Neustart, Lastverteilung und unterbrechungsfreie Updates über mehrere Knoten hinweg – mit Control Plane und Worker Nodes als Grundarchitektur und dem Pod als kleinster Einheit.

Migration statt Neubau

Der Kern des Trainings: Ein bestehender Monitoring-Stack aus Grafana, InfluxDB und Telegraf wird nicht neu geschrieben, sondern per kompose convert aus einer vorhandenen compose.yaml nach Kubernetes migriert – der realistischste Einstiegspfad für Teams, die schon mit Compose arbeiten.

Praxis ohne Risiko

Der komplette Cluster läuft über Minikube mit dem docker-Treiber als isolierter Container auf eurem eigenen Rechner. Kein eigener Cloud-Account, keine Kostenwirkung – inklusive Dashboard und eigenem lokalen Domain-Routing per Ingress.

Was Teilnehmende mitnehmen

  • Warum Kubernetes über Docker Compose hinaus gebraucht wird, und wie Control Plane (kube-apiserver, etcd, kube-scheduler, kube-controller-manager) und Worker Nodes (kubelet, Container Runtime, kube-proxy) zusammenspielen.
  • Den Pod als kleinste Einheit einordnen: geteilte IP-Adresse, geteilter Port-Bereich, geteilte Volumes – und warum in der Praxis fast immer genau ein Container pro Pod läuft.
  • Einen lokalen Single-Node-Cluster mit minikube start –driver=docker hochfahren, ein erstes Deployment samt NodePort-Service deklarativ über YAML anlegen und mit kubectl prüfen.
  • Einen bestehenden Grafana/InfluxDB/Telegraf-Monitoring-Stack per kompose convert von compose.yaml nach Kubernetes migrieren, die generierten Deployments/Services lesen und gezielt per NodePort erreichbar machen.
  • Das Kubernetes Dashboard als grafische Oberfläche für Workloads, Logs und Pod-Details nutzen.
  • Lokales Ingress-Routing unter eigenen Domains (my-app.local, grafana.local) über den Nginx-Ingress-Controller und minikube tunnel aufsetzen, statt mit wechselnden Zufalls-Ports zu arbeiten.
  • Ressourcen sauber wieder freigeben (minikube stop/minikube delete) und den kompletten Stack rein aus den eigenen YAML-Dateien heraus reproduzieren.
  • Managed Kubernetes bei AWS EKS, Azure AKS und Google GKE konzeptionell einordnen – als Ausblick, nicht als eigenes Hands-on.

Für wen dieses Modul ideal ist

  • • Absolvent:innen von “Docker Fortgeschritten” oder Entwickler:innen mit gleichwertigen Compose-Vorkenntnissen
  • • Teams, die einen bestehenden Compose-Stack Richtung Kubernetes migrieren wollen, statt bei null anzufangen
  • • Alle, die Kubernetes-Grundbegriffe (Pod, Deployment, Service, Ingress) erstmals selbst anwenden statt nur nachlesen wollen

Rahmendaten

  • • Dauer: ca. 2 Stunden 15 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, Hands-on-Übung mit eigenem Minikube-Cluster
  • • Voraussetzungen: abgeschlossenes Modul “Docker Fortgeschritten” oder gleichwertige Compose-Vorkenntnisse, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Warum Kubernetes? Control Plane, Worker Nodes, Pod-Konzept (25 min): die Grenze von Docker Compose, die Kernkomponenten der Control Plane und der Worker Nodes, der Pod als kleinste deklarative Einheit.

  2. Minikube lokal mit Docker-Treiber, erstes Deployment + NodePort-Service (35 min): minikube start –driver=docker, kubectl cluster-info, ein Deployment mit zwei Replicas samt NodePort-Service deklarativ über YAML anlegen und mit kubectl get pods/deployment/service sowie minikube service prüfen.

  3. Von Compose zu Kubernetes: kompose-Migration eines Monitoring-Stacks (30 min, Kern, Hands-on): einen Grafana/InfluxDB/Telegraf-Stack aus einer bestehenden compose.yaml per kompose convert nach Kubernetes migrieren, die generierten Manifeste lesen, anwenden und Grafana per NodePort erreichbar machen.

  4. Dashboard & lokales Ingress-Routing mit eigener Domain (30 min): das Kubernetes Dashboard als Add-on aktivieren, den Nginx-Ingress-Controller aktivieren und zwei Domains (my-app.local, grafana.local) per Ingress-Manifest und minikube tunnel lokal erreichbar machen.

  5. Ausblick: Managed Kubernetes EKS/AKS/GKE (15 min, konzeptionell): wie Amazon EKS, Azure AKS und Google GKE die Control Plane verwalten, Serverless-Knoten (Fargate), automatische Cloud-Integration von LoadBalancer-Services und globales Ingress-Routing – als Einordnung, kein eigenes Hands-on.

Eine ehrliche Swarm-vs.-Kubernetes-Einordnung, konzeptionell und ohne Verkaufsargument in die eine oder andere Richtung, ist bereits Teil von Docker Sicherheit & Orchestrierung mit Swarm. Dieses Modul setzt keine Swarm-Kenntnisse voraus und wiederholt diese Einordnung nicht, sondern beginnt direkt praktisch mit Kubernetes.

Wer Control Plane, Worker Nodes, Raft/Quorum und den API-Call-Flow noch nie gehört hat, ist im 90-Minuten-Einstiegsmodul Kubernetes Einführung — der erste Blick unter die Haube besser aufgehoben – dort werden diese Grundbegriffe erklärt, die dieses Aufbaumodul hier bereits voraussetzt.

Installationsüberschneidung mit dem Einstiegsmodul Kubernetes: Minikube, kubectl & Kubeconfig (dort ebenfalls Minikube/kubectl im Ordner mein-k8s-projekt, ohne die Voraussetzung “Docker Fortgeschritten”) – wer Namespace-Handling, kubectl-Debugging (logs/exec/ port-forward) und die Objekthierarchie noch nicht geübt hat, findet das dort vertieft. Dieses Aufbaumodul hier setzt direkt bei der kompose-Migration eines echten Compose-Stacks an, statt diese Grundlagen zu wiederholen.

Deployment-Mechanik (Rolling Update, Rollback, Skalierung), Health-Checks mit liveness-/readiness-/startupProbe sowie ConfigMap und Secret werden in diesem Modul nur so weit behandelt, wie es für die kompose-Migration nötig ist – vertieft werden sie im Modul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag.

Hands-on Inhalte (Auszug)

Architektur & erstes Deployment

  • Control Plane (API-Server, etcd, Scheduler, Controller Manager) und Worker Nodes (kubelet, Container Runtime, kube-proxy) im Zusammenspiel
  • Minikube als isolierter “Container-in-Container”-Cluster über den docker-Treiber, ganz ohne eigene VM
  • Ein Deployment mit zwei Replicas und ein NodePort-Service, deklarativ in YAML beschrieben und per kubectl apply angewendet

kompose-Migration (Kern-Hands-on)

  • Einen Drei-Dienste-Stack (Grafana, InfluxDB, Telegraf) aus compose.yaml per kompose convert automatisch in Kubernetes-Manifeste übersetzen
  • Verstehen, warum kompose für Dienste ohne ports:-Eintrag bewusst keinen Service anlegt (nur ein Deployment)
  • Die generierten Deployments anwenden und Grafana gezielt per kubectl expose –type=NodePort von außen erreichbar machen

Dashboard & Ingress

  • Das Kubernetes Dashboard als Add-on aktivieren und Workloads, Pod-Details und Live-Logs grafisch einsehen
  • Den Nginx-Ingress-Controller als Add-on aktivieren und zwei Ingress-Regeln für zwei unterschiedliche Domains anlegen
  • minikube tunnel und die lokale Hosts-Datei nutzen, um my-app.local und grafana.local über Port 80 statt wechselnder Zufalls-Ports zu erreichen

Aufräumen & Ausblick

  • minikube stop vs. minikube delete – Cluster pausieren oder restlos entfernen
  • Den kompletten Stack rein aus den eigenen YAML-Dateien heraus in Sekunden wiederherstellen
  • Amazon EKS, Azure AKS und Google GKE konzeptionell eingeordnet: Managed Control Plane, Serverless-Knoten, automatische Cloud-Integration – ohne eigenen Cloud-Account in dieser Session

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum lauffähigen Cluster, Ergebnis der kompose-Migration) 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