Training Module
Kubernetes GitOps — Deklaratives Deployment mit ArgoCD
In diesem 100-Minuten-Modul dreht ihr die Deployment-Richtung um. Bisher
kanntet ihr kubectl apply -f aus einer CI-Pipeline heraus –
die Pipeline schreibt aktiv in den Cluster, braucht dafür
Cluster-Credentials und merkt eine Abweichung erst beim nächsten Lauf.
Das GitOps-Grundmodell dreht das Prinzip um:
Push-based (die Pipeline drückt Änderungen in den Cluster) wird zu
Pull-based (ein Operator im Cluster holt sich Änderungen aus Git) –
mit einer Reconciliation-Loop, die kontinuierlich
prüft, ob Ist- und Soll-Zustand übereinstimmen. Danach seziert ihr die
ArgoCD-Architektur: die Application-CRD
als zentrales Objekt, und die bewusste Trennung zweier Zustände, die
leicht verwechselt werden – Sync-Status (
Synced/OutOfSync, stimmt der Cluster-Zustand
mit Git überein?) gegen Health-Status (
Healthy/Degraded/Progressing,
läuft die Anwendung tatsächlich?). Im ersten Hands-on installiert ihr
ArgoCD in einem lokalen Minikube-Cluster und registriert eure erste
Application gegen ein Git-Repo mit Manifesten – analog zu
den aus “Kubernetes Workloads & Konfiguration” bekannten Deployment-/
Service-Manifesten – und beobachtet den Auto-Sync live. Im zweiten
Hands-on löst ihr per manuellem kubectl scale gegen einen
GitOps-verwalteten Namespace bewusst eine Abweichung aus und seht, wie
ArgoCD sie über Drift Detection & Self-Healing
automatisch zurücksynct. Im dritten Hands-on rollt ihr nicht mit dem
aus “Workloads & Konfiguration” bekannten
kubectl rollout undo zurück – das würde ein Self-Healing
GitOps-Setup im nächsten Reconciliation-Zyklus einfach wieder
überschreiben –, sondern per git revert: der Git-Commit
ist die Wahrheit, nicht der Cluster-Zustand. Ein kurzer Ausblick ohne
eigenes Hands-on rundet ab: Helm-Chart als Application-Source,
App-of-Apps-Pattern, Sync-Waves, und eine Zeile Abgrenzung zu Flux als
alternativem GitOps-Operator. Ausdrücklich NICHT Teil dieses
Kurses: CI/Image-Build (das leistet das Modul “CI: Continuous
Integration & der Build-Prozess”), das App-of-Apps-Pattern und
Sync-Waves als eigenständige Vertiefung mit eigenem Hands-on – dafür
gibt es das Aufbaumodul
Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves
–, und Progressive Delivery mit Argo Rollouts – dafür baut das
Aufbaumodul
Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts
direkt auf diesem Kurs auf. Pflicht ist
das Modul “Kubernetes Workloads & Konfiguration”, empfohlen, aber
keine Pflicht, ist “Helm — Paketmanagement für Kubernetes” (relevant
für den Ausblick auf Helm-Chart als Application-Source). Die Session
läuft komplett lokal über Minikube (–driver=docker) –
ArgoCD selbst läuft rein containerisiert im Cluster, ohne
Cloud-Account und ohne Kostenwirkung.
Format
100 Minuten, live (remote oder vor Ort), Input & drei Hands-on-Übungen
Teilnehmende
Entwickler:innen und Ops, die Deployments über Git statt über direkten Cluster-Zugriff steuern wollen
Voraussetzungen
Abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” (Pflicht), “Helm — Paketmanagement für Kubernetes” empfohlen, aber keine Pflicht, lauffähige lokale Docker-Umgebung für Minikube
Warum dieses Training für deine Organisation wirkt
Pull statt Push dreht das Risiko um
Eine CI-Pipeline mit kubectl apply braucht
Cluster-Credentials außerhalb des Clusters – ein Angriffsziel.
ArgoCD als Pull-based Operator läuft im Cluster und holt sich
Änderungen selbst; kein externer Zugriff mit Schreibrechten nötig.
Drift wird nicht bemerkt, sondern korrigiert
Ein manueller kubectl scale oder ein Hotfix direkt
im Cluster fällt bei klassischem CI/CD erst beim nächsten
Deployment auf. Die Reconciliation-Loop erkennt und korrigiert
solche Abweichungen kontinuierlich, ohne dass jemand danach sucht.
Rollback ist ein Git-Commit, kein Cluster-Befehl
git revert statt kubectl rollout undo –
der Unterschied ist mehr als Geschmackssache: Bei Self-Healing
GitOps überschreibt der nächste Reconciliation-Zyklus einen
reinen Cluster-Rollback wieder, wenn Git nicht mitzieht.
Was Teilnehmende mitnehmen
- Push- vs. Pull-based Deployment unterscheiden und gegen ein klassisches
kubectl applyaus einer CI-Pipeline abgrenzen, inklusive Reconciliation-Loop als Kernmechanismus. - Die ArgoCD-
Application-CRD lesen und einordnen sowie Sync-Status (Synced/OutOfSync) sauber von Health-Status (Healthy/Degraded/Progressing) unterscheiden. - ArgoCD in einem lokalen Minikube-Cluster installieren und eine erste
Applicationgegen ein Git-Repo mit Manifesten registrieren, Auto-Sync live beobachten. - Drift Detection & Self-Healing live nachvollziehen: einen GitOps-verwalteten Namespace manuell per
kubectl scaleverändern und beobachten, wie ArgoCD automatisch zurücksynct. - Einen Rollback per
git revertstattkubectl rollout undodurchführen und begründen, warum der Cluster-Befehl bei aktivem Self-Healing keine dauerhafte Lösung ist. - Helm-Chart als Application-Source, App-of-Apps und Sync-Waves konzeptionell einordnen sowie ArgoCD in einem Satz von Flux abgrenzen – bewusst ohne eigenes Hands-on zu diesen Punkten.
- Benennen, was dieses Modul bewusst nicht behandelt: CI/Image-Build, App-of-Apps und Sync-Waves als eigene Vertiefung, und Progressive Delivery mit Argo Rollouts.
Für wen dieses Modul ideal ist
- • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Workloads & Konfiguration” oder gleichwertigen Vorkenntnissen
- • Teams, deren CI-Pipeline heute direkt mit
kubectl applyin den Cluster schreibt und die diese Cluster-Credentials aus der Pipeline entfernen wollen - • Alle, die vor dem ersten produktiven GitOps-Rollout wissen wollen, was Self-Healing für einen manuellen Cluster-Eingriff bedeutet – bevor es überrascht
Rahmendaten
- • Dauer: 100 Minuten live (remote oder vor Ort)
- • Format: Input, Live-Demo, drei Hands-on-Übungen (ArgoCD-Installation & erste Application, Drift Detection & Self-Healing, Rollback per git revert)
- • Voraussetzungen: abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” (Pflicht), “Helm — Paketmanagement für Kubernetes” empfohlen, lauffähige lokale Docker-Umgebung für Minikube, keine Cloud-Kostenwirkung
Modulaufbau & Agenda
GitOps-Grundmodell (15 min): Push- vs. Pull-based Deployment, die Reconciliation-Loop als Kernmechanismus, Abgrenzung zu klassischem
kubectl applyaus einer CI-Pipeline.ArgoCD-Architektur (15 min): die
Application-CRD als zentrales Objekt, Sync-Status (Synced/OutOfSync) gegen Health-Status (Healthy/Degraded/Progressing).Hands-on 1: ArgoCD installieren & erste Application (30 min, Hands-on): ArgoCD in einem lokalen Minikube-Cluster installieren, eine erste
Applicationaus einem Git-Repo mit Manifesten registrieren, Auto-Sync live beobachten.Hands-on 2: Drift Detection & Self-Healing (15 min, Hands-on): manueller
kubectl scalegegen einen GitOps-verwalteten Namespace, live beobachten, wie ArgoCD automatisch zurücksynct.Hands-on 3: Rollback per git revert (15 min, Hands-on): Rollback über
git revertstattkubectl rollout undo– bewusste Abgrenzung zum in “Workloads & Konfiguration” gelehrten Befehl.Ausblick ohne Hands-on (10 min): Helm-Chart als Application-Source, App-of-Apps-Pattern, Sync-Waves, eine Zeile Abgrenzung zu Flux; Progressive Delivery mit Argo Rollouts ausdrücklich nicht Teil dieses Kurses, sondern eigenes Aufbaumodul.
Dieses Modul setzt das Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag voraus. Deployment, Service, ConfigMap und Secret als Objekte werden dort erklärt und hier als bekannt vorausgesetzt – die Manifeste in Hands-on 1 sind bewusst analog zu den dort geschriebenen aufgebaut.
Empfohlen, aber keine Pflicht, ist das Vertiefungsmodul Helm — Paketmanagement für Kubernetes. Wer es bereits abgeschlossen hat, erkennt im Ausblick auf “Helm-Chart als Application-Source” sofort den Anschluss an Chart/ Release/Repository; wer es noch nicht hat, kann diesem Kurs trotzdem vollständig folgen – der Ausblick bleibt ohne eigenes Hands-on und wird hier nicht vertieft.
Die konzeptionelle Grundlage zu GitOps – Push vs. Pull, die vier OpenGitOps-Prinzipien, ArgoCD und Flux im Werkzeugvergleich – erklärt bereits der frei zugängliche Artikel Was ist GitOps?. Dieses Modul setzt darauf auf und macht daraus ein strukturiertes, buchbares Live-Training mit echtem Hands-on gegen einen laufenden Minikube-Cluster statt nur Lesestoff.
Was dieses Modul bewusst nicht behandelt: den Build eines Container-Images oder eine CI-Pipeline davor – das leistet das Vertiefungsmodul CI: Continuous Integration & der Build-Prozess, hier wird ein bereits vorhandenes Image vorausgesetzt. Ebenfalls nicht Thema: Flux als alternativer GitOps-Operator über eine konzeptionelle Abgrenzungszeile im Ausblick hinaus – die vertiefte Abgrenzung und das Umstiegsszenario liefert jetzt das eigenständige Aufbaumodul Kubernetes GitOps mit Flux — Abgrenzung und Umstieg von ArgoCD, sowie das App-of-Apps-Pattern und Sync-Waves als eigenständige Vertiefung mit eigenem Hands-on – dafür gibt es jetzt das Aufbaumodul Kubernetes GitOps at Scale — App-of-Apps & Sync-Waves, sowie Progressive Delivery mit Argo Rollouts (Canary/Blue-Green) – das bleibt bewusst außen vor, kein Bestandteil dieses Kurses. Wer direkt weitermachen will, findet es als eigenständiges Aufbaumodul: Kubernetes Progressive Delivery — Canary & Blue-Green mit Argo Rollouts.
Hands-on Inhalte (Auszug)
ArgoCD installieren
- Minikube mit
minikube start –driver=dockerstarten, Namespaceargocdanlegen und ArgoCD über das offizielle Install-Manifest anwenden - Mit
kubectl -n argocd rollout status deploy/argocd-serverabwarten, bis ArgoCD selbst vollständig läuft – rein containerisiert im Cluster, ohne Cloud-Zugriff
Erste Application & Auto-Sync
- Eine
Application-Ressource anwenden, die auf ein Git-Repo mit Deployment-/Service-Manifesten zeigt, mitsyncPolicy.automatedfür Auto-Sync - Sync-Status
Syncedund Health-StatusHealthylive perkubectl -n argocd get applicationbestätigen
Drift Detection & Self-Healing
- Mit
kubectl scaledie Replica-Zahl im GitOps-verwalteten Namespace manuell verändern, ohne Git anzufassen - Beobachten, wie der Sync-Status kurzzeitig auf
OutOfSyncspringt und Self-Healing die manuelle Änderung automatisch zurücksynct
Rollback per git revert
- Eine fehlerhafte Änderung committen, live ausrollen lassen und live erleben, dass
kubectl rollout undovon Self-Healing wieder überschrieben wird - Stattdessen
git revertauf den fehlerhaften Commit anwenden und pushen, und den automatischen Re-Sync auf den korrekten Zustand bestätigen
Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit von der Application-Registrierung bis zum ersten bestätigten Synced/Healthy-Status) 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