Implementazione di GitOps utilizzando Argo CD

Tutorial
Git Kubernetes

Introduzione

Argo CD è una popolare implementazione open source per eseguire la continuous delivery di GitOps su Kubernetes. Le tue applicazioni, definizioni, configurazioni e ambienti dovrebbero essere dichiarativi e versionati. Inoltre, il rilascio delle applicazioni e la gestione del ciclo di vita dovrebbero essere automatizzati, auditabili e facili da capire. Tutto questo può essere fatto utilizzando Argo.

Argo CD aderisce agli stessi modelli e principi di GitOps, mantenendo quindi lo stato del tuo cluster utilizzando un approccio dichiarativo. La sincronizzazione avviene tramite un repository Git, dove sono memorizzati i manifesti Kubernetes. I manifesti Kubernetes possono essere specificati in diversi modi:

Come ogni applicazione che viene eseguita in un cluster Kubernetes, Argo CD è configurato tramite definizioni di risorse personalizzate (CRD) memorizzate all’interno di manifesti YAML. La più importante è la CRD Application. In un’applicazione Argo CD, si definisce quale repository Git deve essere utilizzato per sincronizzare quale cluster Kubernetes. Può essere lo stesso cluster Kubernetes dove è distribuito Argo CD, o uno esterno.

Argo CD è implementato come un Controller Kubernetes che monitora continuamente le applicazioni in esecuzione e confronta lo stato corrente (o live) con lo stato target desiderato (come specificato nel repository Git). Un’applicazione distribuita il cui stato live si discosta dallo stato target è considerata OutOfSync. Argo CD segnala e visualizza le differenze, fornendo strumenti per sincronizzare automaticamente o manualmente lo stato live con lo stato target desiderato.

Argo CD offre molte funzionalità, tra le più importanti:

  • Supporto per vari strumenti di gestione/configurazione dei dati, come: Kustomize, Helm, Ksonnet, Jsonnet, plain-YAML.
  • Capacità di gestire e distribuire su più cluster.
  • Integrazione SSO (OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, LinkedIn).
  • Multi-tenancy e politiche RBAC per l’autorizzazione.
  • Analisi dello stato di salute delle risorse dell’applicazione.
  • Rollback/Roll-anywhere a qualsiasi configurazione dell’applicazione commessa nel repository Git.
  • Rilevamento della deriva della configurazione automatizzata e visualizzazione.
  • Interfaccia utente Web che fornisce una visualizzazione in tempo reale dell’attività dell’applicazione.
  • CLI per l’automazione e l’integrazione CI.
  • Integrazione Webhook (GitHub, BitBucket, GitLab).
  • Hook PreSync, Sync, PostSync per supportare rollout complessi dell’applicazione (ad esempio, aggiornamenti blue/green e canary).
  • Metriche di Prometheus.

In questo tutorial, imparerai a:

  • Utilizzare Helm per approvvigionare Argo CD al tuo cluster DOKS.
  • Mantenere sincronizzato lo stato delle applicazioni del cluster Kubernetes con un repository Git (utilizzare i principi GitOps).
  • Effettuare il deploy e gestire le applicazioni tramite Argo CD.

Dopo aver completato tutti i passaggi di questo tutorial, dovresti avere un cluster DOKS con Argo CD deployato, che:

  • Gestisce la riconciliazione del cluster, tramite CRD dell’Applicazione.
  • Gestisce i rilasci di Helm, utilizzando le fonti Helm definite all’interno dei CRD dell’applicazione.

DOKS e Argo CD per Panoramica dei Rilasci di Helm

Il diagramma seguente mostra come Argo CD gestisce le applicazioni Helm ospitate utilizzando un repository Git:

Tabella dei Contenuti

Prerequisiti

Per completare questo tutorial, avrai bisogno di:

  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, per l’interazione con Kubernetes. Segui queste istruzioni per connetterti al tuo cluster con kubectl e doctl.
  5. Argo CLI, per interagire con Argo CD utilizzando l’interfaccia della riga di comando.
  6. Kubeseal, per la crittografia delle segrete e l’interazione con il controller di Sealed Secrets.
  7. Helm, per gestire rilasci e aggiornamenti di Argo CD (opzionale, ma generalmente consigliato per i sistemi in produzione).

Comprensione dei concetti di Argo CD per il rilascio delle applicazioni

Argo CD utilizza il concetto centrale di Applicazione per gestire il rilascio e il ciclo di vita delle applicazioni. All’interno di un manifesto dell’applicazione di Argo CD, si definisce il repository Git che ospita le definizioni dell’applicazione, così come il cluster Kubernetes corrispondente per distribuire le applicazioni. In altre parole, un’applicazione di Argo CD definisce la relazione tra un repository di origine e un cluster Kubernetes. Si tratta di un design molto conciso e scalabile, dove è possibile associare più origini (repository Git) e relativi cluster Kubernetes.

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.

Inoltre, è possibile raggruppare applicazioni simili in un Progetto. I progetti consentono di raggruppare logicamente le applicazioni e i ruoli/autorizzazioni associati quando si lavora con più team. Quando non specificato, ogni nuova applicazione appartiene al default progetto. Il progetto default viene creato automaticamente e non ha restrizioni. Il progetto predefinito può essere modificato, ma non eliminato.

Il Kit di Avvio utilizza il progetto default per un rapido avvio utilizzando Argo CD. Successivamente, imparerai come creare un Applicazione per ogni componente del Kit di Avvio, e utilizzare i chart di Helm come sorgente dell'applicazione. Argo CD non è limitato solo alle sorgenti Helm, e puoi anche sfruttare la potenza di Kustomize, Ksonnet, Jsonnet, ecc. Si prega di consultare la pagina delle sorgenti dell’applicazione per maggiori dettagli.

Sebbene tu possa utilizzare l’interfaccia utente grafica (interfaccia web) di Argo CD per creare applicazioni, il Kit di Avvio si basa sul modo dichiarativo di GitOps, tramite manifesti YAML. Ogni configurazione YAML funge da ricetta per ciascuna applicazione, quindi può essere memorizzata in un repository Git. Ciò significa che puoi sempre ricreare la tua configurazione di Argo CD se ricrei il tuo ambiente o ti sposti su un altro cluster. Inoltre, è possibile eseguire audit e tenere traccia di ogni modifica tramite la cronologia di Git. È una pratica consigliata avere anche i file di configurazione di Argo CD in un repository Git separato rispetto a quello utilizzato per lo sviluppo dell’applicazione. Puoi leggere la pagina delle pratiche consigliate sul sito web della documentazione ufficiale di Argo CD per ulteriori informazioni sull’argomento.

Nota importante:
Un aspetto importante da tenere presente è che per impostazione predefinita Argo CD non sincronizza automaticamente le nuove applicazioni. Quando viene creata per la prima volta un’applicazione ArgoCD, il suo stato è OutOfSync. Significa che lo stato del repository Git indicato dall’applicazione ArgoCD non corrisponde allo stato del cluster Kubernetes. La creazione di una nuova applicazione ArgoCD non attiva un dispiegamento automatico nel cluster di destinazione.

Per abilitare la sincronizzazione automatica e l’eliminazione delle risorse orfane (pruning), è necessario creare una syncPolicy. È anche possibile configurare Argo CD per ripristinare automaticamente le modifiche manuali apportate tramite kubectl. Puoi leggere ulteriori informazioni sulle politiche di sincronizzazione automatica sul sito ufficiale della documentazione.

Il tipico CRD dell'Applicazione che utilizza una sorgente del repository Git appare come segue:

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

Spiegazioni per la configurazione sopra riportata:

  • spec.project: Indica ad Argo CD quale progetto utilizzare per l’applicazione (default in questo esempio).
  • spec.source.repoURL: URL del repository Git utilizzato per sincronizzare lo stato del cluster.
  • spec.source.targetRevision: Revisione del repository Git utilizzata per la sincronizzazione (può essere anche il nome di un ramo o di un tag).
  • spec.source.path: Percorso del repository Git dove sono memorizzati i file sorgente (manifest YAML).
  • spec.destination.server: Indirizzo del cluster Kubernetes di destinazione. Di solito punta a https://kubernetes.default.svc, se Argo CD sta utilizzando lo stesso cluster in cui è distribuito.
  • spec.destination.namespace: Namespace Kubernetes da utilizzare per la tua applicazione.
  • spec.syncPolicy.automated: Abilita la sincronizzazione automatica delle applicazioni nel tuo cluster con un repository Git.
  • spec.syncPolicy.automated.prune: Prune specifica se eliminare le risorse dal cluster che non sono più presenti nelle origini come parte della sincronizzazione automatica.
  • spec.syncPolicy.automated.selfHeal: Specifica se ripristinare le risorse allo stato desiderato in caso di modifica manuale nel cluster (ad esempio tramite kubectl).

Puoi anche utilizzare i repository di Helm come origine per installare applicazioni nel tuo cluster. Un tipico CRD dell'applicazione che utilizza una sorgente del repository di Helm, appare come segue (simile all’esempio del repository Git, tranne che viene utilizzato un repository di chart di Helm):

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

Spiegazioni per la configurazione sopra:

  • spec.source.chart: Chart Helm da utilizzare come origine per l’applicazione.
  • spec.source.repoURL: URL del repository del chart di Helm.
  • spec.source.targetRevision: Versione del chart di Helm da utilizzare per l’applicazione.
  • spec.source.helm.releaseName: Nome del rilascio di Helm da creare nel tuo cluster Kubernetes.
  • spec.source.helm.values: Specifica i valori di Helm da passare al template di helm, tipicamente definiti come un blocco.
  • spec.destination.server: Indirizzo del cluster Kubernetes di destinazione. Di solito punta a https://kubernetes.default.svc, se Argo CD sta utilizzando lo stesso cluster in cui è distribuito.
  • spec.destination.namespace: Spazio dei nomi Kubernetes da utilizzare per la tua applicazione.

Per favore, continua a leggere di più sui concetti di base di Argo CD sul sito ufficiale della documentazione. Successivamente, scoprirai le opzioni di installazione disponibili per distribuire Argo CD nel tuo cluster Kubernetes.

Installazione di Argo CD

Argo CD può essere installato utilizzando kubectl o Helm:

  1. Utilizzando kubectl e un file manifesto di installazione. Questo metodo non offre un controllo diretto per vari parametri di installazione. Se non sei molto familiare con le installazioni basate su Helm, questa è l’opzione più diretta con cui iniziare.
  2. Installazione basata su Helm. Offre un controllo più granulare per la distribuzione e il ciclo di vita dell’applicazione Argo CD. Consigliato per configurazioni ad HA (Alta Affidabilità) e se Argo CD viene utilizzato in produzione.

Successivamente, a seconda delle funzionalità che desideri disponibili, hai due opzioni:

  • Modalità Multi-Tenant. Questo tipo di installazione viene tipicamente utilizzato per servire più team di sviluppatori di applicazioni nell’organizzazione ed è gestito da un team di piattaforma. Gli utenti finali possono accedere ad Argo CD tramite il server API utilizzando l’interfaccia utente Web o argocd CLI.
  • Modalità solo Core. Questa è un’installazione ridotta, senza l’interfaccia utente grafica, il server API, SSO, ecc., e installa la versione leggera (non-HA) di ciascun componente.

Kit di avvio sta utilizzando le modalità Multi-Tenant e Alta Disponibilità per installare Argo CD nel tuo cluster DOKS. In questo modo, avrai una configurazione affidabile ed esplorerai tutte le funzionalità disponibili, inclusa l’interfaccia utente. Si prega di visitare la pagina di documentazione sui metodi di installazione per maggiori informazioni sull’argomento.

Installazione basata su Kubectl

Questo metodo richiede kubectl, ed è un processo in due fasi:

  1. Creare uno namespace per distribuire Argo CD stesso.
  2. Eseguire il manifesto di installazione HA tramite kubectl.

Si prega di eseguire i comandi seguenti nell’ordine indicato:

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

Ora, si prega di procedere e verificare se l’installazione è stata eseguita con successo. Innanzitutto, controllare se tutti i deployment di Argo CD sono sani:

kubectl get deployments -n argocd

Il risultato assomiglia a (controllare la colonna READY – tutti i Pods devono essere in esecuzione):

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

Il server Argo CD deve avere un valore minimo di 2 per il replicaset in modalità HA. Se per qualche motivo alcuni deployment non sono sani, controllare gli eventi di Kubernetes e i log per i Pods del componente interessato.

Installazione basata su Helm

Questo metodo richiede che Helm sia installato sul tuo computer locale. Il kit di avvio fornisce un file di valori Helm pronto all’uso per iniziare e installa Argo CD in modalità HA (senza autoscaling).

Segui i passaggi seguenti per completare l’installazione basata su Helm:

  1. Prima, clona la directory del kit di avvio (se non lo hai già fatto), e cambia la directory nella tua copia locale:
git clone https://github.com/digitalocean/Kubernetes-Starter-Kit-Developers.git
cd Kubernetes-Starter-Kit-Developers
  1. Successivamente, aggiungi il repository Helm di Argo CD:
helm repo add argo https://argoproj.github.io/argo-helm
helm repo update argo
  1. Ora, cerca nel repository Helm di argo i grafici disponibili da installare:
helm search repo argo

Il risultato assomiglia a questo:

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. Quindi, apri e ispeziona il file di valori Helm di Argo CD fornito nel repository del kit di avvio utilizzando un editor a tua scelta (preferibilmente con supporto per il lint YAML). Ad esempio, puoi usare VS Code:
code 14-continuous-delivery-using-gitops/assets/manifests/argocd/argocd-values-v4.9.4.yaml
  1. Infine, distribuisci Argo CD nel tuo cluster DOKS:
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 \

Nota:
Viene utilizzata una versione specifica per il grafico di Helm. In questo caso, viene selezionata la versione 4.9.4, che corrisponde alla versione 2.4.0 dell’applicazione. È una buona pratica, in generale, bloccarsi su una versione specifica. Questo aiuta ad avere risultati prevedibili e consente il controllo della versione tramite Git.

helm ls -n argocd

Ora, controlla se il rilascio di Helm è stato eseguito con successo:

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

L’output assomiglia a (STATUS il valore della colonna dovrebbe essere impostato su deployed):

kubectl get deployments -n argocd

Infine, verifica lo stato del rilascio dell’applicazione Argo CD:

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

L’output assomiglia a (controlla la colonna READY – tutti i Pods devono essere in esecuzione):

Il server Argo CD deve avere un valore minimo di replicaset di 2 per la modalità HA. Se, per qualche motivo, alcuni rilasci non sono sani, controllare gli eventi di Kubernetes e i log per i Pods del componente interessato.

È anche possibile trovare ulteriori informazioni sulla chart di Helm di Argo CD accedendo al repository mantenuto dalla community.

Successivamente, imparerai come accedere ed esplorare le principali funzionalità dell’interfaccia utente grafica fornita da Argo CD.

Accesso ed Esplorazione dell’Interfaccia Web di Argo CD

Una delle caratteristiche interessanti che Argo CD ha da offrire è l’interfaccia web, utilizzata per eseguire varie attività amministrative e visualizzare lo stato del deployment dell’applicazione. Puoi creare applicazioni utilizzando l’interfaccia utente grafica e interagire con Argo CD in vari modi. Un’altra funzionalità importante è la capacità di ispezionare lo stato di ciascuna applicazione e accedere agli eventi di Kubernetes, così come ai log delle tue applicazioni. Inoltre, Argo CD fornisce una rappresentazione visiva di tutti gli oggetti Kubernetes (replicasets, pod, ecc.) utilizzati da ciascun deployment dell’applicazione.

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

L’interfaccia web può essere accessa tramite il port-forwarding del servizio Kubernetes argocd-server. Si prega di eseguire il comando seguente in un terminale shell:

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

Ora, apri un browser web e vai su localhost:8080 (ignora per ora i certificati TLS non validi). Ti verrà mostrata la pagina di accesso di Argo CD. Il nome utente amministratore predefinito è admin, e la password viene generata casualmente al momento dell’installazione. Puoi recuperarla eseguendo il comando seguente:

Successivamente, verrai reindirizzato alla pagina del dashboard delle applicazioni. Da qui, puoi visualizzare, creare o gestire applicazioni tramite l’interfaccia utente (è disponibile anche un editor YAML), nonché eseguire operazioni di sincronizzazione o aggiornamento:

Se fai clic su una qualsiasi delle applicazioni, verrà mostrata anche una rappresentazione visiva di tutti gli oggetti coinvolti:

Nella sezione successiva, puoi gestire i tuoi progetti di applicazioni, repository e cluster:

Infine, la sezione delle informazioni utente mostra gli utenti disponibili e consente di aggiornare la password dell’amministratore:

È possibile giocare e esplorare ogni sezione e sottosezione in dettaglio per vedere tutte le funzionalità disponibili. Successivamente, imparerai come utilizzare il corrispettivo CLI, chiamato argocd.

Conoscere il CLI di Argo CD

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 consente di utilizzare lo stesso set di funzionalità sia tramite l’interfaccia web che tramite il CLI. Per utilizzare il CLI argocd, è necessario aprire una finestra di shell separata e digitare semplicemente argocd senza argomenti. Per impostazione predefinita, visualizzerà i comandi e le opzioni disponibili:

argocd app --help

Per qualsiasi comando o sottocomando, è possibile richiamare la pagina di aiuto corrispondente utilizzando il seguente pattern: argocd <comando/sottocomando> --help. Ad esempio, se si desidera verificare quali opzioni sono disponibili per il comando app:

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

Examples:
  Il risultato è simile a:
  argocd app list
  
  # Elencare tutte le applicazioni.
  argocd app get my-app
...

# Ottenere i dettagli di un’applicazione

Si prega di procedere e esplorare anche gli altri comandi/sottocomandi per vedere tutte le opzioni disponibili. Successivamente, imparerai come avviare la tua prima applicazione Argo CD, che distribuirà automaticamente tutti i componenti del kit di avvio.

Avvio delle Applicazioni Argo CD

In una nuova installazione, Argo CD non sa da dove sincronizzare le tue applicazioni, né quali repository Git sono disponibili per l’estrazione dei manifesti dell’applicazione. Quindi, il primo passo è eseguire un’operazione chiamata bootstrap, che si effettua una sola volta. Puoi eseguire tutte le operazioni presentate in questa sezione utilizzando sia la CLI argocd che l’interfaccia utente grafica.

Esistono diversi modi per avviare il tuo cluster (ad esempio, tramite script), ma di solito gli utenti di Argo CD fanno uso del modello app of apps. Significa che inizierai creando un’applicazione principale utilizzando la CLI good (o l’interfaccia web), che a sua volta farà riferimento e avvierà il resto delle applicazioni nel tuo cluster Kubernetes.

Preparazione della Struttura del Repository Git

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

Prima devi preparare il layout del tuo repository Git per utilizzare una struttura coerente. Nell’esempio seguente, creerai una struttura di layout del repository Git simile a:

  1. Apri una terminale e segui i passaggi seguenti per creare il layout per il tuo repository Git:
git clone <YOUR_ARGOCD_GIT_REPOSITORY_ADDRESS>
  1. Prima di tutto, clona il repository git utilizzato per testare Argo CD (assicurati di sostituire i segnaposto <> di conseguenza):
cd <YOUR_GIT_REPO_LOCAL_COPY_DIRECTORY>
mkdir -p clusters/dev/helm
  1. Successivamente, cambia la directory alla tua copia locale e crea la struttura delle directory (assicurati di sostituire i segnaposto <> di conseguenza):
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. Copia i manifest delle applicazioni forniti per ciascun componente nel repository Starter Kit (puoi anche dare un’occhiata e vedere come è strutturato ciascun manifest):

Infine, esegui il commit delle modifiche e pusha all’origine.

Successivamente, creerai il deployment dell’applicazione principale e permetterai ad Argo CD di sincronizzare automaticamente tutte le applicazioni dello Starter Kit nel tuo cluster DOKS.

Utilizzando il Pattern App of Apps tramite la CLI di Argo CD

In questa sezione, imparerai come utilizzare la CLI di argocd per creare e fare uso del pattern app of apps per distribuire tutti i componenti dello Starter Kit nel tuo cluster DOKS. La seguente immagine illustra il concetto principale:

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

Prima di tutto, devi port-forwardare il server principale di Argo CD sulla tua macchina locale in una finestra del terminale separata:

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

Successivamente, è necessario l’accesso al server API di Argo CD affinché funzioni l’interfaccia della riga di comando argocd. Utilizzando un’altra finestra di terminale, è necessario autenticare il client argocd con l’istanza del server Argo CD:

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

L’output sarà simile a:

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

Successivamente, eseguire il comando seguente per creare l’applicazione principale starter-kit-apps (assicurarsi di sostituire i segnaposto <> di conseguenza):

  • –dest-namespace argocd \
  • –dest-server https://kubernetes.default.svc \
  • Il comando sopra creerà una nuova applicazione Argo CD chiamata starter-kit-apps nello spazio dei nomi argocd, configurata per:

Puntare allo stesso cluster Kubernetes dove è distribuito Argo CD, poiché --dest-server è impostato su https://kubernetes.default.svc.

argocd app sync starter-kit-apps

Utilizzare il repository GitHub impostato dall’argomento --repo per sincronizzare il tuo cluster.

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

Scansionare ed applicare tutti i manifesti dell’applicazione trovati nella directory clusters/dev/helm (argomento --path).

Successivamente, è necessario sincronizzare l’applicazione starter-kit-apps (ricorda che Argo CD non sincronizza nulla per impostazione predefinita a meno che non venga specificato):

argocd app list

L’output sarà simile a:

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  ...

Dopo che il comando sopra è stato completato, dovresti vedere una nuova applicazione presente nella dashboard principale del tuo server Argo CD. Si prega di aprire un browser web e navigare su http://localhost:8080. Quindi selezionare la scheda Applicazioni, e fare clic sulla scheda starter-kit-apps (notare il modello app delle app guardando il grafico di composizione):

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

È anche possibile ispezionare le nuove applicazioni tramite la CLI:

L’output appare simile a:

argocd app list

L’applicazione genitore starter-kit-apps apparirà come sincronizzata ma le app figlio saranno fuori sincronia. Successivamente, è possibile sincronizzare tutto utilizzando l’interfaccia web o tramite la 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  ...

L’operazione di sincronizzazione potrebbe richiedere del tempo per completarsi (anche fino a 5-10 minuti), a seconda della complessità e del numero di oggetti Kubernetes di tutte le applicazioni in fase di distribuzione.

Dopo un po’, si prega di elencare nuovamente tutte le applicazioni:

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
  • L’output appare simile a (notare che tutte le applicazioni sono ora sincronizzate):
argocd app get velero

Il rilascio dell’applicazione Velero fallirà e verrà lasciato appositamente nello stato SyncError come esercizio per il lettore per familiarizzare e imparare come diagnosticare i problemi dell’applicazione in Argo CD. Consultare la sezione Indizi di seguito per vedere come diagnosticare i problemi dell’applicazione Argo CD.
L’avviamento dell’applicazione principale è un’operazione unica. Alle modifiche successive di Git per ciascuna applicazione, Argo CD rileverà lo scostamento e applicherà le modifiche necessarie. Argo CD utilizza un meccanismo di polling per default per rilevare le modifiche nel repository Git. L’intervallo di aggiornamento predefinito è impostato su 3 minuti. Invece di fare affidamento su un meccanismo di polling, è anche possibile sfruttare la potenza dei webhook di Git. Si prega di visitare il sito web della documentazione ufficiale per apprendere come creare e configurare Argo CD per utilizzare i webhook di Git. 

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]
...

Indizi: Se si desidera, è possibile configurare l’applicazione principale per essere sincronizzata automaticamente (e abilitare anche l’autoguarigione e il pruning automatico), è possibile utilizzare il seguente comando (non dimenticare di sostituire i segnaposto <> di conseguenza):

–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 caso di eventuali fallimenti di sincronizzazione, puoi sempre ispezionare gli eventi di Kubernetes per l’applicazione in questione (tramite argocd app get <application_name>):

L’output è simile a:

  • Successivamente, imparerai come utilizzare il modello di app di app e eseguire gli stessi passaggi tramite l’interfaccia utente grafica di Argo CD.
  • Utilizzo del Modello di App di App tramite l’Interfaccia Web di Argo CD
  • In questa sezione, imparerai come utilizzare l’interfaccia web di Argo CD per creare e utilizzare il modello di app di app per distribuire tutti i componenti Starter Kit nel tuo cluster DOKS. L’immagine seguente illustra il concetto principale:
  • Come mostra il diagramma sopra, l’avvio di una nuova applicazione tramite l’interfaccia web è molto simile alla controparte CLI. L’unica differenza è che navigherai tra pannelli/finestre diversi e utilizzerai operazioni di puntamento e clic. Dietro le quinte, Argo CD creerà i CRD dell’applicazione necessari e applicherà le modifiche al tuo cluster Kubernetes.
  • Per prima cosa, apri un browser web e accedi alla console web di Argo CD. Il nome utente predefinito è admin, e la password predefinita è ottenuta tramite:
  • Una volta effettuato l’accesso, verrai reindirizzato alla pagina del dashboard delle applicazioni (in una nuova installazione, il dashboard è vuoto). Successivamente, fai clic sul pulsante Crea Applicazione. Viene visualizzato un nuovo pannello che chiede i dettagli dell’applicazione:
  • Per favore compila ogni campo correttamente:

Nome Applicazione: Il nuovo nome dell’applicazione (ad esempio, starter-kit-apps).

Progetto: Il nome del progetto a cui appartiene questa applicazione (quando si utilizza Argo CD per la prima volta, è possibile utilizzare default).

Politica di Sincronizzazione e Opzioni di Sincronizzazione: Configura la politica di sincronizzazione e le opzioni (ad esempio, Manuale, Automatico, numero di tentativi, intervallo tra i tentativi, ecc).

URL del Repository di Origine: L’indirizzo URL del tuo repository GitHub – ad esempio, https://github.com/<IL_TUO_NOME_UTENTE_GITHUB>/<NOME_REPO_ARGOCD_GITHUB>.git.

Percorso di Origine: Percorso della directory del repository GitHub dove sono memorizzati i manifesti dell’applicazione (ad esempio, clusters/dev/helm).

URL del Cluster di Destinazione: Cluster Kubernetes di destinazione da sincronizzare con il tuo repository GitHub (ad esempio, https://kubernetes.default.svc per il cluster locale dove è distribuito Argo CD).

Namespace di Destinazione: Namespace del cluster Kubernetes di destinazione da utilizzare per le applicazioni Argo CD (argocd, di solito).

Dopo aver compilato tutti i dettagli dell’applicazione, fai clic sul pulsante Crea in alto. Comparirà una nuova tessera dell’applicazione sulla pagina del dashboard:

Se si fa clic sull’icona dell’applicazione, è possibile osservare il modello di app delle app, guardando il grafico di composizione:

Se si guarda l’immagine sopra, si noterà che tutte le applicazioni sono contrassegnate come OutOfSync. Il passo successivo è avviare un’operazione di sincronizzazione sull’applicazione genitore. Quindi, tutte le applicazioni figlio verranno sincronizzate anche. Procedere premendo il pulsante Sync sull’icona dell’applicazione genitore. Compare un nuovo pannello sul lato destro (notare che tutte le app figlio sono selezionate in basso):

Lasciare i valori predefiniti, quindi premere il pulsante Synchronize in alto e osservare come Argo CD propaga l’operazione di sincronizzazione a tutte le applicazioni:

Il rilascio dell’applicazione Velero fallirà e verrà lasciato intenzionalmente nello stato SyncError come esercizio per il lettore per familiarizzare e imparare come diagnosticare i problemi delle applicazioni in Argo CD. Consultare la sezione Indizi di seguito per vedere come diagnosticare i problemi delle applicazioni Argo CD.

Se tutto va bene, tutte le applicazioni dovrebbero avere un bordo verde e lo stato dovrebbe essere Salutare e Sincronizzato. Il processo di bootstrap è un’operazione unica. Con le modifiche successive di Git per ogni applicazione, Argo CD rileverà lo scostamento e applicherà le modifiche richieste. Argo CD utilizza un meccanismo di polling per default per rilevare le modifiche nel tuo repository Git. L’intervallo di aggiornamento predefinito è impostato su 3 minuti. Invece di affidarsi a un meccanismo di polling, puoi anche sfruttare la potenza dei webhook di Git. Si prega di visitare il sito della documentazione ufficiale per apprendere come creare e configurare Argo CD per utilizzare i webhook di Git.

Suggerimenti: Se desiderato, puoi configurare l’applicazione principale per essere sincronizzata automaticamente impostando il valore del campo POLICY DI SINCRONIZZAZIONE su Automatico. Per abilitare l’autoguarigione e l’eliminazione automatica, seleziona le caselle di controllo PRUNE RESOURCES e SELF HEAL:

In caso di errori di sincronizzazione, puoi sempre ispezionare gli eventi di Kubernetes per l’applicazione in questione. Utilizzando l’interfaccia web, puoi navigare nella casella dell’applicazione interessata:

Quindi, clicca sul link del messaggio Errore di sincronizzazione contrassegnato in rosso, dalla sezione ULTIMO RISULTATO DELLA SINCRONIZZAZIONE nell’intestazione della pagina dell’applicazione. Si aprirà un nuovo pannello, mostrando informazioni utili su perché l’operazione di sincronizzazione è fallita:

Application Sets è un’altra potente funzionalità offerta da Argo CD. Il Controller di ApplicationSet è un sottoprogetto di Argo CD, che aggiunge automazione delle applicazioni tramite definizioni templatizzate. Questa funzionalità ti aiuta ad evitare ripetizioni nei manifesti delle tue applicazioni (utilizzando il principio DRY).

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

Il Controller di ApplicationSet è installato insieme ad Argo CD (nello stesso namespace) e genera automaticamente Applicazioni Argo CD in base ai contenuti di un nuovo Custom Resource (CR) di ApplicationSet.

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

Nota:
A partire dalla versione 2.3.x di Argo CD, non è necessario installare il Controller di ApplicationSet separatamente perché fa parte dell’installazione principale di Argo CD. Starter Kit utilizza version >= 2.3.1, quindi non è necessario modificare nulla.

L’idea principale di un ApplicationSet si basa sull’avere una lista di valori che agiscono come un generatore, e un modello che viene popolato dai valori della lista di input. Per ogni elemento della lista, viene generato un nuovo modello di applicazione in sequenza. Fondamentalmente, si definisce un CRD di ApplicationSet e poi si lascia che generi per voi tanti CRD di Applicazione ArgoCD, quanti ne volete, basati sui valori di input. Così, invece di creare e gestire più manifesti di Applicazione, si gestisce tutto tramite un unico manifesto – l’ApplicationSet.

Questo concetto semplifica anche la gestione di setup multi-cluster e multi-ambiente utilizzando modelli di applicazione parametrizzati. Gli insiemi di applicazioni includono anche altri generatori, oltre ai Generatori di Lista:

Generatore Cluster: Utilizza i cluster definiti da Argo CD per i modelli di applicazione.

argocd app delete starter-kit-apps

Generatore Git: Utilizza i file/cartelle di un repository Git per i modelli di applicazione.

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

Un tipico CRD di ApplicationSet che utilizza un Generatore di Lista, appare come segue:

Applicando l’ApplicationSet sopra al vostro cluster Kubernetes, si otterranno tre applicazioni Argo CD. Ad esempio, l’applicazione per l’ambiente dev viene generata come mostrato di seguito:

I motori di template sono molto potenti per natura e offrono molte possibilità. Si prega di visitare il sito web principale della documentazione di ApplicationSet per saperne di più su questa funzionalità.

Disinstallazione delle Applicazioni Argo CD

La disinstallazione (o eliminazione) delle applicazioni gestite da Argo CD avviene eliminando il manifesto corrispondente dalla sorgente del repository Git. Nel caso delle applicazioni create utilizzando il modello di app di app, è necessario eliminare solo l’applicazione genitore (tramite CLI o interfaccia web). Quindi, tutte le applicazioni figlio saranno eliminate come parte del processo.

  • Come eliminare l’applicazione genitore starter-kit-apps (incluso le app figlio) utilizzando la CLI argocd:
  • Se si desidera garantire che le app figlio e tutte le loro risorse vengano eliminate quando viene eliminata l’app genitore, assicurarsi di aggiungere il finalizzatore appropriato alla definizione dell'applicazione:

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