Flux CD — Automatisation des mises à jour d'images

Un des atouts différentiants de Flux CD par rapport à ArgoCD est son système d’automatisation d’images natif. Flux peut surveiller un registre de conteneurs, détecter une nouvelle version d’image conforme à votre politique SemVer, et pousser automatiquement la mise à jour dans votre dépôt Git — sans pipeline CI supplémentaire. Ce guide explique comment configurer les trois objets : ImageRepository, ImagePolicy et ImageUpdateAutomation.

Composants requis

L’automatisation d’images nécessite deux contrôleurs supplémentaires : image-reflector-controller et image-automation-controller. Ils ne sont pas installés par défaut sur un bootstrap minimal. Vérifiez avec flux get all qu’ils sont présents, sinon relancez le bootstrap avec --components-extra=image-reflector-controller,image-automation-controller.

Ce que vous allez apprendre

• Comprendre le flux complet : registre → ImagePolicy → Git → cluster
• Déclarer un ImageRepository pour surveiller un registre
• Créer une ImagePolicy avec une règle SemVer ou de filtrage
• Configurer ImageUpdateAutomation pour que Flux pousse dans Git
• Annoter vos manifestes avec le marqueur de mise à jour Flux
• Limiter l’automatisation à une branche de staging (bonne pratique)

Prérequis

• Flux bootstrappé avec les composants image-reflector et image-automation
• Un registre de conteneurs (GitHub Container Registry, Docker Hub, Harbor…)
• Un dépôt Git où Flux a accès en écriture (deploy key avec droits d’écriture)

Vérifier les composants :

flux get all
# Vous devriez voir image-reflector-controller et image-automation-controller
kubectl get pods -n flux-system
# NAME                                              READY
# image-automation-controller-xxx                   1/1
# image-reflector-controller-xxx                    1/1

Le flux de données

L’automatisation d’images fonctionne en trois étapes :

1. ImageRepository → surveille le registre, stocke les tags dans le cluster
2. ImagePolicy     → filtre les tags selon une règle (semver, alphabétique, date)
3. ImageUpdateAutomation → lit les politiques, met à jour les manifestes Git

C’est le seul flux dans Flux CD où Flux pousse vers une source externe (Git). Tout le reste est en mode pull.

Installer les composants image automation

Si vous utilisez le bootstrap minimal (sans --components-extra), relancez-le :

flux bootstrap github \
  --owner=${GITHUB_USER} \
  --repository=fleet-infra \
  --branch=main \
  --path=clusters/my-cluster \
  --components-extra=image-reflector-controller,image-automation-controller \
  --personal

Déclarer un ImageRepository

Un ImageRepository déclare un dépôt d’images à surveiller (une image Docker, pas un tag particulier) :

infrastructure/image-automation/podinfo-image.yaml

apiVersion: image.toolkit.fluxcd.io/v1beta2
kind: ImageRepository
metadata:
  name: podinfo
  namespace: flux-system
spec:
  image: ghcr.io/stefanprodan/podinfo
  interval: 1m

Pour un registre privé, référencez un Secret Kubernetes contenant les credentials :

spec:
  image: registry.example.com/my-org/my-app
  interval: 5m
  secretRef:
    name: registry-credentials

Créez le Secret :

kubectl create secret docker-registry registry-credentials \
  --docker-server=registry.example.com \
  --docker-username=<user> \
  --docker-password=<token> \
  --namespace=flux-system

Créer une ImagePolicy

Une ImagePolicy filtre les tags d’image pour sélectionner celui à déployer.

Politique SemVer (recommandée)

infrastructure/image-automation/podinfo-policy.yaml

apiVersion: image.toolkit.fluxcd.io/v1beta2
kind: ImagePolicy
metadata:
  name: podinfo
  namespace: flux-system
spec:
  imageRepositoryRef:
    name: podinfo
  policy:
    semver:
      range: ">=6.0.0 <7.0.0"

Cette politique sélectionne le tag le plus élevé dans la range >=6.0.0 <7.0.0. Si 6.2.0 est la version la plus récente, ImagePolicy sélectionne 6.2.0. Quand 6.3.0 sort, Flux la sélectionne automatiquement.

Autres types de politiques

Alphabétique — utile pour les tags non-SemVer comme des timestamps :

spec:
  policy:
    alphabetical:
      order: asc   # ou "desc" pour le dernier tag alphabétiquement

Numérique — pour les builds numérotés (build-42, build-43…) :

spec:
  filterTags:
    pattern: "^build-(?P<build>[0-9]+)$"
    extract: "$build"
  policy:
    numerical:
      order: asc

Filtre de tags — pour exclure des tags de pre-release ou de test :

spec:
  filterTags:
    pattern: "^v[0-9]+\\.[0-9]+\\.[0-9]+$"   # Exclut v1.0.0-rc1, latest, dev...
  policy:
    semver:
      range: ">=1.0.0"

Vérifiez la politique sélectionnée :

flux get image policy podinfo
# NAME     LATEST IMAGE                          READY  MESSAGE
# podinfo  ghcr.io/stefanprodan/podinfo:6.2.0   True   Latest image tag for 'ghcr.io/stefanprodan/podinfo' resolved to: 6.2.0

Annoter les manifestes avec le marqueur de mise à jour

Pour que ImageUpdateAutomation sache quel champ mettre à jour dans vos manifestes, vous devez ajouter un marqueur de commentaire dans le fichier YAML.

Dans votre Deployment, annotez la ligne image: :

apps/base/podinfo/deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: podinfo
spec:
  template:
    spec:
      containers:
        - name: podinfod
          image: ghcr.io/stefanprodan/podinfo:6.0.0   # {"$imagepolicy": "flux-system:podinfo"}

Le commentaire # {"$imagepolicy": "flux-system:podinfo"} indique à Flux :

• flux-system — namespace de l’objet ImagePolicy
• podinfo — nom de l’objet ImagePolicy

Quand Flux détecte une mise à jour, il remplace uniquement le tag dans cette ligne précise.

Format complet et format réduit

Vous pouvez aussi annoter uniquement le tag (utile si l’image est définie via une variable) :

# Annoter seulement le tag
image: ghcr.io/stefanprodan/podinfo:6.0.0  # {"$imagepolicy": "flux-system:podinfo:tag"}

# Dans un autre champ (configmap, env var...)
value: "6.0.0"  # {"$imagepolicy": "flux-system:podinfo:tag"}

Configurer ImageUpdateAutomation

ImageUpdateAutomation est l’objet qui fait le lien entre les politiques d’image et le dépôt Git. Il fait une chose simple : scanner les fichiers du dépôt pour les marqueurs $imagepolicy, remplacer les tags obsolètes, et pousser un commit dans Git.

infrastructure/image-automation/flux-system-automation.yaml

apiVersion: image.toolkit.fluxcd.io/v1beta2
kind: ImageUpdateAutomation
metadata:
  name: flux-system
  namespace: flux-system
spec:
  interval: 1m
  sourceRef:
    kind: GitRepository
    name: flux-system
  git:
    checkout:
      ref:
        branch: main
    commit:
      author:
        email: fluxcdbot@users.noreply.github.com
        name: fluxcdbot
      messageTemplate: |
        chore(image): update {{range .Updated.Images}}{{.}}{{end}} to latest
    push:
      branch: main
  update:
    path: ./apps
    strategy: Setters

Paramètres clés :

Paramètre	Description
git.checkout.ref.branch	Branche à lire
git.push.branch	Branche où pousser les commits
git.commit.author	Identité du commit automatique
update.path	Répertoire à scanner pour les marqueurs
update.strategy	Setters : utilise les commentaires $imagepolicy

Glissez pour voir

Ne jamais pointer image-automation vers main en production

Si push.branch: main et que main est la branche de production, une image non testée peut aller directement en production. La bonne pratique est de pousser vers une branche staging ou image-updates et d’utiliser une Pull Request pour valider avant de merger vers main.

Configuration production : branche dédiée

spec:
  git:
    checkout:
      ref:
        branch: main
    push:
      branch: staging   # Pousse les mises à jour dans staging

Avec cette configuration :

1. Flux détecte une nouvelle image sur la politique.
2. Flux crée ou met à jour la branche staging avec le nouveau tag.
3. Vous (ou un bot) créez une PR de staging vers main.
4. Après merge, Flux réconcilie et déploie.

Workflow complet — test end-to-end

1. Vérifier que tous les objets sont prêts

flux get image repository podinfo
flux get image policy podinfo
flux get image update flux-system

2. Simuler une nouvelle image (test)

Pousser une image avec un tag plus récent dans votre registre, ou modifier temporairement la contrainte SemVer de l’ImagePolicy pour sélectionner un tag différent.

3. Observer le commit automatique

# Surveiller les logs de image-automation-controller
kubectl logs -n flux-system deploy/image-automation-controller -f

# Vérifier dans votre dépôt Git
git log --oneline -5
# chore(image): update ghcr.io/stefanprodan/podinfo:6.3.0 to latest
# ...

4. Vérifier le déploiement

flux get kustomizations
kubectl get pods -n podinfo
kubectl describe pod -n podinfo | grep Image:

Pièges courants

La politique sélectionne toujours l’ancien tag

Vérifiez que le tag le plus récent est présent dans les tags scannés :

kubectl get imagerepository podinfo -n flux-system -o jsonpath='{.status.lastScanResult}'

ImageUpdateAutomation ne pousse pas de commit

Vérifiez que la deploy key Flux a des droits en écriture sur le dépôt. Sur GitHub, une deploy key en lecture seule ne peut pas pousser.

Les marqueurs ne sont pas reconnus

Le format exact du commentaire doit être respecté : # {"$imagepolicy": "namespace:name"} — sans espace à l’intérieur des accolades, et avec les guillemets doubles.

À retenir

• Les contrôleurs image-reflector-controller et image-automation-controller sont nécessaires et ne sont pas installés par défaut.
• ImageRepository surveille le registre, ImagePolicy filtre les tags, ImageUpdateAutomation pousse dans Git.
• Le marqueur de commentaire # {"$imagepolicy": "ns:name"} dans les manifestes est obligatoire pour que Flux sache quoi mettre à jour.
• Ne jamais pousser directement sur main en production — utiliser une branche intermédiaire et une PR.
• La policy SemVer est la plus courante et la plus sûre : elle évite les pre-releases et garantit une progression stable.

Prochaines étapes

Multi-tenancy Isoler les équipes avec des namespaces et des permissions Flux dédiées

Monitoring et alertes Recevoir des notifications Slack quand Flux met à jour une image

Déploiements Helm Automatistatiser les tags d'images dans des HelmRelease

×

📖 Voir la documentation →