Gitops Tutorial mit ArgoCD Teil 2

In diesem Blogbeitrag richten wir ArgoCD auf einem Kubernetes-Cluster ein. Wir installieren ArgoCD mit Helm, erstellen eine Anwendung zur Verwendung des App-of-Apps Ansatzes, richten ArgoCD so ein, dass es sich selbst aktualisieren kann, und installieren Prometheus über ArgoCD als Beispiel.

prometheus-argocd

1. Was ist Argo CD?

ArgoCD ist ein GitOps Tool zur automatischen Synchronisierung des Clusters mit dem gewünschten Status, der in einem Git-Repository definiert ist. Jede Arbeitslast wird deklarativ über ein Ressourcenmanifest in einer YAML-Datei definiert. ArgoCD prüft, ob der im Git-Repository definierte Status mit dem übereinstimmt, was auf dem Cluster ausgeführt wird, und synchronisiert ihn, wenn Änderungen festgestellt wurden.

Anstatt beispielsweise CLI-Befehle manuell auszuführen, um Kubernetes-Ressourcen mit kubectl apply oder zu aktualisieren helm upgrade, würden wir eine YAML-Datei in unserem Git-Repository aktualisieren, die ein ApplicationManifest enthält. ArgoCD überprüft dieses Manifest regelmäßig auf Änderungen und synchronisiert die darin definierten Ressourcen automatisch mit denen, die in unserem Cluster ausgeführt werden.

Eine Verbindung zum Cluster, entweder vom Laptop des Entwicklers oder von einem CI/CD-System, ist nicht mehr erforderlich, da Änderungen von einem Kubernetes-Operator, der im Cluster ausgeführt wird, aus dem Git-Repository abgerufen werden.

Anforderungen

Um diesem Tutorial folgen zu können, benötigen wir Folgendes.

kubectl

Docker/Rancher-Desktop

kind - um einen lokalen Cluster zu erstellen

Helm

ein öffentliches GitHub Repository

Lokalen Cluster aufsetzen

Als Erstes benötigen wir einen lokalen Kubernetes Cluster. Wir werden hier Kind nutzen.

Auf dem Mac installieren wir Kind mit brew

brew install kind

Und erstellen eine Cluster. Wir nennen ihn argo-workflows.

kind create cluster --name argo-gitops-teil1

Um mit dem CLuster zu interagieren setzen wir den Context.

kubectl cluster-info --context kind-argo-gitops-teil1

2. Erstellen eines Umbrella-Helm-Diagramms

Wir verwenden Helm, um das ArgoCD Chart argoproj/argo-helm zu installieren. Wir erstellen ein Umbrella Helm Chart, das das ArgoCD Chart als Abhängigkeit mit einbezieht.

Durch diesen Ansatz haben wir die Möglichkeit, zusätzliche Ressourcen einzubinden. Beispielsweise können wir Secrets installieren, die zur Authentifizierung bei privaten Git- oder Helm-Repositorys verwendet werden, indem wir sie im Template Verzeichnis des Charts ablegen.

Um das Umbrella Chart zu erstellen, erstellen wir ein Verzeichnis und erstellen im Folgenden zwei Dateien darin.

[charts/argo-cd/Chart.yaml](https://github.com/AlexanderWiechert/argocd-prometheus-example/blob/main/charts/argo-cd/Chart.yaml)

apiVersion: v2
name: argo-cd
version: 1.0.0
dependencies:
- name: argo-cd
  version: 4.2.2
  repository: https://argoproj.github.io/argo-helm

[charts/argo-cd/values.yaml](https://github.com/AlexanderWiechert/argocd-prometheus-example/blob/main/charts/argo-cd/values.yaml)

argo-cd:
  dex:
    enabled: false
  server:
    config:
      repositories: |
        - type: helm
          name: argo-cd
          url: https://argoproj.github.io/argo-helm

Einen Überblick über die verfügbaren Optionen finden Sie in der values.yaml.

ACHTUNG: Für unser Subchart müssen die Werte unterhalb des argo-cd: Keys liegen.

Für dieses Tutorial überschreiben wir die folgenden Werte:

  • Wir deaktivieren die dex Komponente, die für die Integration mit externen Authentifizierungsanbietern verwendet wird.
  • Wir fügen das ArgoCD Helm-Repository zur Repository Liste hinzu.

Bevor wir das Chart installieren, müssen wir eine Chart.lock Datei generieren.

$ helm repo add argo-cd https://argoproj.github.io/argo-helm
$ helm dep update charts/argo-cd/

Das erstellt folgen Dateien:

  • Chart.lock
  • charts/argo-cd-4.2.2.tgz

Die Datei im Order Charts benötigen wir nicht in unserem GitHub Repository, daher löschen wir sie und tragen den Ordner in die .gitignore Datei ein.

Jetzt können wir das Chart pushen.

$ git add charts/argo-cd
$ git commit -m 'add argo-cd chart'
$ git push

3. Installieren wir unser ArgoCD Helm Chart

Dazu installieren wir das Char manuell per Helm CLI

$ helm install argo-cd charts/argo-cd/

und warten, bis alles Pods gestartet wurden.

kubectl get pods --watch               rbenv:system
NAME                                                       READY   STATUS    RESTARTS   AGE
argo-cd-argocd-application-controller-0                    0/1     Running   0          8s
argo-cd-argocd-applicationset-controller-7c79d6866-nfv2j   1/1     Running   0          8s
argo-cd-argocd-notifications-controller-f87959dcb-4lrkb    1/1     Running   0          8s
argo-cd-argocd-redis-7bc4c98894-vbch9                      1/1     Running   0          8s
argo-cd-argocd-repo-server-77d5b68b5b-5bhdb                0/1     Running   0          8s
argo-cd-argocd-server-696cbbcd7f-24q4q                     0/1     Running   0          8s
argo-cd-argocd-repo-server-77d5b68b5b-5bhdb                1/1     Running   0          20s

4. Login in die Web UI

Da das ArgoCD Helm Chart per se keine Ingress definiert hat, müssen wir uns den Zugang per Port-Forwarding erstellen:

$ kubectl port-forward svc/argo-cd-argocd-server 8080:443

Im Browser öffnen wir dann einfach http://localhost:8080

Der default Benutzer is admin. Das Password ist automatisch generated und wir erhalten es folgednermassen:

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

So sieht ArgoCD nach dem ersten Login aus.

argo-new-install

Man könnte jetzt ArgoCD über diese Oberfläche einrichten und Apps hinzufügen, aber wir wollen das Codeseitig lösen, daher beschreiben wir diese in den Applikations Manifesten in Yaml und pushen sie in unser Git Repository.

Wenn wir nun beispielsweise eine Kube-prometheus-stackinstallieren wollten, würden wir ein passendes Applikationsmanifest anlegen. Dort würden wir dann das zu verwendende Helm Chart hinterlegen, sowie die Werte, welche wir anpassen wollen würden. Würden wir weiter so vorgehen, wie wir hier gestartet sind, müssten wir jede Applikation per kubectl manuell installieren. Das ist aber genau das, was wir nicht wollen.

In ArgoCd gibt es einen Weg diesen Vorgang komplett zu automatisieren, indem wir eine Applikation anlegen, die mittels des App-of-App Pattern, weitere Applikationen hinzufügen und verwalten kann. Dies ist die sogenannte Root-Applikation.

Diese Root-Applikation hat eigentlich nur eine Aufgabe: Sie generiert Manifeste für andere Applikationen. ArgoCD überwacht nun die Root-App und synchronisiert die Manifeste der anderen Applikationen.

Mit diesen Setup müssen wir nur noch eine Applikation von Hand installieren: Die Root App.

4. Erstellen der Root App

Für die Root-Anwendung erstellen ein Helm-Diagramm. Wir erstellen ein apps/-Verzeichnis und fügen eine Chart.yaml und eine leere values.yaml hinzu.

apps/Chart.yaml

apiVersion: v2
name: root
version: 1.0.0

Wir erstellen nun das Manifest für unsere Stammanwendung in apps/templates/root.yaml. Dies ermöglicht uns, alle Aktualisierungen an der Stammanwendung selbst über ArgoCD vorzunehmen.

[apps/templates/root.yaml](https://github.com/AlexanderWiechert/argocd-prometheus-example/blob/main/apps/templates/root.yaml)

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: root
  finalizers:
  - resources-finalizer.argocd.argoproj.io
spec:
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  project: default
  source:
    path: apps/
    repoURL: https://github.com/AlexanderWiechert/argocd-prometheus-example.git
    targetRevision: HEAD
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Die Applikation überwacht das Helm-Diagramm unter apps/ (unsere Root-Anwendung) und synchronisiert es, wenn Änderungen festgestellt wurden.

Hinweis: ArgoCD wird nicht helm install verwenden, um Diagramme zu installieren. Es wird das Diagramm mit helm template rendern und dann die Ausgabe mit kubectl anwenden. Das bedeutet, dass wir helm list nicht auf einer lokalen Maschine ausführen können, um alle installierten Versionen zu erhalten.

Um unsere Root-Anwendung bereitzustellen, müssen wir die Dateien in unser Git-Repository pushen und das Manifest anwenden:

$ git add apps
$ git commit -m 'add root app'
$ git push

$ helm template apps/ | kubectl apply -f -

In der Weboberfläche kann man nun unsere Root-Applikation sehen.

argo-root-app-created

5. ArgoCD sich selbst verwalten lassen

Um das Ganze nun auf die Spitze zu treiben, können wir nun ArgoCD als Applikation sich selbst verwalten lassen. Bisher hatten wir ArgoCD mit Helm installiert. Wenn wir nun Anpassungen an ArgoCd selbst vornehmen wollten, müssten wir Updates manuell durchführen.

Um dies zu vermeiden, können wir eine Anwendungsressource für ArgoCD erstellen und sie sich selbst verwalten lassen. Mit diesem Ansatz können alle Aktualisierungen an unserer Argo-CD-Bereitstellung durch die Änderung von Dateien in unserem Git-Repository vorgenommen werden, anstatt manuelle Befehle auszuführen.

Dazu legen wir ein Applikationsmanifest an.

[apps/templates/argo-cd.yaml](https://github.com/AlexanderWiechert/argocd-prometheus-example/blob/main/apps/templates/argo-cd.yaml)

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: argo-cd
  namespace: default
  finalizers:
  - resources-finalizer.argocd.argoproj.io
spec:
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  project: default
  source:
    path: charts/argo-cd
    repoURL: https://github.com/AlexanderWiechert/argocd-prometheus-example.git
    targetRevision: HEAD
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

und pushen es ins Git Repository:

$ git add apps/templates/argo-cd.yaml
$ git commit -m 'add argo-cd application'
$ git push

In der Weboberfläche sollten wir nun ArgoCD als Applikation sehen. Falls die Anwendung nicht sofort angezeigt wird, klicken Sie auf die Schaltfläche “Aktualisieren” in der Stammanwendung. Standardmäßig wird alle 3 Minuten nach Änderungen im Git-Repository gesucht.

argo-app-created.

Sobald die ArgoCD Anwendung synchronisiert ist, kann sie sich selbst verwalten und wir können die zuvor manuell installierte Installation löschen. Der folgende Befehl löscht ArgoCD nicht aus dem Cluster, sondern lässt Helm nur wissen, dass es ArgoCD nicht mehr verwaltet:

$ kubectl delete secret -l owner=helm,name=argo-cd

6. Kube-prometheus-stack installieren

m zu demonstrieren, wie ein Helm-Diagramm mit ArgoCD eingesetzt wird, fügen wir den Kube-prometheus-stack zu unserem Cluster hinzu. Zuerst erstellen wir ein Anwendungsmanifest in apps/templates/prometheus.yaml, das das Prometheus Community Chart verwendet.

[apps/templates/kube-prometheus-stack.yaml](https://github.com/AlexanderWiechert/argocd-prometheus-example/blob/main/apps/templates/kube-prometheus-stack.yaml)

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: kube-prometheus-stack
  namespace: default
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
  destination:
    server: https://kubernetes.default.svc
    namespace: default
  project: default
  source:
    chart: kube-prometheus-stack
    repoURL: https://prometheus-community.github.io/helm-charts
    targetRevision: 44.3.0
    helm:
      skipCrds: true
      values: |-
  syncPolicy:
    syncOptions:
      - Replace=true
    automated:
      prune: true
      selfHeal: true

Im Vergleich zu unserem zuvor erstellten ArgoCD Manifest gibt es folgende Unterschiede:

  • Wir verwenden als Source chart anstelle von path, um ein Helmchart aus einem anderen Helm-Repository zu installieren
  • Die targetRevision ist die spezifische Version des Charts, die wir installieren wollen.
  • Die repoURL wird auf das Helmchart-Repository der Prometheus-Community gesetzt.
  • Wir überschreiben die Standardwerte des Diagramms, um das Pushgateway zu deaktivieren.

Hinweis! Um den Fehler “The CustomResourceDefinition “prometheuses.monitoring.coreos.com” is invalid: metadata.annotations: Too long: must have at most 262144 bytes” zu umgehen waren einige Anpassungen notwendig.

helm.skipCrds = true +

helm.values = -

syncPolicy.syncOptions = - Replace=true

Um die Anwendung bereitzustellen, müssen wir nur noch das Manifest in unser Git-Repository pushen:

$ git add apps/templates/kube-prometheus-stack.yaml
$ git commit -m 'add kube-prometheus-stack'
$ git push

Nun sollte in der Weboberfläche Prometheus auftauchen.

prometheus

grafana

7. Kube-prometheus-stack wieder deinstallieren

Um die Prometheus Applikation wieder zu deinstallieren, müssen wir lediglich die zuvor hinzugefügte kube-prometheus-stack.yaml Datei aus dem Git Repository löschen.

$ git rm apps/templates/kube-prometheus-stack.yaml
$ git commit -m 'remove kube-prometheus-stack'
$ git push

Die Applikation wird beim nächsten Refresh vom Cluster entfernt werden.

8. Fazit

In diesem Tutorial haben wir ArgoCD mit Helm installiert und es so eingerichtet, dass es sich selbst verwalten kann. Aktualisierungen von ArgoCD können durch Modifikation des Manifests im Git-Repository durchgeführt werden und erfordern keinerlei manuelle Schritte.

Wir haben eine Root-Anwendung erstellt, die das App-of-Apps Pattern verwendet, um unsere Anwendungen auf deklarative Weise zu verwalten.

Anwendungen können mit Git hinzugefügt, aktualisiert oder entfernt werden. Als Beispiel haben wir Prometheus in unserem Cluster installiert.

Alle in diesem Blog-Beitrag erwähnten Dateien findet ihr hier bei GitHub.