FluxCD : le GitOps natif Kubernetes en 2026

FluxCD est le toolkit GitOps moderne pour Kubernetes, certifié CNCF Graduated depuis décembre 2022. Contrairement à la croyance populaire, ce n'est pas simplement une alternative à ArgoCD — c'est une architecture déclarative et orientée contrôleurs, où Git devient réellement la source unique de vérité pour votre infrastructure.

Dans ce guide, nous couvrons l'architecture complète, le bootstrap, le déploiement d'applications et la gestion des secrets chiffrés.

1. Les principes du GitOps
2. Architecture de FluxCD (5 contrôleurs)
3. Bootstrap et structure de repository
4. Déployer une application avec FluxCD
5. Sécuriser les secrets avec SOPS
6. Flux vs ArgoCD : comparaison
7. Perspectives et ressources

Le GitOps repose sur quatre principes clés :

• Déclaration complète : toute l'infra et les apps sont décrites dans Git
• Git = source unique de vérité : le cluster recopie l'état du repo
• Pull-based : les contrôleurs tirent l'état depuis Git (pas de push)
• Réconciliation automatique : un opérateur détecte les drift et corrige

FluxCD pousse cette philosophie plus loin avec une architecture entièrement basée sur des contrôleurs Kubernetes natifs et des CRDs customs.

FluxCD fournit 5 composants principaux :

1. source-controller

Synchronise les sources (Git, Helm, OCI) dans le cluster.

• GitRepository : clone et surveille un repo Git
• HelmRepository : indexe les charts Helm
• Bucket : syncés S3/OCI Artifact Registry

2. kustomize-controller

Applique des manifestes Kustomize avec ordre et dépendances.

• Kustomization : construit et applique des overlays Kustomize
• Support des secrets, images, replicas inline

3. helm-controller

Gère les releases Helm via CRD.

• HelmRelease : déploie/met à jour des charts
• Hooks de test, rollback automatique, multi-chart

4. notification-controller

Envoie les événements (Slack, Teams, webhook).

• Alert : déclenche sur événements Flux
• Receiver : reçoit les webhooks GitHub/GitLab

5. image-automation-controller

Met à jour automatiquement les tags d'images dans Git.

• ImageRepository : scanne un registry
• ImageUpdateAutomation : commit les nouveaux tags

La boucle de réconciliation s'exécute toutes les 10 secondes (configurable) : chaque contrôleur scrute Git et corrige le cluster.

Initialiser FluxCD

# Installer la CLI
curl -s https://fluxcd.io/install.sh | sudo bash

# Bootstrap sur GitHub
export GITHUB_TOKEN=your_token
flux bootstrap github \
  --owner=your-org \
  --repo=flux-config \
  --branch=main \
  --path=./clusters/production \
  --personal

Flux crée automatiquement :

• /clusters/production/ : manifestes Flux du cluster
• /apps/ : applications déclarées
• /infrastructure/ : composants infra (cert-manager, ingress, etc.)

Structure recommandée

flux-config/
├── clusters/
│   └── production/
│       ├── flux-system/              # Namespace Flux
│       └── kustomization.yaml        # Point d'entrée
├── apps/
│   ├── base/                        # Kustomize base communes
│   │   └── my-app/
│   │       ├── deployment.yaml
│   │       ├── service.yaml
│   │       └── kustomization.yaml
│   └── overlays/
│       └── production/
│           └── kustomization.yaml
└── infrastructure/
    ├── cert-manager/
    ├── nginx-ingress/
    └── kustomization.yaml

Étape 1 : Source Git

Créez une GitRepository pour suivre votre repo d'app :

apiVersion: source.toolkit.fluxcd.io/v1
kind: GitRepository
metadata:
  name: my-app
  namespace: flux-system
spec:
  interval: 1m
  url: https://github.com/org/my-app
  ref:
    branch: main
  secretRef:
    name: my-app-credentials # Optional SSH key

Étape 2 : Kustomization

Appliquez les manifestes via Kustomize :

apiVersion: kustomize.toolkit.fluxcd.io/v1
kind: Kustomization
metadata:
  name: my-app
  namespace: flux-system
spec:
  interval: 10m
  sourceRef:
    kind: GitRepository
    name: my-app
  path: ./k8s/overlays/production
  prune: true # Supprime les ressources non déclarées
  wait: true # Attend la stabilité
  postBuild:
    substitute:
      environment: 'production'
      replicas: '3'

Étape 3 : Helm (optionnel)

Pour les packages Helm :

apiVersion: source.toolkit.fluxcd.io/v1beta2
kind: HelmRepository
metadata:
  name: stable
  namespace: flux-system
spec:
  interval: 1h
  url: https://charts.example.com
---
apiVersion: helm.toolkit.fluxcd.io/v2
kind: HelmRelease
metadata:
  name: nginx-ingress
  namespace: ingress-nginx
spec:
  interval: 1h
  chart:
    spec:
      chart: nginx-ingress
      sourceRef:
        kind: HelmRepository
        name: stable
  values:
    replicas: 3
    controller:
      resources:
        requests:
          cpu: 100m
          memory: 256Mi

FluxCD supporte SOPS (Secrets Operations) pour chiffrer les secrets directement dans Git.

Initialiser SOPS

# Générer une clé AGE
age-keygen -o ~/.config/sops/age/keys.txt

# Ajouter la clé au cluster
kubectl create secret generic sops-age \
  --from-file=age.agekey=$HOME/.config/sops/age/keys.txt \
  -n flux-system

# Chiffrer un secret existant
sops -e --age=$(age-keygen -y ~/.config/sops/age/keys.txt) secrets.yaml > secrets.enc.yaml

Déclarer le secret chiffré

apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
stringData:
  username: ENC[AES256_GCM,data:xL8=,iv:RwKn,tag:lB0=,type:str]
  password: ENC[AES256_GCM,data:uDk8QTrM,iv:RwKp,tag:lC0=,type:str]
sops:
  kms: []
  gcp_kms: []
  azure_kv: []
  hc_vault: []
  age:
    - recipient: age1u9r8fqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
      enc: |
        -----BEGIN AGE ENCRYPTED FILE-----
        ...
        -----END AGE ENCRYPTED FILE-----
  lastmodified: '2026-03-08T10:00:00Z'
  mac: ENC[AES256_GCM,data:xxx,iv:yyy,tag:zzz,type:str]
  pgp: []
  unencrypted_suffix: _unencrypted
  version: 3.8.1

Flux déchiffre automatiquement lors de la réconciliation.

Verdict : Flux = GitOps pur, ArgoCD = GitOps + management UI. Choisir Flux si vous maîtrisez kubectl ; ArgoCD si vous avez besoin d'une interface.

Chez SHPV, nous utilisons FluxCD pour orchestrer notre infrastructure déclarative sur Kubernetes. GitOps garantit que chaque changement est tracé, reviewé et auditable — crucial pour les SLAs de 99.9%+ que nous servons à nos clients en infogérance.

Les bénéfices immédiats :

• Auditabilité : chaque déploiement = commit Git signé
• Disaster recovery : recréer le cluster = flux bootstrap + pousser le repo
• Drift detection : les contrôleurs détectent et corrigent les divergences
• Multi-région : une seule source Git pour tous les clusters

Pour approfondir :

• /blog/kubernetes-introduction : fondamentaux Kubernetes
• /blog/sops-secrets-chiffres : gestion avancée des secrets
• /blog/argo-cd-gitops : alternative avec ArgoCD

Sources officielles

• FluxCD : https://fluxcd.io/
• CNCF : https://www.cncf.io/projects/flux/
• GitHub : https://github.com/fluxcd/flux2

FluxCD est la solution GitOps native Kubernetes pour les équipes DevOps modernes. Son architecture décentralisée, ses contrôleurs spécialisés et son support natif des secrets en font le choix idéal pour les infras complexes nécessitant auditabilité, traçabilité et automation robuste.

Commencez par un bootstrap simple, versionnez votre infra dans Git, et laissez les contrôleurs orchestrer vos déploiements. Bienvenue dans le GitOps réel.