Training Module

Kubernetes GitOps at Scale — ApplicationSet & Generators

Dieses 110-Minuten-Modul löst das Problem, mit dem der Vorgängerkurs bewusst geendet hat: Dort habt ihr eine Parent-Application registriert, deren source ein Git-Verzeichnis mit drei Child-Application-Manifesten war – aber jede dieser drei Dateien musstet ihr weiterhin einzeln anlegen und pflegen. Bei drei Diensten ist das machbar. Bei zwanzig ist es die Aufgabe eines Generators. Genau dafür gibt es den ApplicationSet-Controller: Statt einer Application-Datei pro Anwendung schreibt ihr ein einziges ApplicationSet-Objekt, das über einen Generator automatisch beliebig viele Child-Applications erzeugt. Drei Generator-Typen lernt ihr heute kennen: den List-Generator (eine feste Liste von Key/Value-Paaren im Manifest selbst), den Git-Directory-Generator (jedes Verzeichnis, das einem Muster im Repo entspricht, wird automatisch zu einer Application) und – nur als Ausblick – den Cluster-Generator (eine Application pro registriertem Ziel-Cluster). Im ersten Hands-on baut ihr einen List-Generator, der aus einer festen Liste von drei Diensten automatisch drei Child-Applications erzeugt – dieselben drei Dienste (frontend, backend, worker), für die ihr im Vorgängerkurs noch drei einzelne Dateien in apps/ angelegt habt. Im zweiten Hands-on geht ihr einen Schritt weiter: Ihr legt einen Git-Directory-Generator an, der ein Verzeichnismuster im Repo beobachtet, und committet danach einen komplett neuen Ordner für einen vierten Dienst – ohne irgendeine Application-YAML anzufassen. Live seht ihr, wie der ApplicationSet-Controller daraus automatisch eine vierte Child-Application erzeugt. Zwei Grenzen dieses Kurses werden ausdrücklich benannt: Der Git-Generator pollt das Repo standardmäßig alle drei Minuten statt sofort zu reagieren – kein Bug, sondern eine bewusste Konfigurationsentscheidung, die sich per Webhook umgehen lässt. Und ein Tippfehler in einer Template-Variablen erzeugt keinen harten Validierungsfehler beim kubectl apply, sondern eine fehlerhafte oder unvollständig gerenderte Application, die erst beim Sync auffällt. Ein kurzer Ausblick ohne eigenes Hands-on rundet ab: der Cluster-Generator für Multi-Cluster-Rollouts sowie eine Abgrenzung zu Flux’ eigenem dependsOn-Modell. Ausdrücklich NICHT Teil dieses Kurses: ein eigenständiger Multi-Cluster-Hands-on, produktive Webhook-Konfiguration gegen einen echten Git-Provider und weitere Generator-Typen (SCM-, Pull-Request-, Matrix-/Merge-Generator). Pflicht ist das Modul “Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves” – dieses Modul setzt dessen Git-Repo und Minikube-Cluster direkt fort, statt sie zu wiederholen. Die Session läuft komplett lokal über Minikube ( –driver=docker) – der ApplicationSet-Controller läuft rein containerisiert im Cluster, ohne Cloud-Account und ohne Kostenwirkung.

Format

110 Minuten, live (remote oder vor Ort), Input & zwei Hands-on-Übungen

Teilnehmende

Absolvent:innen von “Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves”, die den manuellen apps/-Pflegeaufwand aus mehreren Child-Applications loswerden wollen

Voraussetzungen

Abgeschlossenes Modul “Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves” (Pflicht) – App-of-Apps-Pattern und Sync-Waves gelten als bekannt, lauffähige lokale Docker-Umgebung für Minikube

Warum dieses Training für deine Organisation wirkt

Ein Generator statt zwanzig Dateien

Statt für jeden Dienst eine eigene Application-Datei im Verzeichnis apps/ zu pflegen, beschreibt ein einziges ApplicationSet-Objekt, woher die Child-Applications kommen – der Rest entsteht automatisch.

Ein neuer Ordner reicht

Mit dem Git-Directory-Generator entsteht eine neue Application aus einem einzigen git push – ohne dass irgendjemand danach noch ein Application-Manifest schreiben oder anwenden muss.

Grenzen ehrlich benannt statt verschwiegen

Der Kurs zeigt nicht nur, was funktioniert, sondern auch, wo Automatisierung Zeit kostet (Polling-Intervall) oder Fehler leiser wird (Template-Rendering) – beides, bevor es im produktiven Rollout überrascht.

Was Teilnehmende mitnehmen

  • Den ApplicationSet-Controller als Erzeuger von Application-Objekten aus einem Generator einordnen, als direkte Weiterentwicklung des im Vorgängerkurs manuell gepflegten apps/-Verzeichnisses.
  • Die drei Generator-Typen List, Git-Directory und Cluster konzeptionell unterscheiden und benennen können, wann welcher Typ passt.
  • Einen List-Generator mit fester Elementliste aufsetzen und live beobachten, wie daraus mehrere Child-Applications automatisch entstehen.
  • Einen Git-Directory-Generator aufsetzen und live erleben, wie ein neu committeter Ordner im Repo automatisch eine neue Child-Application erzeugt, ohne dass eine Application-YAML dafür angefasst wird.
  • Benennen können, warum eine neue Application beim Git-Generator nicht sofort erscheint (Standard-Polling-Intervall), und wie ein Tippfehler in einer Template-Variablen zu einer fehlerhaft gerenderten statt einer beim Apply abgewiesenen Application führt.
  • Den Cluster-Generator für Multi-Cluster-Rollouts sowie Flux’ dependsOn-Modell konzeptionell einordnen – bewusst ohne eigenes Hands-on zu diesen Punkten.
  • Benennen, was dieses Modul bewusst nicht behandelt: einen eigenständigen Multi-Cluster-Hands-on, produktive Webhook-Konfiguration gegen einen echten Git-Provider und weitere Generator-Typen (SCM-, Pull-Request-, Matrix-/Merge-Generator).

Für wen dieses Modul ideal ist

  • • Absolvent:innen von “Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves” oder gleichwertigen Vorkenntnissen
  • • Teams, die App-of-Apps bereits einsetzen, aber den manuellen Pflegeaufwand pro Child-Application-Datei loswerden wollen
  • • Alle, die vor der Einführung von zehn oder mehr GitOps-verwalteten Diensten wissen wollen, wie sich das strukturell automatisieren lässt, statt jede Anwendung einzeln zu registrieren

Rahmendaten

  • • Dauer: 110 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, zwei Hands-on-Übungen (List-Generator; Git-Directory-Generator mit neuem Ordner → automatische Application)
  • • Voraussetzungen: abgeschlossenes Modul “Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves” (Pflicht), lauffähige lokale Docker-Umgebung für Minikube, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Recap: manuelle apps/-Pflege als Schmerzpunkt (10 min): kurzer Rückblick auf App-of-Apps aus dem Vorgängerkurs – drei Child-Applications, drei einzeln gepflegte Dateien in apps/, und die Frage, was bei zwanzig Diensten passiert.

  2. Konzept: ApplicationSet-Controller & Generator-Typen (20 min): der ApplicationSet-Controller als Erzeuger von Application-Objekten, die drei Generator-Typen List, Git-Directory und Cluster im Überblick, Template-Rendering mit {{.variable}}.

  3. Hands-on 1: List-Generator (30 min, Hands-on): ein ApplicationSet mit fester Elementliste anlegen, das dieselben drei Dienste aus dem Vorgängerkurs automatisch als Child-Applications erzeugt, ohne eine einzige Application-Datei von Hand zu schreiben.

  4. Hands-on 2: Git-Directory-Generator (30 min, Hands-on): ein ApplicationSet mit Git-Directory-Generator anlegen, danach einen neuen Ordner für einen vierten Dienst committen und pushen und live beobachten, wie daraus automatisch eine vierte Child-Application entsteht.

  5. Grenzen: Generator-Sync-Timing & Template-Fehlerbilder (10 min): das Standard-Polling-Intervall des Git-Generators, warum eine neue Application nicht sofort erscheint, und wie ein Tippfehler in einer Template-Variablen zu einer fehlerhaft gerenderten statt einer beim Apply abgewiesenen Application führt.

  6. Ausblick ohne Hands-on: Cluster-Generator & Flux-Abgrenzung (10 min): der Cluster-Generator für Multi-Cluster-Rollouts (eine Application pro registriertem Ziel-Cluster), sowie eine Abgrenzung zu Flux’ eigenem dependsOn-Modell aus dem Vorgängerkurs.

Dieses Modul setzt das Aufbaumodul Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves zwingend voraus. Das App-of-Apps-Pattern, die Annotation argocd.argoproj.io/sync-wave und der dort aufgebaute Minikube-Cluster samt Git-Repo gelten als bekannt und werden hier nicht erneut hergeleitet – Hands-on 1 verwendet direkt dieselben drei Dienste (frontend/backend/ worker), die im Vorgängerkurs noch manuell als Child-Application-Dateien in apps/ gepflegt wurden.

Was dieses Modul bewusst nicht behandelt: produktive Webhook-Konfiguration gegen einen echten Git-Provider (GitHub/GitLab) zur Umgehung des Polling-Intervalls, sowie weitere Generator-Typen wie SCM-Provider-, Pull-Request- oder Matrix-/Merge-Generator. Beide werden nur genannt, nicht vertieft. Für den Cluster-Generator selbst gibt es dafür das eigenständige Aufbaumodul Kubernetes GitOps at Scale — Multi-Cluster mit dem ApplicationSet Cluster-Generator , das direkt auf diesem Kurs aufsetzt und dieselbe Anwendung services/frontend weiterverwendet. Für den Matrix-Generator (Cluster- mit Git-Directory-Generator kombiniert) gibt es darauf aufbauend das weitere Aufbaumodul Kubernetes GitOps at Scale — Matrix-Generator: Cluster × Verzeichnis kombiniert , das den in diesem Kurs eingeführten Git-Directory-Generator voraussetzt. Für die vertiefte Abgrenzung zu Flux’ eigenem dependsOn-Modell samt Umstiegsszenario gibt es das eigenständige Aufbaumodul Kubernetes GitOps mit Flux — Abgrenzung und Umstieg von ArgoCD. Kein CI/Image-Build (das leistet das Modul CI: Continuous Integration & der Build-Prozess ). Und keine Progressive Delivery – dafür gibt es das eigenständige Aufbaumodul Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts.

Hands-on Inhalte (Auszug)

List-Generator anlegen

  • Ein ApplicationSet mit generators: - list: und einer festen Elementliste (frontend/backend/worker) anwenden
  • Mit kubectl -n argocd get application -w live sehen, wie drei Child-Applications aus der Liste entstehen – ohne eine einzige davon selbst per kubectl apply registriert zu haben

Neuen Dienst zur Liste hinzufügen

  • Ein viertes Element im ApplicationSet-Manifest ergänzen und erneut anwenden
  • Beobachten, dass beim List-Generator jede neue Anwendung weiterhin eine Änderung am ApplicationSet-Manifest selbst braucht

Git-Directory-Generator anlegen

  • Ein ApplicationSet mit generators: - git: directories: und einem Verzeichnismuster (services/*) anwenden – einmalig, keine weitere Änderung nötig
  • Namensbildung über {{.path.basename}} und {{.path.path}} aus dem tatsächlichen Verzeichnisnamen im Repo

Neuen Ordner committen, ohne YAML anzufassen

  • Einen vierten Dienst als neuen Ordner im Repo anlegen, committen und pushen – kein Application-Manifest dafür schreiben
  • Live beobachten, wie der ApplicationSet-Controller nach dem nächsten Poll automatisch eine vierte Child-Application erzeugt

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit vom Commit des neuen Ordners bis zur bestätigt Synced/Healthy Child-Application) 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