Kubernetes Schulung für Entwickler: Helm, Kustomize und CKAD

Lokaler Entwicklungscluster und der erste eigene Dienst

• Was Entwickler:innen über Kubernetes wissen müssen und was beim Plattformbetrieb bleibt
• Arbeitsplatz einrichten: kubectl, Kontext, Namespace und YAML-Schema im Editor
• Lokaler Cluster mit minikube oder kind, eigenes Image per kind load ohne Registry laden
• Ersten eigenen Container als Pod starten: Image-Tag, imagePullPolicy und Startbefehl
• Den Pod über einen Service im Cluster ansprechbar machen
• Zugriff von außen über NodePort und LoadBalancer und ihre Grenzen
• HTTP-Routing: Ingress im Bestand, HTTPRoute der Gateway API für neue Dienste (Ingress-NGINX seit März 2026 eingestellt)

Den Cluster mit kubectl erkunden

• Ressourcen untersuchen mit -o yaml, -o jsonpath und kubectl describe
• Logs mehrerer Container und Replikate verfolgen: -c, -f, --since und -l
• Befehle im Container ausführen mit kubectl exec, Dateien kopieren mit kubectl cp
• Web-Ansicht des Clusters mit Headlamp, Nachfolger des archivierten Kubernetes Dashboard

Workloads aus der Praxis

• Deployment für zustandslose Dienste, StatefulSet für Dienste mit stabiler Identität
• Rolling Updates mit maxSurge, Rollout-Historie, kubectl rollout undo und revisionHistoryLimit
• Batch-Verarbeitung: Jobs mit Parallelität und Indexed Jobs, CronJobs mit concurrencyPolicy
• Deployment-Strategien: Recreate, Blue-Green über den Service-Selektor, Canary mit Gewichtung
• Sauber herunterfahren: SIGTERM, terminationGracePeriodSeconds und preStop-Hook

Kubernetes über den eigenen Dienst informieren

• Liveness-, Readiness- und Startup-Probe passend zum Startverhalten des Dienstes entwerfen
• Requests und Limits aus Messwerten ableiten; Ressourcen laufender Pods ohne Neustart anpassen
• Platzierung beeinflussen: nodeSelector, Taints und Tolerations aus Sicht der Anwendung
• Node-Affinität und Pod-Anti-Affinität, damit Replikate nicht auf demselben Node landen
• Horizontal Pod Autoscaler mit CPU- und eigenen Metriken, KEDA für Warteschlangenlänge
• ConfigMaps als Variablen und Dateien; Rollout auslösen, wenn sich die Konfiguration ändert
• Secrets bereitstellen; External Secrets Operator oder Sealed Secrets für Git-Workflows
• NetworkPolicy für den eigenen Dienst schreiben: nur erlaubte Aufrufer und Ziele
• RBAC aus Anwendungssicht: eigener ServiceAccount statt default mit minimalen Rechten
• Übung: Dienst liest über die Kubernetes-API nur die ConfigMaps seines Namespace
• SecurityContext: runAsNonRoot, schreibgeschütztes Root-Dateisystem, Capabilities entfernen

Erweiterte Deployment-Muster

• Namespaces je Umgebung oder Feature-Branch: Konventionen und Aufräumen
• Arbeiten mit Namespaces: Standard im Kontext setzen, Quotas und LimitRanges aus Entwicklersicht
• Funktionen ergänzen mit Init-Containern und nativen Sidecars (restartPolicy: Always)
• Service Mesh im Überblick: Sidecar-Proxys bei Linkerd, Istio im Ambient-Modus ohne Sidecars
• Datenverkehr und Fehlerraten zwischen Diensten mit Linkerd Viz analysieren
• Kubernetes erweitern: CRDs lesen, vorhandene Operatoren nutzen statt eigene zu schreiben

Manifeste paketieren mit Helm und Kustomize

• Warum Manifeste generieren: mehrere Umgebungen, Wiederholungen, Versionierung
• Helm-Chart für den eigenen Dienst: Templates, values.yaml, helm template und helm upgrade --install
• Kustomize mit Basis, Overlays und Patches, angewendet über kubectl apply -k
• Helm, Kustomize oder beides: Entscheidungshilfen aus Projekten
• Charts als OCI-Artefakte in der Container-Registry veröffentlichen

Fehlersuche und schneller Entwicklungszyklus

• kubectl debug mit ephemerem Container oder als Kopie des Pods mit anderem Image
• Debug-Images bei Bedarf zusammenstellen mit nixery.dev, alternativ netshoot
• Netzwerkverkehr mitschneiden: tcpdump im ephemeren Container, Mitschnitt in Wireshark auswerten
• Bauen, Laden und Neuausrollen bei jeder Codeänderung mit Skaffold oder Tilt
• Lokalen Prozess in den Clusterverkehr einklinken mit Telepresence oder mirrord
• CKAD-Training: Manifeste schnell erzeugen mit kubectl create … --dry-run=client -o yaml

Kubernetes-Dienste mit GitHub Copilot entwickeln

• Manifest-Vorschläge gegen das JSON-Schema der Cluster-Version prüfen, kubeconform im Pre-commit-Hook
• Chart-Änderungen des Agenten zuerst als helm diff upgrade ansehen, dann installieren
• Skaffold-Schleife als Rückmeldung: Agent sieht Build-Fehler, Probe-Fehlschläge und Pod-Logs
• Probes und Requests nur aus gemessenen Start- und Speicherwerten ableiten lassen, nicht geschätzt
• Eigener Namespace mit ResourceQuota je Agentensitzung schützt den gemeinsamen Entwicklungscluster

Praxisprojekt: Bestelldienst mit Worker auf Kubernetes

• Bestell-API, RabbitMQ und Worker als Helm-Chart mit Werten für dev und prod
• Datenbankmigration als Job per Helm-Hook vor jedem Rollout
• Worker per KEDA nach Warteschlangenlänge skalieren, API per HTTPRoute als Canary ausrollen
• Absichtlich eingebauten Fehler mit Skaffold und kubectl debug finden und beheben

Lernziele

• Sie schreiben Manifeste für Deployments, Services, Jobs und HTTPRoutes und rollen sie kontrolliert aus
• Sie versorgen Dienste mit ConfigMaps, Secrets, Probes, Ressourcenangaben und einem eigenen ServiceAccount
• Sie paketieren einen Dienst als Helm-Chart und pflegen Umgebungen mit Kustomize-Overlays
• Sie wählen eine Deployment-Strategie und nehmen fehlerhafte Versionen zurück
• Sie finden Fehler mit kubectl debug und verkürzen den Entwicklungszyklus mit Skaffold oder Telepresence

Zielgruppe

• Entwickler:innen, die ihre Dienste selbst auf Kubernetes bringen und dort verantworten
• Teams, die von Docker Compose auf Kubernetes umsteigen
• Kandidat:innen für die Zertifizierung Certified Kubernetes Application Developer (CKAD)