Mitglied werden – KI-Tutor mit vollen Antworten

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/commonAnnotations und dem configMapGenerator eigenständige Dev- und Prod-Overlays ableiten.
  • Generierte Manifeste mit Kubeconform per -strict-Schema-Validierung prüfen und diesen Schritt als Pipeline-Stufe vor jedem kubectl apply einordnen.
  • 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

  1. 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.

  2. 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.

  3. 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.yaml und der Steuerdatei kustomization.yaml im base/-Ordner selbst schreiben und mit kubectl kustomize gegenlesen.

  4. 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 Beispiel Norway: NO.

  5. 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 configMapGenerator sowie ein Prod-Overlay mit zwei getrennten Patches (Replikazahl, Release-Image, externer LoadBalancer-Service) selbst bauen.

  6. 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 -summary gegen das offizielle Kubernetes-Schema validieren.

  7. 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.yaml schreiben, die beide Manifeste zu einem Kustomize-Paket bündelt, und das Ergebnis mit kubectl 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.yaml sowie eine Assert-Datei mit der erwarteten Anzahl betriebsbereiter Replicas deklarativ schreiben
  • Den Test per kubectl kuttl test ausfü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