GitOps implementeren met Argo CD

Handleidingen
Git Kubernetes

Inleiding

Argo CD is een populaire open source-implementatie voor het uitvoeren van GitOps continue levering bovenop Kubernetes. Uw toepassingen, definities, configuraties en omgevingen moeten declaratief en versiebeheerd zijn. Ook de implementatie en levenscyclusbeheer van de toepassing moeten geautomatiseerd, controleerbaar en gemakkelijk te begrijpen zijn. Dit alles kan worden gedaan met behulp van Argo.

Argo CD houdt zich aan dezelfde GitOps-patronen en principes, en onderhoudt dus de status van uw cluster met een declaratieve aanpak. Synchronisatie gebeurt via een Git-opslagplaats, waar uw Kubernetes-manifesten worden opgeslagen. Kubernetes-manifesten kunnen op verschillende manieren worden gespecificeerd:

  • Kustomize-toepassingen.
  • Helm-charts.
  • Ksonnet-toepassingen.
  • Jsonnet-bestanden.
  • Platte map met YAML/json-manifesten.
  • Elk aangepast configuratiebeheerstool geconfigureerd als een configuratiebeheerplug-in.

Zoals bij elke toepassing die wordt uitgevoerd in een Kubernetes-cluster, wordt Argo CD geconfigureerd via aangepaste resource-definities (CRD’s) opgeslagen in YAML-manifesten. De belangrijkste hiervan is de CRD Application. In een Argo CD-toepassing definieer je welk Git-repository moet worden gebruikt om welk Kubernetes-cluster te synchroniseren. Het kan hetzelfde Kubernetes-cluster zijn waar Argo CD is geïmplementeerd, of een extern cluster.

Argo CD is geïmplementeerd als een Kubernetes-controller die continu draaiende toepassingen bewaakt en de huidige (of live) status vergelijkt met de gewenste doelstatus (zoals gespecificeerd in het Git-repo). Een ingezette toepassing waarvan de live status afwijkt van de doelstatus wordt beschouwd als OutOfSync. Argo CD rapporteert en visualiseert de verschillen, terwijl het faciliteiten biedt om automatisch of handmatig de live status terug te synchroniseren naar de gewenste doelstatus.

Argo CD biedt veel functies, waarvan de meest opvallende zijn:

  • Ondersteuning voor meerdere configuratiebeheer/sjabloneringstools, zoals: Kustomize, Helm, Ksonnet, Jsonnet, plain-YAML.
  • Mogelijkheid om meerdere clusters te beheren en te implementeren.
  • SSO-integratie (OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, LinkedIn).
  • Multi-tenant en RBAC-beleid voor autorisatie.
  • Gezondheidsstatusanalyse van toepassingsresources.
  • Terugdraaien/Overal rollen naar elke toepassingsconfiguratie die is vastgelegd in het Git-opslagplaats.
  • Geautomatiseerde detectie en visualisatie van configuratieafwijkingen.
  • Web-gebruikersinterface die een realtime weergave van de activiteit van de toepassing biedt.
  • CLI voor automatisering en integratie met CI.
  • Webhook-integratie (GitHub, BitBucket, GitLab).
  • PreSync, Sync, PostSync-hooks om complexe implementaties van toepassingen te ondersteunen (bijv. blauw/groen en kanarie-upgrades).
  • Prometheus-metrieken.

In deze zelfstudie leert u:

  • Gebruik Helm om Argo CD in uw DOKS-cluster te voorzien.
  • Houd de staat van toepassingen in uw Kubernetes-cluster gesynchroniseerd met een Git-opslagplaats (gebruik principes van GitOps).
  • Bepaal en beheer toepassingen via Argo CD.

Na het voltooien van alle stappen in deze zelfstudie zou u een DOKS-cluster met Argo CD moeten hebben geïmplementeerd, dat zal:

  • Handel de verzoening van het cluster af, via Toepassings CRD’s.
  • Beheer Helm-releases, met behulp van Helm-bronnen gedefinieerd binnen toepassings-CRD’s.

DOKS en Argo CD voor Helm Releases Overzicht

Onderstaande diagram toont hoe Argo CD Helm-toepassingen beheert die worden gehost met behulp van een Git-opslagplaats:

Inhoudsopgave

Vereisten

Om deze tutorial te voltooien, heb je nodig:

  1. A working DOKS cluster that you have access to. Please follow the Starter Kit DOKS Setup Guide to find out more.to find out more.
  2. A GitHub repository and branch, to store Argo CD and your applications manifests. Must be created beforehand.
  3. A Git client, for cloning the Starter Kit repository.
  4. Kubectl CLI, voor interactie met Kubernetes. Volg deze instructies om verbinding te maken met uw cluster met kubectl en doctl.
  5. Argo CLI, om te communiceren met Argo CD via de command line interface.
  6. Kubeseal, voor het versleutelen van geheimen en interactie met Sealed Secrets Controller.
  7. Helm, voor het beheren van Argo CD releases en upgrades (optioneel, maar over het algemeen aanbevolen voor productiesystemen).

Begrip van Argo CD-concepten voor het implementeren van toepassingen

Argo CD gebruikt het kernconcept van de Applicatie om de implementatie en levenscyclus van applicaties te beheren. Binnen een Argo CD applicatie manifest definieer je het Git repository dat jouw applicatiedefinities host, evenals het overeenkomstige Kubernetes cluster om applicaties uit te rollen. Met andere woorden, een Argo CD applicatie bepaalt de relatie tussen een bronrepository en een Kubernetes cluster. Het is een zeer beknopt en schaalbaar ontwerp, waarbij je meerdere bronnen (Git repositories) en bijbehorende Kubernetes clusters kunt associëren.

A major benefit of using applications is that you don’t need to deploy Argo to each cluster individually. You can use a dedicated cluster for Argo, and deploy applications to all clusters at once from a single place. This way, you avoid Argo CD downtime or loss, in case other environments have issues or get decommissioned.

Bovendien kun je vergelijkbare applicaties groeperen in een Project. Projecten maken logische groepering van applicaties en bijbehorende rollen/machtigingen mogelijk bij het werken met meerdere teams. Als niet gespecificeerd, behoort elke nieuwe applicatie tot het default project. Het default project wordt automatisch aangemaakt en heeft geen beperkingen. Het standaard project kan worden aangepast, maar niet worden verwijderd.

Starter Kit gebruikt het standaard project om snel aan de slag te gaan met Argo CD. Vervolgens leer je hoe je een Applicatie maakt voor elk onderdeel van de Starter Kit, en hoe je Helm-charts gebruikt als de bron voor de applicatie. Argo CD is niet beperkt tot alleen Helm-bronnen, je kunt ook profiteren van de kracht van Kustomize, Ksonnet, Jsonnet, enzovoort. Neem een kijkje op de pagina met applicatiebronnen voor meer details.

Hoewel je de grafische UI (webinterface) van Argo CD kunt gebruiken om applicaties te maken, vertrouwt Starter Kit op de GitOps-declaratieve manier, via YAML-manifesten. Elke YAML-configuratie fungeert als een recept voor elke applicatie, dus het kan worden opgeslagen in een Git-opslagplaats. Dit betekent dat je altijd je Argo CD-configuratie kunt herstellen als je je omgeving opnieuw maakt of naar een ander cluster verplaatst. Belangrijker nog, je kunt audits uitvoeren en elke wijziging bijhouden via de Git-geschiedenis. Het is een goede praktijk om de Argo CD-configuratiebestanden ook in een aparte Git-opslagplaats te hebben, dan degene die wordt gebruikt voor de ontwikkeling van je applicatie. Je kunt de beste praktijkenpagina lezen op de officiële documentatiewebsite van Argo CD voor meer informatie over dit onderwerp.

Belangrijke opmerking:
Een belangrijk aspect om in gedachten te houden is dat Argo CD standaard niet automatisch uw nieuwe toepassingen synchroniseert. Wanneer een ArgoCD-toepassing voor het eerst wordt gemaakt, is de status ervan OutOfSync. Dit betekent dat de Git-repositoriestatus waarnaar de ArgoCD-toepassing wijst, niet overeenkomt met de status van het Kubernetes-cluster. Het maken van een nieuwe ArgoCD-toepassing activeert geen automatische implementatie op het doelcluster.

Om automatische synchronisatie en verwijdering van achtergebleven bronnen (opruiming) in te schakelen, moet u een syncPolicy maken. U kunt ook Argo CD configureren om automatisch handmatige wijzigingen die zijn aangebracht via kubectl ongedaan te maken. U kunt meer lezen over automatische synchronisatiebeleid op de officiële documentatiewebsite.

Een typische Application CRD met een Git-repositorybron ziet er als volgt uit:

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

Uitleg bij de bovenstaande configuratie:

  • spec.project: Geeft Argo CD aan welk project moet worden gebruikt voor de toepassing (standaard in dit voorbeeld).
  • spec.source.repoURL: Git-repository-URL die wordt gebruikt voor het synchroniseren van de clusterstatus.
  • spec.source.targetRevision: Git-repository-revisie die wordt gebruikt voor synchronisatie (kan ook een branch- of tag-naam zijn).
  • spec.source.path: Git-repository-pad waar bronbestanden (YAML-manifesten) zijn opgeslagen.
  • spec.destination.server: Doeladres van het Kubernetes-cluster. Dit wijst meestal naar https://kubernetes.default.svc, als Argo CD hetzelfde cluster gebruikt waar het is geïmplementeerd.
  • spec.destination.namespace: Kubernetes namespace om te gebruiken voor je toepassing.
  • spec.syncPolicy.automated: Schakelt geautomatiseerde synchronisatie in van toepassingen in je cluster met een Git-opslagplaats.
  • spec.syncPolicy.automated.prune: Prune geeft aan of resources uit het cluster moeten worden verwijderd die niet meer worden gevonden in de bronnen als onderdeel van de geautomatiseerde synchronisatie.
  • spec.syncPolicy.automated.selfHeal: Geeft aan of resources terug moeten worden gezet naar hun gewenste toestand bij handmatige wijziging in het cluster (bijv. via kubectl).

Je kunt ook Helm-opslagplaatsen gebruiken als bron voor het installeren van toepassingen in je cluster. Een typisch Application CRD met een Helm-opslagplaats als bron ziet er als volgt uit (vergelijkbaar met het voorbeeld van de Git-opslagplaats, behalve dat hier een Helm-grafiekopslagplaats wordt gebruikt):

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: sealed-secrets
  namespace: argocd
spec:
  project: default
  source:
    chart: sealed-secrets
    repoURL: https://bitnami-labs.github.io/sealed-secrets
    targetRevision: 2.4.0
    helm:
      releaseName: sealed-secrets
      values: |
        replicaCount: 2
  destination:
    server: "https://kubernetes.default.svc"
    namespace: kubeseal

Uitleg voor de bovenstaande configuratie:

  • spec.source.chart: Helm-grafiek om te gebruiken als bron voor de toepassing.
  • spec.source.repoURL: URL van de Helm-grafiekopslagplaats.
  • spec.source.targetRevision: Versie van de Helm-grafiek om te gebruiken voor de toepassing.
  • spec.source.helm.releaseName: Naam van de Helm-release om aan te maken in je Kubernetes-cluster.
  • spec.source.helm.values: Geeft Helm-waarden aan die moeten worden doorgegeven aan helm template, meestal gedefinieerd als een blok.
  • spec.destination.server: Doeladres van het Kubernetes-cluster. Geeft meestal https://kubernetes.default.svc aan als Argo CD hetzelfde cluster gebruikt waarin het is geïmplementeerd.
  • spec.destination.namespace: Kubernetes namespace om te gebruiken voor uw applicatie.

Ga verder en lees meer over de kernconcepten van Argo CD op de officiële documentatiewebsite. Vervolgens ga je de beschikbare installatieopties ontdekken om Argo CD in je Kubernetes-cluster te implementeren.

Argo CD installeren

Argo CD kan worden geïnstalleerd met behulp van kubectl of Helm:

  1. Gebruik kubectl en een installatiemanifestbestand. Deze methode biedt geen directe controle over verschillende installatieparameters. Als je niet erg bekend bent met op Helm gebaseerde installaties, is dit de meest eenvoudige optie om mee te beginnen.
  2. Installatie met Helm. Biedt meer gedetailleerde controle over de implementatie en levenscyclus van de Argo CD-applicatie. Aanbevolen voor HA (High Availability) setups en als Argo CD in productie wordt gebruikt.

Vervolgens, afhankelijk van de functies die je beschikbaar wilt hebben, heb je twee opties:

  • Multi-Tenant modus. Dit type installatie wordt doorgaans gebruikt om meerdere applicatieontwikkelingsteams in de organisatie te bedienen en wordt onderhouden door een platformteam. De eindgebruikers kunnen Argo CD benaderen via de API-server met behulp van de Web UI of argocd CLI.
  • Kern alleen modus. Dit is een afgeslankte installatie, zonder de grafische gebruikersinterface, API-server, SSO, enz., en installeert de lichtgewicht (niet-HA) versie van elk onderdeel.

Starter Kit gebruikt de Multi-Tenant en High Availability modi om Argo CD te installeren in uw DOKS-cluster. Op deze manier heeft u een betrouwbare opstelling en kunt u alle beschikbare functies verkennen, inclusief de gebruikersinterface. Bezoek alstublieft de installatiemethoden documentatiepagina voor meer informatie over dit onderwerp.

Kubectl-Gebaseerde Installatie

Deze methode vereist kubectl, en het is een tweestappenproces:

  1. Maak een namespace aan om Argo CD zelf te implementeren.
  2. Voer het HA-installatiemanifest uit via kubectl.

Voer alstublieft de onderstaande commando’s in de juiste volgorde uit:

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

Controleer nu alstublieft of de installatie succesvol was. Controleer eerst of alle Argo CD-implementaties gezond zijn:

kubectl get deployments -n argocd

De output ziet er ongeveer zo uit (controleer de READY-kolom – alle Pods moeten draaien):

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           51s
argocd-dex-server                  1/1     1            1           50s
argocd-notifications-controller    1/1     1            1           50s
argocd-redis-ha-haproxy            3/3     3            3           50s
argocd-repo-server                 2/2     2            2           49s
argocd-server                      2/2     2            2           49s

Argo CD-server moet een replicaset minimale waarde hebben van 2 voor de HA modus. Als om welke reden dan ook sommige implementaties niet gezond zijn, controleer dan Kubernetes-events en logs voor de aangetaste component Pods.

Installatie op basis van Helm

Deze methode vereist dat Helm is geïnstalleerd op uw lokale machine. De Starter Kit biedt een klaar voor gebruik Helm-waardenbestand om mee te beginnen en installeert Argo CD in HA-modus (zonder automatisch schalen).

Volg alstublieft de onderstaande stappen om de installatie op basis van Helm te voltooien:

  1. Eerst, kloon de Starter Kit-directory (indien nog niet gedaan) en verander de directory naar uw lokale kopie:
git clone https://github.com/digitalocean/Kubernetes-Starter-Kit-Developers.git
cd Kubernetes-Starter-Kit-Developers
  1. Vervolgens, voeg de Helm-repository van Argo CD toe:
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update argo
  1. Zoek nu de argo Helm-repository naar beschikbare grafieken om te installeren:
helm search repo argo

De uitvoer ziet er ongeveer zo uit:

Output
NAME                            CHART VERSION   APP VERSION     DESCRIPTION 
argo/argo                       1.0.0           v2.12.5         A Helm chart for Argo Workflows  
argo/argo-cd                    4.9.4           v2.4.0          A Helm chart for Argo CD, a declarative, GitOps...
...
  1. Open en inspecteer vervolgens het Argo CD Helm-waardenbestand dat wordt geleverd in de Starter Kit-repository met behulp van een editor naar keuze (bij voorkeur met YAML-lintondersteuning). U kunt bijvoorbeeld VS Code gebruiken:
code 14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v4.9.4.yaml
  1. Deploy ten slotte Argo CD naar uw DOKS-cluster:
HELM_CHART_VERSION="4.9.4"
helm install argocd argo/argo-cd --version "${HELM_CHART_VERSION}" \
  --namespace argocd \
  --create-namespace \
  -f "14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v${HELM_CHART_VERSION}.yaml"

–create-namespace \

Let op:
Een specifieke versie van het Helm-diagram wordt gebruikt. In dit geval wordt 4.9.4 gekozen, wat overeenkomt met de versie 2.4.0 van de applicatie. Het is over het algemeen een goede praktijk om te vergrendelen op een specifieke versie. Dit helpt bij voorspelbare resultaten en maakt versiebeheer mogelijk via Git.

helm ls -n argocd

Controleer nu of de Helm-release succesvol was:

NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
argocd  argocd          1               2022-03-23 11:22:48.486199 +0200 EET    deployed        argo-cd-4.9.4   v2.4.0

De uitvoer lijkt op (de waarde van de STATUS-kolom moet worden ingesteld op deployed):

kubectl get deployments -n argocd

Tenslotte, controleer de implementatiestatus van de Argo CD-toepassing:

Output
NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
argocd-applicationset-controller   1/1     1            1           2m9s
argocd-dex-server                  1/1     1            1           2m9s
argocd-notifications-controller    1/1     1            1           2m9s
argocd-redis-ha-haproxy            3/3     3            3           2m9s
argocd-repo-server                 2/2     2            2           2m9s
argocd-server                      2/2     2            2           2m9s

De uitvoer lijkt op (controleer de READY-kolom – alle Pods moeten draaien):

De Argo CD-server moet een minimale waarde van 2 hebben voor de replicaset in de HA-modus. Als om de een of andere reden sommige implementaties niet gezond zijn, controleer dan de Kubernetes-gebeurtenissen en logs voor de getroffen component-Pods.

Je kunt ook meer informatie vinden over de Argo CD Helm-grafiek door toegang te krijgen tot de door de gemeenschap onderhouden repository.

Vervolgens ga je leren hoe je toegang krijgt tot en de belangrijkste functies van de grafische gebruikersinterface van Argo CD verkent.

Toegang tot en verkenning van de Argo CD-webinterface

Een van de handige functies die Argo CD te bieden heeft, is de webinterface, die wordt gebruikt om verschillende beheertaken uit te voeren en de status van applicatie-implementaties te bekijken. U kunt applicaties maken met behulp van de grafische gebruikersinterface en op verschillende manieren met Argo CD communiceren. Een andere belangrijke functie is de mogelijkheid om de status van elke applicatie te inspecteren en toegang te krijgen tot Kubernetes-gebeurtenissen, evenals de logs van uw applicatie. Bovendien biedt Argo CD een visuele voorstelling van alle Kubernetes-objecten (replicareeksen, pods, enz.) die elke implementatie van een applicatie gebruikt.

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

De webinterface is toegankelijk via port-forwarding van de Kubernetes-service argocd-server. Voer de onderstaande opdracht uit in een shell-terminal:

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

Open nu een webbrowser en ga naar localhost:8080 (negeer alstublieft de ongeldige TLS-certificaten voor nu). U wordt begroet met de aanmeldingspagina van Argo CD. De standaardbeheerdersgebruikersnaam is admin, en het wachtwoord wordt willekeurig gegenereerd bij de installatie. U kunt het ophalen door de onderstaande opdracht uit te voeren:

Vervolgens wordt u doorgestuurd naar de dashboardpagina van de applicaties. Vanaf hier kunt u applicaties bekijken, maken of beheren via de UI (een YAML-editor is ook beschikbaar), evenals synchronisatie- of vernieuwingsbewerkingen uitvoeren:

Als u op een applicatietegel klikt, wordt ook een visuele voorstelling van alle betrokken objecten getoond:

In de volgende sectie kunt u uw applicatieprojecten, repositories en clusters beheren:

Ten slotte toont de gebruikersinformatiesectie de beschikbare gebruikers en maakt het mogelijk om het wachtwoord van de beheerder bij te werken:

Je kunt spelen en elke sectie en subsectie in detail verkennen om alle beschikbare functies te zien. Vervolgens leer je hoe je de CLI-tegenhanger, genaamd argocd, kunt gebruiken.

Het Kennen van de Argo CD CLI

argocd
Usage:
  argocd [flags]
  argocd [command]

Available Commands:
  account     Manage account settings
  admin       Contains a set of commands useful for Argo CD administrators and requires direct Kubernetes access
  app         Manage applications
  cert        Manage repository certificates and SSH known hosts entries
  cluster     Manage cluster credentials
  completion  output shell completion code for the specified shell (bash or zsh)
  context     Switch between contexts
  gpg         Manage GPG keys used for signature verification
  help        Help about any command
...

Argo CD staat toe dat dezelfde set functies wordt gebruikt via de webinterface of via de CLI. Om de argocd CLI te gebruiken, moet je een aparte shell-venster openen en gewoon argocd typen zonder enige argumenten. Standaard worden de beschikbare commando’s en opties weergegeven:

argocd app --help

Voor elk commando of sub-commando kun je de bijbehorende helppagina oproepen met het volgende patroon: argocd <commando/subcommando> --help. Als je bijvoorbeeld wilt controleren welke opties beschikbaar zijn voor het app-commando:

Manage Applications
Usage:
  argocd app [flags]
  argocd app [command]

Examples:
  De uitvoer ziet er vergelijkbaar uit:
  argocd app list
  
  # Lijst alle applicaties op.
  argocd app get my-app
...

# Haal de details van een applicatie op

Ga gerust verder en verken ook andere commando’s/subcommando’s om alle beschikbare opties te zien. Vervolgens leer je hoe je je eerste Argo CD-applicatie kunt opstarten, die automatisch alle componenten van de Starter Kit implementeert.

Bootstrapen van Argo CD-toepassingen

Bij een nieuwe installatie weet Argo CD niet waar het de toepassingen moet synchroniseren, of welke Git-repositories beschikbaar zijn voor het ophalen van toepassingsmanifesten. De eerste stap is dus om een eenmalige operatie uit te voeren die bootstrapping wordt genoemd. U kunt alle bewerkingen in deze sectie uitvoeren met behulp van de argocd CLI of de grafische gebruikersinterface.

Er zijn meerdere manieren om uw cluster te bootstrappen (bijv. via scripts), maar meestal maken Argo CD-gebruikers gebruik van het app of apps-patroon. Dit betekent dat u begint met het maken van een ouderlijke toepassing met behulp van de good CLI (of de webinterface), die op zijn beurt de rest van de toepassingen in uw Kubernetes-cluster zal refereren en bootstrappen.

Voorbereiden van de lay-out van het Git-repository

clusters
└── dev
    └── helm
        ├── cert-manager-v1.8.0.yaml
        ├── nginx-v4.1.3.yaml
        ├── prometheus-stack-v35.5.1.yaml
        ├── sealed-secrets-v2.4.0.yaml
        └── velero-v2.29.7.yaml

Eerst moet u uw Git-repository voorbereiden om een consistente lay-out te gebruiken. In het volgende voorbeeld zal een Git-repository-lay-outstructuur worden gemaakt die vergelijkbaar is met:

  1. Open alstublieft een terminal en volg de onderstaande stappen om de lay-out voor uw Git-repository te maken:
git clone <YOUR_ARGOCD_GIT_REPOSITORY_ADDRESS>
  1. Eerst kloon je je git-repository die wordt gebruikt voor het testen van Argo CD (zorg ervoor dat je de <> placeholders vervangt door de juiste gegevens):
cd <YOUR_GIT_REPO_LOCAL_COPY_DIRECTORY>
mkdir -p clusters/dev/helm
  1. Vervolgens verander je naar de directory van je lokale kopie en maak je de directorystructuur aan (zorg ervoor dat je de <> placeholders vervangt door de juiste gegevens):
CERT_MANAGER_CHART_VERSION="1.8.0"
NGINX_CHART_VERSION="4.1.3"
PROMETHEUS_CHART_VERSION="35.5.1"
SEALED_SECRETS_CHART_VERSION="2.4.0"
VELERO_CHART_VERSION="2.29.7"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml" > "clusters/dev/helm/cert-manager-v${CERT_MANAGER_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/nginx-v${NGINX_CHART_VERSION}.yaml" > "clusters/dev/helm/nginx-v${NGINX_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml" > "clusters/dev/helm/prometheus-stack-v${PROMETHEUS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml" > "clusters/dev/helm/sealed-secrets-v${SEALED_SECRETS_CHART_VERSION}.yaml"

curl "https://raw.githubusercontent.com/digitalocean/Kubernetes-Starter-Kit-Developers/main/14-continuous-delivery-using-gitops/assets/manifests/argocd/applications/helm/velero-v${VELERO_CHART_VERSION}.yaml" > "clusters/dev/helm/velero-v${VELERO_CHART_VERSION}.yaml"
  1. Kopieer de applicatie-manifesten die zijn verstrekt voor elk component in de Starter Kit-repository (je kunt ook kijken hoe elk manifest is gestructureerd):

Tenslotte, commit de wijzigingen en push naar de origin.

Daarna zal je de ouderapplicatie-implementatie maken en Argo CD alle Starter Kit-applicaties automatisch laten synchroniseren met je DOKS-cluster.

Het gebruik van het App of Apps-patroon via de Argo CD CLI

In deze sectie leer je hoe je de argocd-CLI gebruikt om het app of apps-patroon te creëren en te gebruiken om alle Starter Kit-componenten in je DOKS-cluster te implementeren. Onderstaande afbeelding illustreert het hoofdconcept:

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

Eerst moet je de hoofdserver van Argo CD doorsturen naar je lokale machine in een apart terminalvenster:

ADMIN_USER="admin"
ADMIN_PASSWD="$(kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d)"
argocd login localhost:8080 --username $ADMIN_USER --password $ADMIN_PASSWD --insecure

Volgende, is toegang tot de Argo CD API-server nodig voor de argocd CLI om te werken. Gebruik een andere terminalvenster om de argocd-client te authenticeren met je Argo CD-serverinstantie:

Output
'admin:login' logged in successfully
Context 'localhost:8080' updated

Het uitvoer ziet er vergelijkbaar uit:

argocd app create starter-kit-apps \
    --dest-namespace argocd \
    --dest-server https://kubernetes.default.svc \
    --repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
    --path clusters/dev/helm

Vervolgens, voer de onderstaande opdracht uit om de ouderapplicatie starter-kit-apps te maken (zorg ervoor dat je de <> plaatshouders vervangt):

  • –dest-namespace argocd \
  • –dest-server https://kubernetes.default.svc \
  • De bovenstaande opdracht zal een nieuwe Argo CD-applicatie genaamd starter-kit-apps creëren in de argocd namespace, geconfigureerd om:

Richten op dezelfde Kubernetes-cluster waar Argo CD is ingezet, omdat --dest-server is ingesteld op https://kubernetes.default.svc.

argocd app sync starter-kit-apps

Gebruik het GitHub-repository ingesteld door het argument --repo om je cluster te synchroniseren.

Output
TIMESTAMP                  GROUP        KIND             NAMESPACE   NAME                       STATUS     HEALTH  ...
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      sealed-secrets-controller  OutOfSync  Missing ...            
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      velero                     OutOfSync  Missing ...             
2022-03-23T17:39:38+02:00  argoproj.io  Application      argocd      ingress-nginx              OutOfSync  Missing ...
...
GROUP        KIND         NAMESPACE  NAME                       STATUS  HEALTH  HOOK  MESSAGE
argoproj.io  Application  argocd     sealed-secrets-controller  Synced                application.argoproj.io/sealed-secrets-controller created
argoproj.io  Application  argocd     ingress-nginx              Synced                application.argoproj.io/ingress-nginx created
argoproj.io  Application  argocd     kube-prometheus-stack      Synced                application.argoproj.io/kube-prometheus-stack created
argoproj.io  Application  argocd     velero                     Synced                application.argoproj.io/velero created
argoproj.io  Application  argocd     cert-manager               Synced                application.argoproj.io/cert-manager created

Scan en pas alle applicatie-manifesten toe die gevonden zijn in de clusters/dev/helm directory (--path argument).

Vervolgens moet je de applicatie starter-kit-apps synchroniseren (onthoud dat Argo CD standaard niets synchroniseert tenzij gespecificeerd):

argocd app list

Het uitvoer ziet er vergelijkbaar uit:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS     HEALTH   SYNCPOLICY  ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  OutOfSync  Missing  Auto-Prune  ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  OutOfSync  Missing  Auto-Prune  ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  OutOfSync  Missing  Auto-Prune  ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  OutOfSync  Missing  Auto-Prune  ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced     Healthy  <none>      ...  
velero                     https://kubernetes.default.svc  velero          default  OutOfSync  Missing  Auto-Prune  ...

Nadat het bovenstaande commando is voltooid, zou je een nieuwe applicatie moeten zien in het hoofddashboard van je Argo CD-server. Open vervolgens een webbrowser en ga naar http://localhost:8080. Selecteer vervolgens het tabblad Applicaties en klik op de tegel starter-kit-apps (let op het app of apps-patroon door naar de compositiegrafiek te kijken):

argocd app sync -l argocd.argoproj.io/instance=starter-kit-apps

Je kunt de nieuwe applicaties ook inspecteren via de CLI:

De uitvoer ziet er vergelijkbaar uit:

argocd app list

De ouderapplicatie starter-kit-apps verschijnt als in-sync, maar de onderliggende apps zijn uit sync. Vervolgens kun je alles synchroniseren via de webinterface of via de CLI:

Output
NAME                       CLUSTER                         NAMESPACE       PROJECT  STATUS    HEALTH   SYNCPOLICY  CONDITIONS ...
ingress-nginx              https://kubernetes.default.svc  ingress-nginx   default  Synced    Healthy  Auto-Prune  <none>     ...
cert-manager               https://kubernetes.default.svc  cert-manager    default  Synced    Healthy  Auto-Prune  <none>     ...
kube-prometheus-stack      https://kubernetes.default.svc  monitoring      default  Synced    Healthy  Auto-Prune  <none>     ...
sealed-secrets-controller  https://kubernetes.default.svc  sealed-secrets  default  Synced    Healthy  Auto-Prune  <none>     ...
starter-kit-apps           https://kubernetes.default.svc  argocd          default  Synced    Healthy  <none>      <none>     ...
velero                     https://kubernetes.default.svc  velero          default  OutOfSync Missing  Auto-Prune  SyncError  ...

De synchronisatieoperatie kan even duren om te voltooien (zelfs tot 5-10 minuten), afhankelijk van de complexiteit en het aantal Kubernetes-objecten van alle ingezette applicaties.

Na enige tijd, vermeld alstublieft opnieuw alle applicaties:

argocd app create starter-kit-apps \
  --dest-namespace argocd \
  --dest-server https://kubernetes.default.svc \
  -repo https://github.com/<YOUR_GITHUB_USERNAME>/<YOUR_ARGOCD_GITHUB_REPO_NAME>.git \
  --path clusters/dev/helm \
   --sync-policy automated \
  --auto-prune \
  --self-heal
  • De uitvoer ziet er vergelijkbaar uit (let op dat alle applicaties nu gesynchroniseerd zijn):
argocd app get velero

De implementatie van de Velero-toepassing zal mislukken en opzettelijk in de staat SyncError worden achtergelaten als een oefening voor de lezer om vertrouwd te raken met en te leren hoe ze applicatieproblemen kunnen diagnosticeren in Argo CD. Raadpleeg de onderstaande Hints-sectie om te zien hoe u Argo CD-applicatieproblemen kunt diagnosticeren.
Het opstarten van de ouderapplicatie is een eenmalige operatie. Bij latere Git-wijzigingen voor elke applicatie zal Argo CD de afwijking detecteren en de benodigde wijzigingen toepassen. Argo CD gebruikt standaard een polling-mechanisme om wijzigingen in uw Git-repository te detecteren. Het standaard verversingsinterval is ingesteld op 3 minuten. In plaats van te vertrouwen op een polling-mechanisme, kunt u ook gebruikmaken van de kracht van Git-webhooks. Bezoek alstublieft de officiële documentatiewebsite om te leren hoe u Argo CD kunt maken en configureren om Git webhooks te gebruiken.

Output
 Name:               velero
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          velero
URL:                https://argocd.example.com/applications/velero
Repo:               https://vmware-tanzu.github.io/helm-charts
Target:             2.27.3
 Path:               
SyncWindow:         Sync Allowed
Sync Policy:        Automated (Prune)
Sync Status:        OutOfSync from 2.27.3
Health Status:      Missing
CONDITION  MESSAGE                                                                                          LAST TRANSITION
SyncError  Failed sync attempt to 2.27.3: one or more objects failed to apply (dry run) (retried 5 times).  2022-03-24 12:14:21 +0200 EET
 GROUP                      KIND                      NAMESPACE  NAME                               STATUS     HEALTH      HOOK      MESSAGE
velero.io                  VolumeSnapshotLocation    velero     default                            Failed     SyncFailed  PostSync  error validating data: ValidationError(VolumeSnapshotLocation.spec): missing required field "provider" in io.velero.v1.VolumeSnapshotLocation.spec
velero.io                  BackupStorageLocation     velero     default                            Failed     SyncFailed  PostSync  error validating data: [ValidationError(BackupStorageLocation.spec.objectStorage): missing required field "bucket" in io.velero.v1.BackupStorageLocation.spec.objectStorage, ValidationError(BackupStorageLocation.spec): missing required field "provider" in io.velero.v1.BackupStorageLocation.spec]
...

Hints: Als u dat wenst, kunt u de ouderapplicatie configureren om automatisch te worden gesynchroniseerd (en ook zelfherstel en automatisch opruimen inschakelen), kunt u het volgende commando gebruiken (vergeet niet om de <>-placeholders dienovereenkomstig te vervangen):

–dest-namespace argocd \

–dest-server https://kubernetes.default.svc \

–sync-policy automated \

–auto-prune \

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

In geval van synchronisatiefouten kunt u altijd de Kubernetes-gebeurtenissen voor de betreffende toepassing controleren (via argocd app get <toepassingsnaam>):

Het uitvoer ziet er vergelijkbaar uit:

  • Vervolgens leert u hoe u het app van apps-patroon kunt gebruiken en dezelfde stappen kunt uitvoeren via de grafische gebruikersinterface van Argo CD.
  • Het gebruik van het App van Apps-patroon via de Argo CD-webinterface
  • In deze sectie leert u hoe u de Argo CD-webinterface kunt gebruiken om het app van apps-patroon te maken en te gebruiken om alle Starter Kit-componenten in uw DOKS-cluster te implementeren. Onderstaande afbeelding illustreert het hoofdconcept:
  • Zoals de bovenstaande diagram laat zien, is het opstarten van een nieuwe toepassing via de webinterface erg vergelijkbaar met de CLI-tegenhanger. Het enige verschil is dat u tussen verschillende panelen/vensters navigeert en punt-en-klikbewerkingen uitvoert. Achter de schermen zal Argo CD de vereiste toepassings-CRD’s maken en wijzigingen toepassen op uw Kubernetes-cluster.
  • Eerst, open alstublieft een webbrowser en log in op de Argo CD-webconsole. De standaard gebruikersnaam is admin, en het standaard wachtwoord wordt verkregen via:
  • Eenmaal ingelogd, wordt u doorgestuurd naar de dashboardpagina van de applicaties (bij een nieuwe installatie is het dashboard leeg). Klik vervolgens op de knop Applicatie maken. Er verschijnt een nieuw paneel waarin om applicatiedetails wordt gevraagd:
  • Vul elk veld passend in:

Applicatienaam: De nieuwe naam van de applicatie (bijv. starter-kit-apps).

Project: De projectnaam waartoe deze applicatie behoort (bij eerste gebruik van Argo CD kunt u default gebruiken).

Synchronisatiebeleid en Synchronisatie-opties: Configureert synchronisatiebeleid en -opties (bijv. Handmatig, Automatisch, aantal herhalingen, interval tussen herhalingen, enzovoort).

Bron Repository-URL: Uw GitHub-repository-URL-adres – bijv. https://github.com/<UW_GITHUB_GEBRUIKERSNAAM>/<UW_ARGOCD_GITHUB_REPO_NAAM>.git.

Bron Pad: Pad naar de directory van de GitHub-repository waarin applicatiemanifesten zijn opgeslagen (bijv. clusters/dev/helm).

Doel Cluster-URL: Doel-Kubernetes-cluster om te synchroniseren met uw GitHub-repository (bijv. https://kubernetes.default.svc voor het lokale cluster waar Argo CD is geïmplementeerd).

Doel Namespace: Doel-Kubernetes-clusternamespace om te gebruiken voor Argo CD-applicaties (argocd, meestal).

Na het invullen van alle applicatiedetails, klik op de knop Maken bovenaan. Een nieuwe applicatietegel verschijnt op de dashboardpagina:

Als u op de toepassingstegel klikt, kunt u het app van apps patroon observeren door naar de compositiegrafiek te kijken:

Als u naar de bovenstaande afbeelding kijkt, zult u merken dat alle toepassingen zijn gemarkeerd als OutOfSync. De volgende stap is om een synchronisatiebewerking te activeren op de ouderlijke toepassing. Vervolgens worden alle onderliggende toepassingen ook gesynchroniseerd. Ga alstublieft verder en druk op de Sync knop op de ouderlijke toepassingstegel. Er verschijnt een nieuw paneel aan de rechterkant (let op dat alle onderliggende apps zijn geselecteerd hieronder):

Laat de standaardwaarden staan, druk vervolgens op de knop Synchroniseren bovenaan en zie hoe Argo CD de synchronisatiebewerking naar alle toepassingen doorvoert:

De implementatie van de Velero-toepassing zal mislukken en opzettelijk in de SyncError-status blijven als oefening voor de lezer om vertrouwd te raken met en te leren hoe toepassingsproblemen in Argo CD te diagnosticeren. Raadpleeg alstublieft de Hints sectie hieronder om te zien hoe u problemen met Argo CD-toepassingen kunt diagnosticeren.

Als alles goed gaat, moeten alle applicaties een groene rand hebben en de status moet Gezond en Gesynchroniseerd zijn. Het bootstrapproces is een eenmalige operatie. Bij latere Git-wijzigingen voor elke applicatie zal Argo CD de afwijking detecteren en de vereiste wijzigingen toepassen. Argo CD gebruikt standaard een polling mechanisme om wijzigingen in uw Git-opslagplaats te detecteren. Het standaard verversingsinterval is ingesteld op 3 minuten. In plaats van te vertrouwen op een polling mechanisme, kunt u ook gebruikmaken van de kracht van Git-webhooks. Bezoek alstublieft de officiële documentatiewebsite om te leren hoe u Argo CD kunt maken en configureren om Git webhooks te gebruiken.

Hint: Als gewenst, kunt u de ouderapplicatie configureren om automatisch te worden gesynchroniseerd door de waarde van het veld SYNC POLICY in te stellen op Automatisch. Om zelfherstel en automatisch snoeien in te schakelen, vinkt u de selectievakjes PRUNE RESOURCES en SELF HEAL aan:

In geval van synchronisatiefouten kunt u altijd de Kubernetes-gebeurtenissen voor de betreffende applicatie inspecteren. Met de webinterface kunt u naar de getroffen applicatietegel navigeren:

Vervolgens, klik op de Sync failed berichtkoppeling gemarkeerd in rood, vanuit de LAST SYNC RESULT sectie in de toepassingspagina header. Een nieuw paneel verschijnt, waarin handige informatie wordt weergegeven over waarom de synchronisatieoperatie is mislukt:

Application Sets is een andere krachtige functie die wordt aangeboden door Argo CD. De ApplicationSet Controller is een subproject van Argo CD, dat applicatieautomatisering toevoegt via gesjabloneerde definities. Deze functie helpt u herhalingen in uw toepassingsmanifesten te vermijden (maak gebruik van het DRY-principe).

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-app
spec:
  generators:
    - list:
        elements:
          - cluster: dev
            url: https://kubernetes.dev.svc
          - cluster: qa
            url: https://kubernetes.qa.svc
          - cluster: prod
            url: https://kubernetes.prod.svc
  template:
    metadata:
      name: '{{cluster}}-app'
    spec:
      project: default
      source:
        repoURL: https://github.com/myrepo/my-applicationset.git
        targetRevision: HEAD
        path: clusters/{{cluster}}/my-apps
      destination:
        server: '{{url}}'
        namespace: argocd

De ApplicationSet-controller is geïnstalleerd naast Argo CD (binnen dezelfde namespace) en genereert automatisch Argo CD-toepassingen op basis van de inhoud van een nieuwe ApplicationSet Custom Resource (CR).

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: dev-app
spec:
  project: default
  source:
    repoURL: https://github.com/myrepo/my-applicationset.git
    targetRevision: HEAD
    path: clusters/dev/my-apps
  destination:
    server: https://kubernetes.dev.svc
    namespace: argocd

Opmerking:
Vanaf versie 2.3.x van Argo CD hoeft u de ApplicationSet Controller niet apart te installeren omdat het deel uitmaakt van de hoofdinstallatie van Argo CD. Starter Kit gebruikt versie >= 2.3.1, dus u hoeft niets te wijzigen.

De hoofdgedachte van een ApplicationSet is gebaseerd op het hebben van een lijst van waarden die fungeren als een generator, en een sjabloon die wordt ingevuld door de invoerlijstwaarden. Voor elk item uit de lijst wordt op volgorde een nieuw applicatiesjabloon gegenereerd. In feite definieer je één ApplicationSet CRD en laat je het voor jou zoveel ArgoCD Application CRD’s genereren als je wilt, gebaseerd op de invoerwaarden. Dus, in plaats van meerdere Applicatie-manifesten te maken en ermee om te gaan, beheer je alles via een enkel manifest – de ApplicationSet.

Dit concept vereenvoudigt ook het beheer van multi-cluster– en multi-environment-opstellingen door het gebruik van geparametriseerde applicatiesjablonen. Applicatie sets omvatten naast Generatoren voor Lijsten ook andere generatoren:

Cluster-generator: Gebruikt door Argo CD gedefinieerde clusters om applicaties te sjabloneren.

argocd app delete starter-kit-apps

Git-generator: Gebruikt de bestanden/mappen van een Git repository om applicaties te sjabloneren.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: cert-manager
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io
spec:
...

Een typisch ApplicationSet CRD met behulp van een Generator voor Lijsten, ziet er als volgt uit:

Het toepassen van het bovenstaande ApplicationSet op uw Kubernetes-cluster zal drie Argo CD-applicaties renderen. Bijvoorbeeld, de applicatie voor de ontwikkel-omgeving wordt weergegeven zoals hieronder:

Template-engines zijn van nature zeer krachtig en bieden veel mogelijkheden. Bezoek alstublieft de hoofdwebsite van de documentatie van ApplicationSet om meer te weten te komen over deze functie.

Argo CD-applicaties verwijderen

Het verwijderen (of verwijderen) van applicaties die worden beheerd door Argo CD wordt bereikt door het overeenkomstige manifest uit de Git-repositorybron te verwijderen. In het geval van applicaties die zijn gemaakt met het app of apps-patroon, moet u alleen de hoofdapp verwijderen (via de CLI of webinterface). Vervolgens worden alle onderliggende applicaties ook verwijderd als onderdeel van het proces.

  • Hoe u de ouderapplicatie starter-kit-apps (inclusief kind-apps) kunt verwijderen met behulp van de argocd-CLI:
  • Als u wilt garanderen dat kind-apps en al hun resources worden verwijderd wanneer de ouderapp wordt verwijderd, zorg er dan voor dat u de juiste finalizer toevoegt aan uw Applicatiedefinitie:

Source:
https://www.digitalocean.com/community/developer-center/implementing-gitops-using-argo-cd