Multi-Cluster-Kubernetes-Deployments mit ArgoCD ApplicationSets verwalten

Der Betrieb von Anwendungen über mehrere Kubernetes-Cluster hinweg kann in produktiven Umgebungen für Entwicklungs- und Betriebsteams schnell anspruchsvoll werden. Die Auslieferung kann sich verlangsamen, die Komplexität steigt und zusätzliche operative Risiken entstehen. Klassische Verfahren wie manuelle Deployments, eigene Skripte oder einfache CI/CD-Pipelines reichen häufig nicht mehr aus, sobald mehrere Cluster zuverlässig verwaltet werden müssen. Dadurch können Konfigurationsabweichungen, uneinheitliche Deployments und ein höherer Wartungsaufwand entstehen.

Dieser Leitfaden zeigt, wie ArgoCD ApplicationSets das Management von Kubernetes-Deployments über mehrere Cluster hinweg von einem komplexen und fehleranfälligen Prozess in einen klar strukturierten, automatisierten Workflow verwandeln können. Dabei wird gezeigt, wie sich Deployment-Zeiten um 83 % reduzieren lassen, während die Konfigurationen in allen Clustern konsistent bleiben.

Wichtige Erkenntnisse

• Deployment-Zeit um 83 % reduzieren: ArgoCD ApplicationSets können Multi-Cluster-Deployment-Zyklen von mehr als 30 Minuten auf etwa 5 Minuten verkürzen.
• Manuelle Fehler vermeiden: Ein deklarativer GitOps-Ansatz hilft dabei, menschliche Fehler bei Deployments über mehrere Cluster hinweg zu reduzieren.
• Betrieb effizient skalieren: Mehrere Cluster lassen sich verwalten, ohne dass die operative Komplexität im gleichen Maß zunimmt.
• Konsistente Umgebungen sicherstellen: Zentrales Management unterstützt einheitliche Konfigurationsstandards über alle Cluster hinweg.
• Developer Self-Service ermöglichen: Plattformteams können Entwicklungsteams standardisierte Deployment-Möglichkeiten bereitstellen.
• Disaster Recovery vereinfachen: Eine zentrale Übersicht und automatisierte Rollback-Optionen erleichtern die Wiederherstellung über alle Cluster hinweg.

Warum ArgoCD ApplicationSets das Multi-Cluster-Management verbessern

Klassische Ansätze für Multi-Cluster-Deployments verursachen häufig erheblichen operativen Aufwand und schaffen mehrere potenzielle Fehlerquellen. Manuelle Abläufe erfordern, dass Teams für jeden Cluster eigene Deployment-Skripte pflegen. Das kann zu Konfigurationsabweichungen und uneinheitlichen Umgebungen führen. Auch selbst entwickelte Automatisierungslösungen lassen sich oft nur schwer standardisieren, warten und skalieren, wenn die Infrastruktur wächst.

ApplicationSets lösen diese Herausforderungen durch ein deklaratives und automatisiertes Management, das über eine beliebige Anzahl von Clustern hinweg skaliert. Statt jeden Cluster separat zu verwalten, verwenden ApplicationSets eine zentrale Konfiguration, um Deployments gleichzeitig für alle Cluster zu erzeugen und zu steuern.

Zentrale Vorteile von ApplicationSets

• Zentrales Konfigurationsmanagement: Anstatt für jeden Cluster eigene Deployment-Definitionen zu pflegen, nutzen ApplicationSets eine Vorlage, die sich durch Parameterersetzung automatisch an unterschiedliche Cluster-Anforderungen anpasst. So lassen sich Konfigurationsabweichungen vermeiden und Umgebungen bleiben konsistent.
• Automatisierte Skalierung: Um einen neuen Cluster in den Deployment-Workflow aufzunehmen, genügt eine Anpassung der ApplicationSet-Konfiguration. Das System erstellt anschließend automatisch die erforderlichen ArgoCD Applications für den neuen Cluster, ohne dass manuelle Schritte nötig sind.
• Geringerer operativer Aufwand: Plattformteams können Hunderte von Clustern mit einem Aufwand verwalten, der zuvor nur für wenige Cluster erforderlich war. Dadurch können Organisationen ihre Infrastruktur ausbauen, ohne das Betriebsteam im gleichen Verhältnis zu vergrößern.
• Höhere Zuverlässigkeit: ApplicationSets bieten Funktionen für Health Monitoring und automatisierte Korrekturen. Wenn ein Deployment in einem Cluster fehlschlägt, können die anderen Cluster weiterhin normal betrieben werden. Gleichzeitig liefert das System detaillierte Statusinformationen für die Fehleranalyse.
• Developer Self-Service: Entwicklungsteams können Anwendungen mithilfe standardisierter und freigegebener Konfigurationen über mehrere Cluster hinweg bereitstellen, ohne für jedes Deployment Unterstützung durch das Plattformteam zu benötigen.
• Vereinfachtes Disaster Recovery: Durch das zentrale Management lassen sich Rollbacks über alle Cluster hinweg oder Wiederherstellungen nach Fehlern mit einem einzelnen Befehl ausführen, anstatt einen komplexen und fehleranfälligen manuellen Prozess durchlaufen zu müssen.

Schritt-für-Schritt-Anleitung zur Implementierung

Diese Umsetzung nutzt ein zentrales Management-Modell. Dabei läuft ArgoCD auf einem zentralen Cluster und verwaltet Deployments über mehrere entfernte Kubernetes-Cluster hinweg:

Voraussetzungen

Bevor ArgoCD ApplicationSets eingerichtet werden, sollten die folgenden Voraussetzungen erfüllt sein:

• Mehrere Kubernetes-Cluster: Es werden mindestens zwei Cluster benötigt. In diesem Beispiel werden region-a, region-b und region-c verwendet.
• kubectl installiert und konfiguriert: Das CLI-Tool muss installiert sein und Zugriff auf alle Zielcluster haben.
• Cluster-Konnektivität: Die kubectl-Konfiguration sollte Kontext-Einträge für alle Cluster enthalten.
• Admin-Zugriff: Es werden ausreichende Berechtigungen benötigt, um ArgoCD zu installieren und Cluster-Ressourcen zu verwalten.

Schritt 1: ArgoCD installieren und konfigurieren

Zunächst wird ArgoCD auf dem zentralen Management-Cluster bereitgestellt:

# Namespace erstellen
kubectl create namespace argocd

# ArgoCD installieren
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

# Auf das Deployment warten
kubectl wait --for=condition=available --timeout=300s deployment/argocd-server -n argocd

Die ArgoCD-Benutzeroberfläche kann wie folgt aufgerufen werden:

# Initiales Admin-Passwort abrufen
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

# Port-Forwarding für den Zugriff auf die Benutzeroberfläche
kubectl port-forward svc/argocd-server -n argocd 8080:443

# Alternativ über LoadBalancer/Ingress bereitstellen
kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

ArgoCD CLI installieren und konfigurieren

Die ArgoCD CLI wird anschließend installiert und eingerichtet:

# macOS
brew install argocd

# Anmeldung über die CLI
argocd login localhost:8080 --username admin --password <initial-password>

# Admin-Passwort ändern
argocd account update-password

Schritt 2: Entfernte Cluster verbinden

Die Zielcluster werden zu ArgoCD hinzugefügt:

# Verfügbare Kontexte auflisten
kubectl config get-contexts

# Jeden entfernten Cluster hinzufügen
argocd cluster add <region-a-cluster> --name region-a
argocd cluster add <region-b-cluster> --name region-b
argocd cluster add <region-c-cluster> --name region-c

# Cluster prüfen
argocd cluster list

Schritt 3: ApplicationSets für automatisierte Deployments erstellen

ApplicationSets verwenden Generatoren, um automatisch mehrere ArgoCD Applications über die vorhandenen Cluster hinweg zu erstellen.

Generatoren in ApplicationSets

ApplicationSet-Generatoren sind der zentrale Mechanismus, der bestimmt, welche Anwendungen erstellt werden und welche Parameter an die jeweilige Anwendung übergeben werden. Generatoren lassen sich als Vorlagen verstehen, die eine Liste von Parametersätzen erzeugen. Jeder Parametersatz führt anschließend zu einer ArgoCD Application.

Generator → Parametersätze → Applications

Ein Generator verarbeitet eine Konfiguration und erzeugt daraus Parametersätze. Jeder Parametersatz wird verwendet, um die ApplicationSet-Vorlage zu rendern, wodurch einzelne ArgoCD Applications entstehen.

• Die Generator-Konfiguration definiert die Quelle der Parameter, zum Beispiel Cluster, Git-Verzeichnisse, Listen oder andere Quellen.
• Der Generator erstellt eine Liste von Parametersätzen, wobei jeder Satz Schlüssel-Wert-Paare enthält.
• Jeder Parametersatz rendert die ApplicationSet-Vorlage mithilfe der Go-Template-Syntax, beispielsweise .
• Jede gerenderte Vorlage wird zu einer eigenständigen ArgoCD Application.

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
 name: sample-app-set
 namespace: argocd
spec:
 generators:
 - list:
     elements:
     - cluster: region-a
       name: region-a
       server: < region-a cluster >
       region: region-a
       replicas: "1"
       resources: "small"
     - cluster: region-b
       name: region-b
       server: < region-b cluster >
       region: region-b
       replicas: "2"
       resources: "medium"
     - cluster: region-c
       name: region-c
       server: < region-c cluster >
       region: region-c
       replicas: "3"
       resources: "large"
 template:
   metadata:
     name: '-sample-app'
     labels:
       region: ''
   spec:
     project: default
     source:
       repoURL: https://github.com/argoproj/argocd-example-apps
       targetRevision: HEAD
       path: guestbook
     destination:
       server: ''
       namespace: sample-app
     syncPolicy:
       automated:
         prune: true
         selfHeal: true
       syncOptions:
       - CreateNamespace=true

Zentrale Begriffe

• generators: Legt fest, welche Cluster angesprochen werden sollen.
• template: Stellt die Vorlage bereit, aus der einzelne Anwendungen erzeugt werden.
• parameters: Werte, die in der Vorlage ersetzt werden.

# Detaillierte Informationen abrufen
kubectl describe applicationset sample-app-set -n argocd

Die Statusausgabe zeigt drei wichtige Bedingungen:

Status eines fehlerfrei arbeitenden ApplicationSets

• ErrorOccurred: False – Es wurden keine Verarbeitungsfehler erkannt.
• ParametersGenerated: True – Die Parameter für alle Zielcluster wurden erfolgreich erstellt.
• ResourcesUpToDate: True – Das ApplicationSet ist aktuell und die Anwendungen wurden erzeugt.

Wenn dieser Status angezeigt wird, funktioniert das ApplicationSet korrekt.

# Erstellung der Anwendungen beobachten
kubectl get applications -n argocd 

Synchronisierungsstatus des ArgoCD ApplicationSets

# Synchronisierungsstatus mit der ArgoCD CLI prüfen
argocd app list

# Detaillierte App-Informationen abrufen
argocd app get region-a-sample-app

Häufige Probleme in ApplicationSets beheben

Bei der Arbeit mit ArgoCD ApplicationSets können die folgenden typischen Situationen auftreten:

Synchronisierung überwachen

# Synchronisierungsstatus prüfen
argocd app list | grep sample-app

Wenn Anwendungen als OutOfSync angezeigt werden, können sie manuell synchronisiert werden:

argocd app sync dev-sample-app
argocd app sync staging-sample-app
argocd app sync production-sample-app

Deployments in Zielclustern prüfen

Für jeden Cluster sollten die bereitgestellten Ressourcen überprüft werden. Dafür muss jeweils der passende kubectl-Kontext gewechselt werden.

# Dev-Cluster
kubectl config use-context dev-cluster-context
kubectl get all -n sample-app

# Staging-Cluster 
kubectl config use-context staging-cluster-context
kubectl get all -n sample-app

# Produktionscluster
kubectl config use-context production-cluster-context
kubectl get all -n sample-app

ApplicationSet erstellt keine Applications

# Zuerst den ApplicationSet-Status prüfen
kubectl describe applicationset sample-app-set -n argocd

# Auf Statusbedingungen achten:
# - ErrorOccurred: Sollte False sein
# - ParametersGenerated: Sollte True sein 
# - ResourcesUpToDate: Sollte True sein

Die Logs des ApplicationSet-Controllers prüfen:

kubectl logs -n argocd deployment/argocd-applicationset-controller

Die Cluster-Verbindung überprüfen:

argocd cluster list

Applications bleiben im Status OutOfSync hängen

# Details zur Anwendung prüfen
argocd app get <app-name>

# Synchronisierung erzwingen
argocd app sync <app-name> --force

Berechtigungsprobleme

# RBAC-Berechtigungen prüfen
kubectl describe clusterrole argocd-application-controller

# Service Account überprüfen
kubectl get serviceaccount argocd-application-controller -n argocd

Häufige Bedeutungen der Statuswerte

• ErrorOccurred: True = Es gibt ein Problem mit der ApplicationSet-Konfiguration.
• ParametersGenerated: False = Parameter konnten nicht erzeugt werden. Die Cluster-Konnektivität sollte geprüft werden.
• ResourcesUpToDate: False = Das ApplicationSet muss erneut abgeglichen werden. Dies ist meist nur vorübergehend.

Häufig gestellte Fragen

Was ist der Unterschied zwischen ArgoCD Applications und ApplicationSets?

ArgoCD Applications verwalten einzelne Deployments für bestimmte Cluster. ApplicationSets hingegen sind Vorlagen, die automatisch mehrere Applications über verschiedene Cluster hinweg erzeugen. ApplicationSets nutzen Generatoren, um Parametersätze zu erstellen und daraus Application-Vorlagen für jeden Zielcluster zu rendern. Dadurch wird die Verwaltung vieler Deployments auf einmal möglich.

Wie viele Cluster können ArgoCD ApplicationSets verwalten?

ArgoCD ApplicationSet definiert keine feste Maximalanzahl an Clustern, die verwaltet werden können. In der Praxis hängt die Skalierbarkeit von mehreren Faktoren ab, darunter:

Konfiguration der Argo CD Instanz: Argo CD Komponenten wie der Application Controller müssen passend abgestimmt sein, damit viele Anwendungen und Cluster effizient verarbeitet werden können.

Verfügbare Ressourcen: Die Infrastruktur, auf der Argo CD betrieben wird, muss ausreichend CPU- und Arbeitsspeicherressourcen bereitstellen, um viele Cluster und Anwendungen verwalten zu können.

Anzahl der Anwendungen pro Cluster: Je mehr Anwendungen pro Cluster verwaltet werden, desto stärker steigt die Last auf Argo CD, was die Performance beeinflussen kann.

Netzwerklatenz und Zuverlässigkeit: Die Kommunikation zwischen der Argo CD Instanz und den verwalteten Clustern kann bei sehr vielen Clustern oder bei Umgebungen mit hoher Latenz zum Engpass werden.

Für sehr große Bereitstellungen mit Hunderten oder Tausenden von Clustern wird häufig empfohlen, mehrere Argo CD Instanzen einzusetzen. Jede Instanz kann einen Teil der Cluster verwalten, wodurch die Last verteilt und Performance sowie Ausfallsicherheit verbessert werden. Gleichzeitig wird der mögliche Schaden begrenzt, falls eine einzelne Argo CD Instanz ausfällt.

Können ApplicationSets mit unterschiedlichen Kubernetes-Distributionen verwendet werden?

Ja. ApplicationSets funktionieren mit jeder CNCF-zertifizierten Kubernetes-Distribution, darunter EKS, GKE, AKS, OpenShift und selbst verwaltete Cluster. Die wichtigste Voraussetzung ist, dass ArgoCD sich gegenüber dem API-Server jedes Clusters authentifizieren und eine Verbindung herstellen kann.

Was passiert, wenn ein Cluster während des Deployments ausfällt?

ApplicationSets führen Deployments unabhängig für jeden Cluster aus. Wenn ein Cluster ausfällt, können die anderen Cluster weiterhin normal deployen. ArgoCD stellt detaillierte Statusinformationen pro Cluster bereit, sodass einzelne Cluster-Probleme untersucht werden können, ohne die übrigen Cluster zu beeinträchtigen.

Wie gehen ApplicationSets mit Secrets und unterschiedlichen Konfigurationen zwischen Clustern um?

ApplicationSets unterstützen Parameterersetzung in Vorlagen. Dadurch können clusterspezifische Werte wie Ressourcenlimits, Replikatanzahlen oder umgebungsspezifische Einstellungen an die generierten Applications übergeben werden. Für Secrets können die Secret-Management-Funktionen von ArgoCD oder externe Secret-Operatoren verwendet werden, um sensible Daten pro Cluster zu verwalten.

Fazit

ArgoCD ApplicationSets verbessern das Management von Kubernetes-Deployments über mehrere Cluster hinweg, indem komplexe manuelle Prozesse in strukturierte und automatisierte Workflows überführt werden. Die Ergebnisse sind deutlich: Deployment-Zeiten können von mehr als 30 Minuten auf etwa 5 Minuten sinken, operativer Aufwand kann von 3 bis 4 benötigten Engineers in Richtung Self-Service verschoben werden, und die Konsistenz der Umgebungen kann über alle Cluster hinweg erhalten bleiben.

Mit dem in diesem Leitfaden gezeigten deklarativen GitOps-Ansatz können Plattform-Engineering-Teams Self-Service für Entwicklungsteams ermöglichen und gleichzeitig Kontrolle sowie Observability behalten. Die zentrale Management-Oberfläche beschleunigt die Reaktion auf Vorfälle und unterstützt skalierbare Betriebsmodelle, die mit der Infrastruktur wachsen können, ohne die Komplexität im gleichen Maß zu erhöhen.

ApplicationSets verwandeln Multi-Cluster-Management von einer manuellen und fehleranfälligen Aufgabe in ein zuverlässiges automatisiertes System, das sowohl die Developer Experience als auch die operative Effizienz verbessert.