GitOps in Kubernetes: Ein Leitfaden für deklaratives Continuous Deployment mit Argo CD

In modernen Softwareentwicklungsprozessen ist die schnelle und zuverlässige Bereitstellung von Anwendungen von entscheidender Bedeutung. Während traditionelle CI/CD-Ansätze oft betriebliche Komplexitäten mit sich bringen, zielt die GitOps-Philosophie darauf ab, diese Komplexität zu reduzieren und Bereitstellungsprozesse zu vereinfachen. In diesem Leitfaden lernen Sie Schritt für Schritt, wie Sie GitOps in einer Kubernetes-Umgebung mit Argo CD, einem beliebten Tool, implementieren können.

Die GitOps-Philosophie und ihre Vorteile

GitOps ist ein „deklarativer“ Ansatz, der Ihre operative Infrastruktur und den Anwendungszustand über ein Git-Repository definiert. Git dient sowohl als Single Source of Truth als auch als Audit-Trail. Jede Infrastruktur- oder Anwendungsänderung beginnt mit einem Commit in Git, und Automatisierungstools erkennen diesen Commit, um den gewünschten Zustand anzuwenden. Dieser Ansatz bietet erhebliche Vorteile, wie z. B. einfaches Zurückrollen, Auditing und die Standardisierung des Systemzustands über die Git-Historie.

Was ist Argo CD und warum sollte es bevorzugt werden?

Argo CD ist ein deklaratives, GitOps-basiertes Continuous-Delivery-Tool für Kubernetes. Es läuft als Controller in Ihrem Kubernetes-Cluster und überwacht kontinuierlich den im Git-Repository definierten Zielanwendungszustand (Kubernetes-Manifeste). Wenn es eine Abweichung (Drift) zwischen dem aktuellen Zustand des Clusters und dem Zielzustand in Git feststellt, synchronisiert es diesen Zustand automatisch. Die Hauptvorteile von Argo CD sind:

• Deklarative und automatische Synchronisation: Anwendungszustände werden in Git definiert, und Argo CD synchronisiert diesen Zustand automatisch mit dem Cluster.
• Umfangreiche Weboberfläche: Bietet eine umfassende Weboberfläche zur Überwachung des Live-Anwendungsstatus, der Synchronisierungsqualität und des Verlaufs.
• Drift-Erkennung und -Korrektur: Erkennt manuelle Änderungen im Cluster und kann diese auf den in Git definierten Zustand zurücksetzen (oder benachrichtigen).
• Einfaches Rollback: Mit dem von Git bereitgestellten Versionskontrollvorteil können Sie im Falle fehlerhafter Bereitstellungen einfach zu einem früheren Anwendungszustand zurückkehren.
• Multi-Cluster-Unterstützung: Verwalten Sie mehrere Kubernetes-Cluster von einer einzigen Argo CD-Instanz aus.

Schritt 1: Installation von Argo CD auf Ihrem Kubernetes-Cluster

Die Installation von Argo CD auf Ihrem Kubernetes-Cluster ist recht einfach. Zuerst erstellen wir einen dedizierten Namespace für Argo CD und wenden dann die Installationsmanifeste an:

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

Stellen Sie nach Abschluss der Installation sicher, dass die Argo CD-Pods ausgeführt werden:

kubectl get pods -n argocd

Um auf die Argo CD-Weboberfläche zuzugreifen, können Sie den Dienst argocd-server extern mit einem NodePort oder Port Forwarding zugänglich machen. Hier ist ein einfaches Port-Forwarding-Beispiel:

kubectl port-forward svc/argocd-server -n argocd 8080:443

Jetzt können Sie unter https://localhost:8080 auf die Weboberfläche zugreifen. Der Benutzername für die erste Anmeldung ist admin. Verwenden Sie den folgenden Befehl, um das Passwort abzurufen:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

Schritt 2: Bereitstellen Ihrer ersten Anwendung mit GitOps

Lassen Sie uns nun eine einfache Nginx-Anwendung mit dem GitOps-Ansatz bereitstellen. Erstellen Sie zunächst ein Git-Repository, das die Kubernetes-Manifeste für die Anwendung enthält. Nehmen wir zum Beispiel an, es gibt ein Repository unter git@github.com:your-username/argocd-demo.git, und fügen Sie eine Datei namens nginx-app.yaml hinzu:

# nginx-app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.19.10
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

Committen und pushen Sie diese Datei in Ihr Git-Repository. Als Nächstes erstellen wir eine Application-Ressource, um diese Anwendung Argo CD vorzustellen. Diese Ressource teilt Argo CD mit, wo sich die Anwendung befindet (das Git-Repository) und wo sie bereitgestellt werden soll (der Kubernetes-Cluster). Sie können dies entweder mit der Argo CD CLI oder durch direkte Anwendung auf Kubernetes tun. Verwenden wir die CLI:

argocd app create nginx-gitops \
  --repo https://github.com/your-username/argocd-demo.git \
  --path . \
  --dest-server https://kubernetes.default.svc \
  --dest-namespace default \
  --sync-policy automated --self-heal --prune

Dieser Befehl weist Argo CD an, eine neue Anwendung namens nginx-gitops zu erstellen, die Manifeste im angegebenen Git-Repository zu verwenden und sie im default-Namespace bereitzustellen. --sync-policy automated ermöglicht die automatische Synchronisierung, --self-heal stellt sicher, dass Änderungen im Cluster auf den in Git definierten Zustand zurückgesetzt werden, und --prune stellt sicher, dass aus Git entfernte Ressourcen auch aus dem Cluster gelöscht werden.

Schritt 3: Überwachung und Verwaltung der Bereitstellung

Nachdem die Anwendung erstellt wurde, können Sie ihren Status über die Argo CD-Weboberfläche oder mit der CLI überprüfen:

argocd app get nginx-gitops
argocd app sync nginx-gitops

Nach einer Weile zieht Argo CD die Manifeste aus Ihrem Repository und wendet sie auf Ihren Kubernetes-Cluster an. Sie werden sehen, dass die Anwendung fehlerfrei läuft und mit Git synchronisiert ist. Wenn Sie eine Änderung in der nginx-app.yaml-Datei Ihres Git-Repositorys vornehmen und committen (z. B. die Replikatanzahl auf 3 ändern), erkennt Argo CD diese Änderung automatisch und wendet sie auf Ihren Cluster an.

Best Practices mit GitOps und Argo CD

• Single Source of Truth: Bewahren Sie alle Ihre Anwendungs- und Infrastrukturkonfigurationen in einem einzigen Git-Repository auf, um die Überprüfung zu vereinfachen.
• Strategien für mehrere Umgebungen: Verwenden Sie separate Verzeichnisse oder Branches für verschiedene Umgebungen wie Entwicklung, Test und Produktion. Passen Sie dieselben Basismanifeste für verschiedene Umgebungen mit Tools wie Kustomize oder Helm an.
• Zero-Trust-Bereitstellungen: Der Betrieb von Argo CD innerhalb des Kubernetes-Clusters, der weniger externen Zugriff erfordert, reduziert Sicherheitsrisiken.
• Rollback-Fähigkeit: Nutzen Sie die Versionskontrollvorteile von Git, um im Falle fehlerhafter Bereitstellungen schnelle und zuverlässige Rollbacks durchzuführen.
• Alarme und Benachrichtigungen: Integrieren Sie Argo CD in Überwachungstools wie Prometheus, Grafana und Benachrichtigungssysteme wie Slack, E-Mail, um sofort über Anomalien oder Synchronisierungsprobleme informiert zu werden.

Fazit

GitOps ist ein Eckpfeiler moderner DevOps-Praktiken und bietet eine leistungsstarke Methodik zur Vereinfachung, Automatisierung und Verbesserung der Sicherheit der Anwendungsbereitstellung in einer Kubernetes-Umgebung. Dank Tools wie Argo CD war die Verwaltung Ihrer Infrastruktur und Anwendungen als Code noch nie so einfach. Indem Sie die Schritte in diesem Leitfaden befolgen, können Sie Ihren eigenen GitOps-Workflow einrichten und Ihre Softwarebereitstellungsprozesse revolutionieren.