Module 5 – GitOps & Platform Engineering

GitOps et Platform Engineering permettent de standardiser les déploiements et d’offrir des golden paths aux équipes produit. Ce module couvre Argo CD, Flux et Backstage.

Objectifs

• Déployer une plateforme GitOps (Argo CD ou Flux) pour gérer les environnements.
• Créer un catalogue Backstage avec des templates “golden path”.
• Mesurer l’adoption via métriques de plateforme (temps de provisioning, réutilisation).

1. Repository de configuration

platform-config/
├── apps/
│   ├── staging/webapp/
│   │   ├── kustomization.yaml
│   │   ├── deployment.yaml
│   │   └── service.yaml
│   └── prod/webapp/
├── clusters/
│   ├── staging/argo-app.yaml
│   └── prod/argo-app.yaml
└── templates/
    └── microservice/
        └── skeleton

Argo CD représente chaque application via un manifest Application.

2. Argo CD

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: webapp-staging
spec:
  project: default
  source:
    repoURL: https://github.com/acme/platform-config.git
    path: apps/staging/webapp
    targetRevision: main
  destination:
    server: https://kubernetes.default.svc
    namespace: webapp-staging
  syncPolicy:
    automated:
      selfHeal: true
      prune: true
    syncOptions:
      - CreateNamespace=true

Commande :

argocd app create -f clusters/staging/argo-app.yaml
argocd app sync webapp-staging

3. Flux

flux bootstrap github   --owner=acme   --repository=platform-config   --branch=main   --path=clusters/staging

Déclarer une app :

apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: webapp-staging
  namespace: flux-system
spec:
  interval: 5m
  path: ./apps/staging/webapp
  prune: true
  sourceRef:
    kind: GitRepository
    name: platform-config

4. Platform Engineering : Backstage

Backstage template :

apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: goldenpath-microservice
  title: Microservice Helm chart
spec:
  owner: platform-team
  type: service
  parameters:
    - title: Service details
      required:
        - name
      properties:
        name:
          type: string
          description: Nom du service
  steps:
    - id: fetch-base
      name: Fetch base skeleton
      action: fetch:template
      input:
        url: ./templates/microservice
    - id: publish
      name: Publish to GitHub
      action: publish:github
      input:
        repoUrl: github.com?owner=acme&repo={{ parameters.name }}
        defaultBranch: main

Ce template génère un repo Git, un dossier AppConfig et l’application Argo/Flux associée.

5. Mesure & observabilité de la plateforme

• Exposez les métriques Argo CD (argocd-metrics) ou Flux (/metrics) pour suivre argocd_app_sync_total, reconcile_duration_seconds.
• Ajoutez un tableau de bord Grafana pour suivre : temps de provisioning (Backstage pipeline), taux de réussite, adoption des templates.
• SLO plateforme : ex. 99% des sync < 2 min, 95% des templates déployés en < 30 min.

6. Lab guidé

1. Déployer Argo CD dans un namespace argocd (kubectl apply -n argocd -f argo-install.yaml).
2. Créer le repository platform-config avec structure apps/, clusters/.
3. Déclarer l’application webapp-staging et vérifier la synchronisation.
4. Installer Backstage (Docker ou via Helm) et ajouter le template goldenpath-microservice.
5. Créer un service via Backstage, vérifier la génération du repo et l’apparition de l’Application Argo.

Challenge optionnel

• Mettre en place TechDocs pour documenter les services.
• Intégrer Flagger pour automatiser les canary.
• Déployer Portal interne (Port, Humanitec) et comparer l’expérience de golden path.

Solution détaillée

1. Argo CD : argocd app list doit afficher Sync Status: Synced, Health Status: Healthy. kubectl get pods -n webapp-staging renvoie les Pods attendus.
2. Flux : flux get kustomizations montre Ready. Les events Flux dans flux-system confirment la prise en compte.
3. Backstage template : après création, un repo Git acme/ doit être créé automatiquement avec pipeline bootstrap.
4. Métriques : exposer argocd-metrics ou flux-system dans Prometheus et vérifier un dashboard (nombre de sync, durée moyenne).
5. SLO : calculez la durée entre git push et argocd_app_sync_total pour 5 déploiements. Documentez dans docs/platform-metrics.md.

Capturer des captures d’écran (UI Argo/Backstage) et les consigner dans le dépôt pour démontrer la mise en place.

Pièges fréquents

• Argo CD selfHeal sans prune → les ressources supprimées persistent.
• Flux multi-branch : attention aux kustomization alignées sur la mauvaise branche.
• Backstage : géré par Node.js, surveillez la consommation mémoire.

Ressources

• Argo CD docs
• Flux CD
• Backstage

Checklist

• ✅ Argo CD ou Flux opérationnel avec au moins un environnement synchronisé.
• ✅ Templates Backstage disponibles et testés.
• ✅ Métriques GitOps collectées (Prometheus/Grafana).
• ✅ Documentation plateforme à jour.