15 min de lecture

Objectifs d'apprentissage

À la fin de ce module, vous serez en mesure de:

  • Installer ArgoCD sur Managed Kubernetes et déployer TaskBoard depuis Git avec un `Application` qui assure une synchronisation automatique et une auto-réparation
  • Diviser TaskBoard en un dépôt d'infrastructure (Terraform, application à la fusion) et un dépôt d'application (manifestes, synchronisation ArgoCD)
  • Promouvoir les étiquettes d'images de l'environnement de développement à celui de préproduction, puis à celui de production, à l'aide de superpositions Kustomize et de demandes de fusion
  • Créer et détruire automatiquement des environnements de branche depuis l'intégration continue afin de garder les coûts sous contrôle
  • Tracer une ligne claire de responsabilité entre Terraform et ArgoCD afin que les deux outils ne se disputent jamais le même objet

Unité 5.3 : GitOps et opérations de déploiement

Introduction

Le pipeline de TaskBoard issu de l'unité 3.3 pousse les modifications dans le cluster : CI détient un kubeconfig et exécute kubectl set image. Cela fonctionne, mais l'état du cluster est celui laissé par le dernier job, une modification manuelle via kubectl edit passe inaperçue, et chaque pipeline a besoin d'identifiants d'accès au cluster.

GitOps inverse cette logique. Git détient l'état souhaité de l'application, et un agent à l'intérieur du cluster le récupère et le réconcilie en continu. Si quelqu'un modifie un Deployment manuellement, l'agent le rétablit. Si vous souhaitez effectuer un retour arrière, vous annulez un commit. Dans cette unité, vous installez ArgoCD sur MKS, le connectez aux manifests de TaskBoard, structurez les dépôts, promouvez les releases entre les environnements et démontez automatiquement les environnements de branche. Vous décidez également quel outil possède quel objet, afin que Terraform et ArgoCD n'annulent pas le travail de l'autre.

1. Principes GitOps en pratique

1.1 Push vs Pull

Aspect Push (Unité 3.3) Pull (GitOps)
Qui modifie le cluster Tâche CI avec un kubeconfig Agent à l'intérieur du cluster
Source de vérité Dernière tâche réussie Branche ou étiquette Git
Modification manuelle dans le cluster Persiste jusqu'au déploiement suivant Détectée et annulée
Rollback kubectl rollout undo git revert
Identifiants du cluster dans CI Requis Non requis

Le modèle pull simplifie également l'accès à l'API Kubernetes. Si vous l'avez restreinte avec api_subnet_allow_list (Unité 3.2), chaque exécuteur CI externe doit figurer dans cette liste. ArgoCD s'exécute à l'intérieur du cluster et communique avec le serveur d'API via https://kubernetes.default.svc, et le trafic interne au cluster n'est pas affecté par la liste d'autorisation.

1.2 Détection de dérive

La dérive est toute différence entre Git et l'état en cours d'exécution. Vous détectez déjà la dérive d'infrastructure avec terraform plan -detailed-exitcode (Unité 5.2). ArgoCD fait de même pour les manifests :

argocd app diff taskboard-dev        # exit code 1 when live state differs from Git
argocd app get taskboard-dev -o json | jq -r '.status.sync.status, .status.health.status'

Synced et Healthy indiquent que le cluster correspond à Git et que chaque ressource passe ses contrôles d'intégrité, y compris les sondes de disponibilité de l'unité 5.1.

2. ArgoCD sur MKS

2.1 Installation

kubectl create namespace argocd
kubectl apply -n argocd \
  -f "https://raw.githubusercontent.com/argoproj/argo-cd/${ARGOCD_VERSION}/manifests/install.yaml"
kubectl -n argocd rollout status deploy/argocd-server
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath='{.data.password}' | base64 -d

Épingler ARGOCD_VERSION à une étiquette de version, exactement comme vous épinglez le fournisseur Terraform, et effectuer la mise à niveau par le biais d'une demande d'extraction (pull request). Accéder à l'interface utilisateur avec kubectl -n argocd port-forward svc/argocd-server 8080:443. Ne pas l'exposer avec type: LoadBalancer : sur MKS, ce Service reçoit une adresse IP statique sur un nœud, et non un équilibreur de charge (Unité 3.2). Si l'équipe a besoin d'un accès permanent, le router via le contrôleur d'entrée derrière l'ALB.

2.2 Connexion du dépôt d'application

apiVersion: v1
kind: Secret
metadata:
  name: taskboard-deploy-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://git.example.com/taskboard/deploy.git
  username: argocd
  password: <read-only access token>

Créez ce Secret à partir de votre coffre de secrets, comme dans l'unité 5.2, et non à partir d'un fichier dans Git. ArgoCD n'a besoin que d'un accès en lecture ; il n'effectue jamais de poussée.

2.3 La CRD Application

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: taskboard-dev
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://git.example.com/taskboard/deploy.git
    targetRevision: main
    path: overlays/dev
  destination:
    server: https://kubernetes.default.svc
    namespace: taskboard
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

automated synchronise chaque nouvel engagement sur main. prune supprime les objets que vous avez retirés de Git, et selfHeal annule les modifications manuelles dans le cluster. ArgoCD applique les manifestes, mais ne fournit pas les identifiants du registre : les pods ont toujours besoin de l'entrée imagePullSecrets et du Secret de récupération de l'unité 3.2, sinon ils restent dans l'état ImagePullBackOff.

3. Topologie des dépôts et promotion

3.1 Deux dépôts, deux responsables

taskboard-infra/                 taskboard-deploy/
  modules/                         base/
    mks-cluster/                     api-deployment.yaml
    postgres/                        web-deployment.yaml
  envs/                              worker-deployment.yaml
    dev/main.tf                      kustomization.yaml
    staging/main.tf                overlays/
    prod/main.tf                     dev/kustomization.yaml
  .github/workflows/infra.yml        staging/kustomization.yaml
                                     prod/kustomization.yaml

taskboard-infra est le dépôt d'infrastructure issu de l'unité 3.3 : planification sur la demande d'extraction, application sur la fusion, avec IONOS_TOKEN dans ses secrets. taskboard-deploy ne contient que des manifestes Kubernetes et ne comporte aucune information d'authentification cloud. Le code source de l'application reste dans un troisième dépôt dont la CI construit et pousse les images.

3.2 Superpositions et étiquettes d'image

La superposition de production, overlays/prod/kustomization.yaml :

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namespace: taskboard
resources:
  - ../../base
images:
  - name: taskboard-api
    newName: <registry-hostname>/taskboard/api
    newTag: 3f9c2a1b7d04
replicas:
  - name: taskboard-api
    count: 3

Les manifests de base référencent l'image sous la forme taskboard-api, et chaque superposition fixe l'étiquette Git SHA de l'unité 3.1. La promotion est un commit qui copie une étiquette testée d'une superposition à la suivante.

3.3 Promotion depuis la CI

La CI de l'application n'interagit plus avec le cluster. Après avoir poussé l'image, elle ouvre une demande d'extraction (pull request) sur taskboard-deploy :

SHA="${GITHUB_SHA::12}"
git clone "https://x-access-token:${DEPLOY_REPO_TOKEN}@git.example.com/taskboard/deploy.git"
cd deploy/overlays/dev
kustomize edit set image "taskboard-api=${CR_HOST}/taskboard/api:${SHA}"
git checkout -b "promote-dev-${SHA}"
git commit -am "dev: taskboard-api ${SHA}"
git push origin "promote-dev-${SHA}"
gh pr create --title "dev: taskboard-api ${SHA}" --body "Automated promotion" --base main

En environnement de développement, vous pouvez fusionner automatiquement dès que les vérifications sont passées. Pour les environnements de préproduction et de production, exigez une revue, afin que l'historique de la pull request constitue votre journal de publication. Un retour arrière est git revert de la commit de promotion ; ArgoCD resynchronise l'étiquette précédente.

4. Environnements de branche et démontage automatisé

4.1 Un état par branche

Le flux de travail .github/workflows/branch-env.yml dans taskboard-infra :

on:
  pull_request:
    types: [opened, synchronize, closed]
jobs:
  env:
    runs-on: ubuntu-latest
    concurrency: branch-${{ github.head_ref }}
    defaults:
      run:
        working-directory: envs/branch
    env:
      IONOS_TOKEN: ${{ secrets.IONOS_TOKEN }}
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
      TF_VAR_branch: ${{ github.head_ref }}
    steps:
      - uses: actions/checkout@v4
      - uses: hashicorp/setup-terraform@v3
      - run: terraform init -input=false -backend-config="key=branches/${TF_VAR_branch}/terraform.tfstate"
      - if: github.event.action != 'closed'
        run: terraform apply -input=false -auto-approve
      - if: github.event.action == 'closed'
        run: terraform destroy -input=false -auto-approve

Chaque demande d'extraction (pull request) dispose de son propre objet d'état dans le bucket d'état, de sorte qu'un environnement de branche ne peut jamais modifier l'état de dev ou de production. Nommez chaque ressource en fonction de var.branch et gardez la pile de branche légère : un bucket Object Storage, une base de données et un espace de noms sur le cluster de développement partagé, et non un cluster dédié.

4.2 Un démantèlement qui s'exécute réellement

Les ressources génèrent des frais dès leur création, et un environnement de branche oublié entraîne des coûts chaque heure. Le filet de sécurité nocturne détruit les états des branches dont la demande d'extraction est fermée :

for key in $(aws s3 ls --endpoint-url "$EP" "s3://taskboard-tfstate-7f3a/branches/" | awk '{print $2}' | tr -d /); do
  state=$(gh pr list --head "$key" --state open --json number --jq 'length')
  if [ "$state" = "0" ]; then
    terraform init -reconfigure -input=false -backend-config="key=branches/${key}/terraform.tfstate"
    TF_VAR_branch="$key" terraform destroy -input=false -auto-approve
  fi
done

C'est l'une des trois mesures de protection. Premièrement, l'événement closed détruit la pile lorsque la demande d'extraction est fusionnée ou fermée. Deuxièmement, la tâche nocturne détecte les exécutions en échec ; elle suppose des noms de branche sans /, il est donc recommandé d'utiliser un slug si les vôtres en contiennent. Troisièmement, étiquetez les ressources de branche avec le nom de la branche et une date de création lorsque la ressource le permet, afin qu'une revue du contrat révèle les éléments en retard. Si un cluster Managed Kubernetes fait partie d'une pile de branche, ses pools de nœuds doivent être supprimés avant le cluster ; Terraform ordonne cette opération grâce à la dépendance entre ionoscloud_k8s_node_pool et ionoscloud_k8s_cluster.

Le côté ArgoCD effectue également un nettoyage. Avec prune: true et un ApplicationSet qui génère un Application par demande d'extraction ouverte, la fermeture de la demande d'extraction supprime le Application généré ainsi que les ressources de son espace de noms.

5. Terraform et ArgoCD : qui détient quoi

5.1 La ligne de séparation des responsabilités

Objet Propriétaire Raison
Centre de données, LAN, NSG, ALB, groupes de cibles Terraform Ressources IONOS CLOUD, nécessitent IONOS_TOKEN
Cluster MKS, pools de nœuds, kubeconfig Terraform Ressources IONOS CLOUD
DBaaS, In-Memory DB, Kafka, buckets Object Storage Terraform Ressources IONOS CLOUD
Deployments, Services, Ingress, ConfigMaps, NetworkPolicies ArgoCD Objets Kubernetes, versionnés avec l'application
Secrets contenant des identifiants External Secrets Operator, synchronisé par ArgoCD Les valeurs restent dans le magasin de secrets
ArgoCD lui-même et ses objets Application Initialisation unique, puis ArgoCD Évite une boucle de dépendance circulaire

Un objet, un propriétaire. Le pont entre les deux mondes est constitué de données, et non de ressources partagées : les sorties Terraform telles que pg_host sont envoyées au magasin de secrets, et les manifests référencent le Secret Kubernetes résultant (Unité 5.2).

5.2 Éviter les boucles de conflit

Une boucle de conflit se produit lorsque deux contrôleurs modifient en permanence le même champ. Pour permettre à un HorizontalPodAutoscaler de détenir le nombre de réplicas, ajoutez ceci à Application :

spec:
  ignoreDifferences:
    - group: apps
      kind: Deployment
      name: taskboard-api
      jsonPointers:
        - /spec/replicas

Cas typiques de TaskBoard :

  • HPA vs Git : Si un HPA met à l'échelle taskboard-api, supprimez replicas de la superposition ou ignorez le champ comme indiqué, sinon selfHeal réinitialise le comptage à chaque synchronisation.
  • Autoscaler vs Terraform : Avec auto_scaling sur un pool de nœuds, conservez lifecycle { ignore_changes = [node_count] } de l'unité 3.2, sinon chaque application réinitialise le pool.
  • CI vs ArgoCD : Supprimez kubectl set image du flux de travail de l'unité 3.3 lorsque ArgoCD prend le relais. Avec selfHeal, ArgoCD le révoque en quelques minutes, et le déploiement semble revenir en arrière tout seul.
  • Terraform vs MKS : Les serveurs, les NIC et les IP que Managed Kubernetes crée dans votre centre de données sont affichés en lecture seule dans le DCD. N'importe jamais ces éléments dans Terraform ; gérez-les via le pool de nœuds.

Fiche de référence rapide de l'API

Points de terminaison API clés pour le sujet de cette unité :

Méthode Point de terminaison Description
GET /k8s/{k8sClusterId}/kubeconfig Télécharger le kubeconfig pour initialiser ArgoCD
GET /k8s/{k8sClusterId}/nodepools Vérifier les pools de nœuds avant le démantèlement d'une branche
DELETE /k8s/{k8sClusterId}/nodepools/{nodepoolId} Supprimer un pool de nœuds (avant son cluster)
DELETE /k8s/{k8sClusterId} Supprimer un cluster sans pools de nœuds
GET /requests/{requestId}/status Interroger une suppression asynchrone

URL de base : https://api.ionos.com/cloudapi/v6 Authentification : Authorization: Bearer <token>

Atelier de code

Objectif : Configurer la synchronisation automatique ArgoCD pour les manifests de TaskBoard, pousser une modification de manifest et observer la réconciliation, annuler une modification manuelle grâce à l'auto-réparation, et démanteler un environnement de branche.

Prérequis :

  • Le cluster MKS et l'espace de noms TaskBoard de l'Unité 3.2, avec le kubeconfig administrateur
  • Un dépôt taskboard-deploy avec base/ et overlays/dev/ comme dans la section 3
  • L'interface en ligne de commande argocd, kustomize, gh et Terraform avec le bucket d'état de l'Unité 2.4

Étape 1 : Installer ArgoCD

export ARGOCD_VERSION="<release tag>"
kubectl create namespace argocd
kubectl apply -n argocd -f "https://raw.githubusercontent.com/argoproj/argo-cd/${ARGOCD_VERSION}/manifests/install.yaml"
kubectl -n argocd rollout status deploy/argocd-server

Sortie attendue :

deployment "argocd-server" successfully rolled out

Étape 2 : Connexion

kubectl -n argocd port-forward svc/argocd-server 8080:443 &
argocd login localhost:8080 --username admin --insecure \
  --password "$(kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath='{.data.password}' | base64 -d)"

Sortie attendue :

'admin:login' logged in successfully

Étape 3 : Enregistrer le dépôt et l'application

Appliquez le Secret du dépôt (section 2.2) et le Application (section 2.3).

kubectl apply -f argocd/repo-secret.yaml -f argocd/taskboard-dev.yaml
argocd app wait taskboard-dev --health --timeout 300

Sortie attendue :

Name:     argocd/taskboard-dev
Sync Status:   Synced to main (<sha>)
Health Status: Healthy

Étape 4 : Pousser une modification de manifeste

cd taskboard-deploy/overlays/dev
kustomize edit set image "taskboard-api=${CR_HOST}/taskboard/api:<new-sha>"
git commit -am "dev: taskboard-api <new-sha>" && git push
argocd app get taskboard-dev --refresh | grep -E "Sync Status|Health"

Sortie attendue :

Sync Status:   Synced to main (<new commit>)
Health Status: Healthy

Étape 5 : Observer l'auto-réparation

kubectl -n taskboard scale deploy/taskboard-web --replicas=0
sleep 30
kubectl -n taskboard get deploy taskboard-web

Sortie attendue :

NAME            READY   UP-TO-DATE   AVAILABLE
taskboard-web   2/2     2            2

Étape 6 : Créer et détruire un environnement de branche

Ouvrez une pull request dans taskboard-infra avec le workflow de la section 4.1, attendez l'application, puis fermez la pull request.

gh pr close <number>
gh run watch

Sortie attendue :

✓ env
  ✓ terraform destroy -input=false -auto-approve
Destroy complete! Resources: <n> destroyed.

Liste de contrôle de validation :

  • [ ] taskboard-dev est Synced et Healthy
  • [ ] Un commit vers overlays/dev modifie l'image en cours d'exécution sans aucun accès CI au cluster
  • [ ] Une réduction manuelle est annulée par la guérison automatique
  • [ ] La fermeture de la demande d'extraction détruit la pile de branches et ne laisse aucun état derrière, à l'exception de l'objet d'état vide

Nettoyage :

argocd app delete taskboard-dev --yes
kubectl delete namespace argocd
kill %1

Erreurs courantes

Erreurs de développement à éviter concernant le sujet de cette unité :

  1. Le déploiement qui revient en arrière tout seul

    • Problème : La CI déploie une nouvelle image, et quelques minutes plus tard, l'ancienne image est à nouveau en cours d'exécution.
    • Pourquoi cela arrive : L'étape kubectl set image de l'ancienne version est toujours présente dans le pipeline, et le selfHeal d'ArgoCD restaure l'étiquette depuis Git.
    • Correction : Modifier les images uniquement via des commits vers le superposition (section 3.3) et supprimer les identifiants du cluster de la CI de l'application.
  2. Les environnements de branche que personne ne détruit

    • Problème : La facture augmente chaque mois, et le contrat contient des buckets et des bases de données nommés d'après des branches fusionnées depuis longtemps.
    • Pourquoi cela arrive : La tâche closed a échoué une fois, ou s'est exécutée avant que terraform init ne pointe vers la clé d'état de la branche.
    • Correction : Utiliser une clé d'état par branche, exécuter la destruction sur closed, et ajouter le filet de sécurité nocturne de la section 4.2.
  3. Terraform et ArgoCD gérant le même objet

    • Problème : Chaque terraform apply modifie un Deployment, et chaque synchronisation ArgoCD le remet en état.
    • Pourquoi cela arrive : Le Deployment a été créé avec le fournisseur Terraform Kubernetes et est également présent dans le dépôt de déploiement.
    • Correction : Choisir un propriétaire unique par objet (section 5.1) ; supprimer la ressource de l'état Terraform avec terraform state rm et laisser ArgoCD en être le propriétaire.

Résumé

Vous pouvez désormais exploiter TaskBoard de manière déclarative. Terraform gère l'ensemble des ressources IONOS CLOUD et applique les changements lors de la fusion ; ArgoCD gère l'ensemble des objets Kubernetes et les synchronise depuis Git avec élagage et auto-réparation. Les déploiements passent d'un environnement à l'autre sous forme de commits examinés vers les superpositions Kustomize, et les environnements de branche sont créés et détruits par le cycle de vie de la demande d'extraction.

Points clés :

  • Git est la source de vérité ; ArgoCD récupère et réconcilie, de sorte que l'intégration continue n'a pas besoin d'identifiants de cluster
  • ArgoCD utilise kubernetes.default.svc, de sorte que la liste d'autorisation de l'API ne l'empêche pas
  • Promouvoir en commitant les étiquettes d'image vers les superpositions ; revenir en arrière avec git revert
  • Une clé d'état par branche, destruction à la fermeture de la demande d'extraction, plus un filet de sécurité nocturne
  • Un propriétaire par objet : Terraform pour les ressources IONOS CLOUD, ArgoCD pour les objets Kubernetes

Terminologie importante :

  • GitOps : Exploiter un système en déclarant son état souhaité dans Git et en le réconciliant automatiquement
  • Application : La ressource personnalisée ArgoCD qui associe un chemin Git à un espace de noms de cluster
  • Auto-réparation : Annulation automatique par ArgoCD des modifications effectuées directement dans le cluster
  • Superposition : Un répertoire Kustomize qui modifie la base partagée pour un environnement donné
  • Boucle de conflit : Deux contrôleurs écrasant à plusieurs reprises le même champ du même objet

Prochaines étapes

Continuer l'apprentissage : Unité 5.4 : Vérification des connaissances - Opérations de production

Sujets connexes :