Training Module
Kubernetes Infrastructure as Code — Kustomize, Validierung & E2E-Testing mit Kuttl
In “Kubernetes Workloads & Konfiguration” habt ihr Deployment, Service, ConfigMap
und Secret als rohe Manifeste geschrieben und per kubectl apply direkt
angewendet. Dieses 150-Minuten-Aufbaumodul dreht die Perspektive um: Statt
einzelner Befehle steht das Everything-as-Code-Paradigma im
Zentrum – der bewusste Wechsel von der imperativen Befehlskette
zur deklarativen Soll-Zustands-Beschreibung, und die Frage, wer
die Last trägt, diesen Soll-Zustand dauerhaft durchzusetzen. Ihr seziert den
Reconciliation Loop als generisches Steuerungsmuster anhand des
TOTE-Modells (Test–Operate–Test–Exit) aus der
Kognitionspsychologie und beobachtet live, warum ein imperativ erzeugter Pod ohne
übergeordneten Controller nach dem Löschen nicht zurückkommt. Danach rüstet ihr
euer YAML-Handwerkszeug auf: Einrückungsregeln, das strikte
Tabulator-Verbot, Anchors & Aliases als YAMLs eigenes
DRY-Prinzip, sowie das berüchtigte Norwegen-Problem der
automatischen Typinferenz (Norway: NO wird von älteren Parsern
stillschweigend zu false). Im Kern der Session baut ihr mit
Kustomize eine wiederverwendbare base/-Konfiguration
und leitet daraus per Overlay und gezieltem Patching zwei eigenständige
Umgebungen ab – ein schlankes Dev-Overlay mit
configMapGenerator und ein hochverfügbares Prod-Overlay mit
externem LoadBalancer-Service –, validiert das generierte Ergebnis
mit Kubeconform gegen das offizielle Kubernetes-Schema, bevor
irgendetwas den Cluster erreicht, und schließt mit der tatsächlichen
Bereitstellung, einer live beobachteten Selbstheilung sowie einem deklarativen
End-to-End-Test mit Kuttl (Kubernetes Test Tool) samt
kontrolliertem Aufräumen ab. Abgrenzung zu zwei benachbarten Themen: Anders als
Terraform-Grundlagen
geht es hier nicht um HCL, Provider oder Remote-State für Cloud-Infrastruktur
außerhalb des Clusters, sondern ausschließlich um native
Kubernetes-Manifeste und das dafür in kubectl eingebaute Kustomize. Und anders
als die GitOps-Operator-Module
ArgoCD
oder
Flux,
die den Pull-Mechanismus und die Reconciliation im Cluster-Controller
behandeln, liegt der Fokus dieses Moduls auf den Werkzeugen
davor: den YAML-Manifesten selbst, ihrer strukturierten
Overlay-Ableitung und ihrer automatisierten Validierung und Testbarkeit, bevor
überhaupt ein GitOps-Controller ins Spiel kommt.
Format
150 Minuten, live (remote oder vor Ort), Input & vier Hands-on-Übungen
Teilnehmende
Absolvent:innen von “Kubernetes Workloads & Konfiguration”, die rohe Manifeste kennen und jetzt strukturiert, validiert und testbar als Code verwalten wollen
Voraussetzungen
Abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” (Pflicht) – Deployment, Service, ConfigMap und Secret als Manifest gelten als bekannt; keine GitOps-Vorkenntnis nötig; lauffähige lokale Docker-Umgebung für einen k3d-Cluster
Warum dieses Training für deine Organisation wirkt
Vom Einzelbefehl zum wiederverwendbaren Code
Statt für jede Umgebung eigene, duplizierte Manifeste zu pflegen, baut ihr
eine einzige base/-Konfiguration und leitet Dev und Prod
daraus per Overlay und Patch ab – Änderungen an einer Stelle, nicht in
drei Kopien.
Fehler vor dem Cluster abfangen
Kubeconform prüft jedes generierte Manifest gegen das offizielle Kubernetes-Schema, bevor es überhaupt an eine Pipeline oder einen Cluster geht – Tippfehler und falsche Datentypen werden zum Lint-Fehler, nicht zum Produktionsvorfall.
Behauptung wird zum automatisierten Test
Mit Kuttl schreibt ihr die Erwartung an euer Deployment als deklarative
Testdatei statt als manuellen Blick auf kubectl get pods –
wiederholbar, versionierbar und ohne manuelles Nachschauen nach jedem
Deploy.
Was Teilnehmende mitnehmen
- Das Everything-as-Code-Paradigma benennen und begründen: warum deklarative Soll-Zustands-Beschreibung imperativen Befehlsketten im produktiven Betrieb überlegen ist, und wo imperative Befehle trotzdem ihre Berechtigung behalten.
- Den Reconciliation Loop als generisches Steuerungsmuster erklären und über das TOTE-Modell (Test-Operate-Test-Exit) aus der Kognitionspsychologie einordnen – inklusive der Grenzen des Loops, wenn Vorbedingungen wie ein existierendes Image fehlen.
- YAML-Grundlagen sicher selbst schreiben: die drei Grundelemente (Schlüssel-Wert-Paar, Liste, Verschachtelung), die Zwei-Leerzeichen-Konvention und das absolute Tabulator-Verbot.
- YAML-Anchors (
&) und Aliases (*) inklusive Merge-Syntax (<<:) als DRY-Prinzip einsetzen, sowie das Norwegen-Problem der automatischen Typinferenz erkennen und durch konsequentes Quoting umgehen. - Eine Kustomize-Base (Deployment, Service,
kustomization.yaml) selbst aufbauen und daraus mit gezielten Patches,commonLabels/commonAnnotationsund demconfigMapGeneratoreigenständige Dev- und Prod-Overlays ableiten. - Generierte Manifeste mit Kubeconform per
-strict-Schema-Validierung prüfen und diesen Schritt als Pipeline-Stufe vor jedemkubectl applyeinordnen. - Einen deklarativen End-to-End-Test mit Kuttl schreiben (
kuttl-test.yaml, Assert-Datei), gegen den laufenden Cluster ausführen und die erzeugten Testressourcen kontrolliert wieder aufräumen.
Für wen dieses Modul ideal ist
- • Absolvent:innen von “Kubernetes Workloads & Konfiguration” oder gleichwertigen Vorkenntnissen im Schreiben roher Manifeste
- • Teams, die von duplizierten Umgebungs-Manifesten auf eine strukturierte Base-/Overlay-Architektur umstellen wollen
- • Alle, die Manifest-Fehler künftig vor dem Deployment statt im Cluster-Incident finden wollen
Rahmendaten
- • Dauer: 150 Minuten live (remote oder vor Ort)
- • Format: Input, Live-Demo, vier Hands-on-Übungen (Base schreiben, Dev-/Prod-Overlays mit ConfigMapGenerator, Kubeconform-Validierung, Deployment & Kuttl-E2E-Test mit Cleanup)
- • Voraussetzungen: abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” (Pflicht), keine GitOps-Vorkenntnis nötig, lauffähige lokale Docker-Umgebung für einen k3d-Cluster, keine Cloud-Kostenwirkung
Modulaufbau & Agenda
Everything-as-Code: deklarativ vs. imperativ & Praxisumgebung (15 min): warum imperative Befehlsketten im produktiven Betrieb vom exakten Ist-Zustand abhängen und schwer nachvollziehbar sind, wie deklarativer Code stattdessen nur den Soll-Zustand beschreibt, und Start eines lokalen k3d-Clusters als gemeinsame Praxisumgebung für die gesamte Session.
Der Reconciliation Loop & das TOTE-Modell (15 min): das generische Test-Operate-Test-Exit-Steuerungsmuster aus der Kognitionspsychologie, übertragen auf Kubernetes-Controller; live beobachtet an einem imperativ erzeugten Einzel-Pod, der nach dem Löschen mangels übergeordnetem Soll-Zustand nicht zurückkommt.
Hands-on 1: YAML-Grundlagen & die Kustomize-Base schreiben (30 min, Hands-on): Einrückungsregeln, Tabulator-Verbot und die drei YAML-Grundelemente anhand von
deployment.yaml,service.yamlund der Steuerdateikustomization.yamlimbase/-Ordner selbst schreiben und mitkubectl kustomizegegenlesen.Fortgeschrittenes YAML: Anchors, Aliases & das Norwegen-Problem (15 min): Anchors (
&) und Aliases (*) inklusive Merge-Syntax als DRY-Prinzip, mehrzeilige Textblöcke, sowie die automatische Typinferenz unquotierter Werte am klassischen BeispielNorway: NO.Hands-on 2: Repo-Strukturen, Branching & Kustomize-Overlays Dev vs. Prod (35 min, Hands-on): Verzeichnisstrukturen und Branching-Modelle für Infrastruktur-Code im Überblick, danach ein Dev-Overlay mit gezieltem Patch und
configMapGeneratorsowie ein Prod-Overlay mit zwei getrennten Patches (Replikazahl, Release-Image, externerLoadBalancer-Service) selbst bauen.Hands-on 3: GitOps-Pipeline-Kontext & Kubeconform-Schema-Validierung (20 min, Hands-on): Push-Pipelines gegen das GitOps-Pull-Prinzip abgegrenzt, danach die generierten Dev- und Prod-Manifeste per Pipe direkt an Kubeconform übergeben und mit
-strict -summarygegen das offizielle Kubernetes-Schema validieren.Hands-on 4: Bereitstellung, Selbstheilung live & E2E-Test mit Kuttl (20 min, Hands-on): Dev-Overlay deklarativ im Cluster ausrollen, einen Pod gezielt löschen und die automatische Selbstheilung durch den Deployment-Controller live beobachten, einen deklarativen Kuttl-Test schreiben und ausführen, zum Abschluss alle Testressourcen kontrolliert aufräumen.
Dieses Modul setzt das Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag zwingend voraus. Deployment, Service, ConfigMap und Secret als einzelne, von Hand geschriebene und angewendete Manifeste gelten als bekannt und werden hier nicht erneut eingeführt – dieses Modul beginnt direkt bei der Frage, wie diese Manifeste strukturiert, wiederverwendbar, validiert und testbar als Code verwaltet werden. Keine GitOps-Vorkenntnis nötig: Reconciliation Loop wird in Block 2 vollständig generisch hergeleitet, ohne einen konkreten GitOps-Controller vorauszusetzen.
Wer nach diesem Modul wissen will, wie ein GitOps-Controller diesen
Reconciliation Loop tatsächlich im Cluster durchsetzt – Application-CRD,
Sync-Status gegen Health-Status, Drift Detection & Self-Healing sowie
Rollback per git revert – findet das im Aufbaumodul
Kubernetes GitOps — Deklaratives Deployment mit ArgoCD.
Die dort ausgerollten Manifeste können mit dem in diesem Modul gelehrten
Kustomize-, Kubeconform- und Kuttl-Werkzeugkasten vorbereitet und geprüft
werden, bevor sie überhaupt in ein GitOps-Repository wandern.
Hands-on Inhalte (Auszug)
Kustomize-Base selbst schreiben
- Ein generisches Deployment und einen
ClusterIP-Service als eigenständige YAML-Dateien anlegen - Die Steuerdatei
kustomization.yamlschreiben, die beide Manifeste zu einem Kustomize-Paket bündelt, und das Ergebnis mitkubectl kustomize .gegenlesen
Dev- und Prod-Overlay bauen
- Dev-Overlay: Replikazahl und Image gezielt patchen, dazu eine ConfigMap dynamisch aus einer Properties-Datei und einem Literal generieren
- Prod-Overlay: höhere Replikazahl, geprüftes Release-Image und Umstellung auf einen extern erreichbaren
LoadBalancer-Service über zwei getrennte Patch-Dateien
Kubeconform-Validierung vor dem Cluster
- Das generierte Dev-Overlay per Pipe direkt an
kubeconform -strict -summaryübergeben, ohne vorher irgendetwas im Cluster anzuwenden - Die Validierungs-Zusammenfassung lesen und verstehen, welche Fehlerklassen ein Schema-Validator vor dem Deployment abfängt
E2E-Test mit Kuttl schreiben & aufräumen
- Eine
kuttl-test.yamlsowie eine Assert-Datei mit der erwarteten Anzahl betriebsbereiter Replicas deklarativ schreiben - Den Test per
kubectl kuttl testausführen und anschließend alle im Cluster erzeugten Ressourcen kontrolliert wieder entfernen
Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit von der leeren Base bis zum bestandenen Kuttl-Test) 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