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 apply aus 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 Application gegen ein Git-Repo mit Manifesten registrieren, Auto-Sync live beobachten.
  • Drift Detection & Self-Healing live nachvollziehen: einen GitOps-verwalteten Namespace manuell per kubectl scale verändern und beobachten, wie ArgoCD automatisch zurücksynct.
  • Einen Rollback per git revert statt kubectl rollout undo durchfü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 apply in 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

  1. GitOps-Grundmodell (15 min): Push- vs. Pull-based Deployment, die Reconciliation-Loop als Kernmechanismus, Abgrenzung zu klassischem kubectl apply aus einer CI-Pipeline.

  2. ArgoCD-Architektur (15 min): die Application-CRD als zentrales Objekt, Sync-Status (Synced/OutOfSync) gegen Health-Status (Healthy/Degraded/Progressing).

  3. Hands-on 1: ArgoCD installieren & erste Application (30 min, Hands-on): ArgoCD in einem lokalen Minikube-Cluster installieren, eine erste Application aus einem Git-Repo mit Manifesten registrieren, Auto-Sync live beobachten.

  4. Hands-on 2: Drift Detection & Self-Healing (15 min, Hands-on): manueller kubectl scale gegen einen GitOps-verwalteten Namespace, live beobachten, wie ArgoCD automatisch zurücksynct.

  5. Hands-on 3: Rollback per git revert (15 min, Hands-on): Rollback über git revert statt kubectl rollout undo – bewusste Abgrenzung zum in “Workloads & Konfiguration” gelehrten Befehl.

  6. 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=docker starten, Namespace argocd anlegen und ArgoCD über das offizielle Install-Manifest anwenden
  • Mit kubectl -n argocd rollout status deploy/argocd-server abwarten, 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, mit syncPolicy.automated für Auto-Sync
  • Sync-Status Synced und Health-Status Healthy live per kubectl -n argocd get application bestätigen

Drift Detection & Self-Healing

  • Mit kubectl scale die Replica-Zahl im GitOps-verwalteten Namespace manuell verändern, ohne Git anzufassen
  • Beobachten, wie der Sync-Status kurzzeitig auf OutOfSync springt 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 undo von Self-Healing wieder überschrieben wird
  • Stattdessen git revert auf 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