Module 7 – CI/CD, Helm, GitOps et préparation aux certifications

Nous terminons par l’industrialisation : après ce module, vous serez capable d’automatiser vos déploiements Kubernetes, de mettre en place un flux GitOps et de planifier votre réussite aux certifications CNCF.

Objectifs

• Templater vos manifestes avec Helm ou Kustomize en fonction des besoins.
• Mettre en place un flux GitOps avec Argo CD (ou Flux) et des environnements promotionnels.
• Intégrer Kubernetes dans votre pipeline CI/CD en incluant tests et politiques.
• Structurer la préparation CKA/CKAD (outils, temps, stratégies d’examen).

1. Packaging : Helm vs Kustomize

Helm = templating + release management + chart repository.
Kustomize = overlays, pas de serveur, inclus dans kubectl.

Créer un chart Helm

helm create webapp

Déployer en staging :

helm upgrade --install webapp-staging charts/webapp   --namespace staging   --create-namespace   --values values-staging.yaml

Variables secret : utilisez helm secrets ou helm install --set-file.

Overlay Kustomize

# overlays/staging/kustomization.yaml
bases:
  - ../../base
patchesStrategicMerge:
  - replicas.yaml   # ajuste le nombre de pods
  - ingress.yaml    # configuration spécifique
configMapGenerator:
  - name: webapp-config
    literals:
      - APP_MODE=staging

Build + déploiement :

kustomize build overlays/staging | kubectl apply -f -

2. GitOps

GitOps = l’état désiré vit dans Git, un opérateur observe et aligne le cluster.

argocd app create webapp   --repo https://github.com/acme/platform-config.git   --path apps/prod/webapp   --dest-server https://kubernetes.default.svc   --dest-namespace production   --sync-policy automated   --self-heal

Bonnes pratiques :

• Un repo app (code + Dockerfile) + un repo config (manifeste GitOps).
• Branches staging/production + Pull Requests avec review.
• Labels Argo : argocd.argoproj.io/instance pour retrouver les objets.

3. Pipeline CI/CD type

1. Build : Kaniko, BuildKit, Buildpacks.
2. Scan : trivy image, grype pour les vulnérabilités.
3. Push : registry privé (GHCR, ECR, ACR…).
4. Déployer : Helm, Kustomize, kubectl apply, ou merge GitOps.
5. Tests post-déploiement : smoke tests, e2e, chaos léger.

Exemple GitHub Actions

name: Deploy webapp
on:
  push:
    branches: [ "main" ]
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'
      - name: Build image
        run: |
          docker build -t ghcr.io/acme/webapp:${{ github.sha }} .
          echo "GHCR_TOKEN" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
          docker push ghcr.io/acme/webapp:${{ github.sha }}
      - name: Lint manifests
        run: |
          pip install kubeconform datree
          kubeconform -summary manifests/
      - name: Update values file pour Argo CD
        run: |
          yq -i '.image.tag = "${{ github.sha }}"' platforms/apps/prod/webapp/values-prod.yaml
      - name: Commit & push config
        uses: stefanzweifel/git-auto-commit-action@v5
        with:
          commit_message: "ci: bump webapp image"
          repository: platforms

Un webhook Argo CD détecte la modification et synchronise automatiquement.

4. Qualité et politique

• Lint : helm lint, kubeval, kubeconform.
• Policy : Kyverno/Gatekeeper exécutés dans la pipeline pour shift-left.
• Canary/Progressive delivery : Argo Rollouts, Flagger.

Exemple de test fumée :

kubectl run smoke --image=ghcr.io/acme/tester -n staging --restart=Never   -- ./smoke-tests.sh || kubectl logs job/smoke

5. Préparation CKA/CKAD

• Travaillez uniquement en terminal (pas d’IDE). Alias k=kubectl, export do=--dry-run=client -o yaml.
• Créez /home/cka/answers et utilisez kubectl -n pour chaque question.
• CKA : gestion cluster, network, storage, troubleshooting (180 minutes). CKAD : workloads + architecture app (120 minutes).
• Plateformes d’entraînement : KodeKloud, KillerKoda, Autopilot.
• Recettes rapides : kubectl run --image, kubectl expose, kubectl set image.

Checklist examen :

• Configurer les alias dans ~/.bashrc dès le début (vi ~/.bashrc puis source ~/.bashrc).
• Utiliser kubectl explain pour vérifier les champs exacts.
• Utiliser kubectl get all -n pour obtenir un contexte rapide.
• Pour les YAML, kubectl create deployment ... --dry-run=client -o yaml > fichier.yaml puis éditer.

6. Lab d’industrialisation

1. Créer un chart Helm pour webapp avec deux fichiers values (staging, prod).
2. Installer Argo CD via Helm : helm upgrade --install argo argo/argo-cd -n argocd --create-namespace.
3. Déclarer une application webapp (commande ci-dessus) et activer l’auto-sync.
4. Mettre en place un pipeline minimal (GitLab CI, GitHub Actions ou Azure DevOps) qui build l’image, met à jour le fichier values-prod.yaml et pousse dans le repo GitOps.
5. Ajouter un test smoke (kubectl run smoke ...) et échouer la pipeline en cas d’anomalie.

Solution détaillée

1. Helm
   helm ls -n staging doit afficher webapp-staging en deployed.
   helm get values webapp-staging -n staging montre les values appliquées.
2. Kustomize
   kustomize build overlays/staging affiche le manifeste rendu. kubectl diff -f - vérifie les différences avant apply.
3. Argo CD
   argocd app list → l’application webapp doit être SYNCD/Healthy.
   Simulez un drift (modifiez manuellement un Deployment) : Argo doit le détecter et resynchroniser (mode self-heal).
4. Pipeline
   Une fois le commit poussé, vérifiez que GitHub Actions/GitLab CI passe toutes les étapes (build, scan, push, update config) et que la tâche de smoke test renvoie 0.
   Dans Argo CD, l’historique de synchronisation doit afficher le commit correspondant.
5. Plan CKA/CKAD
   Préparez un fichier plan-revision.md avec : créneaux, modules à relire, examens blancs programmés. Incluez la liste d’alias et les commandes rapides (kubectl run, kubectl expose, kubectl set image).

À la fin, vous devez pouvoir lancer une nouvelle feature en modifiant uniquement le code et en laissant le pipeline + Argo CD déployer automatiquement.

Ressources

• Documentation Helm
• Argo CD
• Flux CD
• Cours KodeKloud CKA

Checklist finale

• ✅ Vous savez générer un chart Helm ou un overlay Kustomize selon les besoins.
• ✅ Vous disposez d’un flux GitOps synchronisé (Argo CD/Flux).
• ✅ Votre pipeline CI/CD exécute build, scan et déploiement avec tests post-release.
• ✅ Vous avez un plan de révision CKA/CKAD clair (alias, outils, environnements pratiques).