ArgoCD — Pattern App of Apps et ApplicationSet

Quand votre plateforme héberge dix, vingt ou cent services, créer une Application ArgoCD à la main pour chacun devient ingérable. Le pattern App of Apps résout ce problème en faisant déployer par ArgoCD ses propres Application depuis Git. L’ApplicationSet va encore plus loin : il génère automatiquement des Applications à partir d’un template et d’une source de données (liste, découverte de dossiers Git…).

Ce que vous allez apprendre

• Le pattern App of Apps : faire déployer ArgoCD ses propres Application depuis Git
• La différence entre App of Apps (manuel, explicite) et ApplicationSet (déclaratif, généré)
• Le générateur List : créer plusieurs Applications depuis une liste statique dans le YAML
• Le générateur Git : découverte automatique des sous-dossiers d’un dépôt
• Comment déléguer la gestion d’Applications à des équipes via des dépôts Git distincts

Le problème : tout faire à la main ne passe pas à l’échelle

Imaginez 30 microservices à déployer dans un cluster. Sans automatisation, vous devez :

• Créer 30 objets Application ArgoCD à la main
• Les maintenir quand une équipe ajoute ou renomme un service
• Vous souvenir de les supprimer quand un service est retiré

Le pattern App of Apps automatise tout cela.

App of Apps : faire se gérer ArgoCD lui-même

L’idée est simple : créez une unique Application ArgoCD (l’app “racine”) qui surveille un dossier de votre dépôt Git. Ce dossier contient des objets Application (des fichiers YAML). ArgoCD crée et synchronise automatiquement chacune d’elles.

config-repo/
├── apps/                    ← l'app racine pointe ici
│   ├── nginx.yaml           ← définit l'Application "nginx-demo"
│   ├── redis.yaml           ← définit l'Application "redis"
│   └── monitoring.yaml      ← définit l'Application "monitoring"
├── nginx-demo/              ← manifestes de nginx
├── redis/                   ← manifestes de redis
└── monitoring/              ← manifestes de monitoring

Créer l’App racine

# root-app.yaml (à appliquer une seule fois avec kubectl)
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: root-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/votre-org/config-repo
    targetRevision: main
    path: apps             # ← dossier contenant les Applications enfants
  destination:
    server: https://kubernetes.default.svc
    namespace: argocd      # ← les Application se créent dans argocd
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

kubectl apply -f root-app.yaml

Écrire les Applications enfants

Chaque fichier dans apps/ décrit une Application ArgoCD :

apps/nginx.yaml

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: nginx-demo
  namespace: argocd
  finalizers:
    - resources-finalizer.argocd.argoproj.io  # Nettoyage à la suppression
spec:
  project: default
  source:
    repoURL: https://github.com/votre-org/config-repo
    targetRevision: main
    path: nginx-demo
  destination:
    server: https://kubernetes.default.svc
    namespace: demo
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true

Le finalizer resources-finalizer

Sans ce finalizer, si vous supprimez l’objet Application de Git, ArgoCD supprime l’Application mais pas les ressources Kubernetes qu’elle gère (Deployments, Services…). Avec le finalizer, ArgoCD supprime d’abord les ressources du cluster, puis l’Application. Comportement recommandé en production.

Pour ajouter un nouveau service, il suffit de créer un fichier YAML dans apps/ et de pousser. ArgoCD le détecte et déploie.

ApplicationSet : générer des Applications depuis un template

L’ApplicationSet est un niveau au-dessus de l’App of Apps. Au lieu de créer les fichiers Application à la main, vous définissez un template et des générateurs. ArgoCD crée autant d’Applications que nécessaire en combinant les deux.

Générateur List

Le générateur List est le plus simple. Vous fournissez une liste fixe de valeurs et ArgoCD crée une Application pour chacune.

applicationset-list.yaml

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
  namespace: argocd
spec:
  generators:
    - list:
        elements:
          - app: nginx-demo
            namespace: demo
          - app: redis
            namespace: data
          - app: monitoring
            namespace: observability
  template:
    metadata:
      name: "{{app}}"
    spec:
      project: default
      source:
        repoURL: https://github.com/votre-org/config-repo
        targetRevision: main
        path: "{{app}}"        # ← chemin = nom de l'app
      destination:
        server: https://kubernetes.default.svc
        namespace: "{{namespace}}"
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
          - CreateNamespace=true

Cet ApplicationSet crée trois Applications ArgoCD automatiquement.

kubectl apply -f applicationset-list.yaml

# Vérification
kubectl get applicationsets -n argocd
kubectl get applications -n argocd

Générateur Git (découverte automatique de dossiers)

Le générateur Git découvre automatiquement les dossiers de votre dépôt et crée une Application pour chacun. Ajout d’un dossier = déploiement automatique.

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: auto-discovery
  namespace: argocd
spec:
  generators:
    - git:
        repoURL: https://github.com/votre-org/config-repo
        revision: main
        directories:
          - path: services/*   # ← découvre tous les sous-dossiers de services/
  template:
    metadata:
      name: "{{path.basename}}"   # ← nom du dossier découvert
    spec:
      project: default
      source:
        repoURL: https://github.com/votre-org/config-repo
        targetRevision: main
        path: "{{path}}"
      destination:
        server: https://kubernetes.default.svc
        namespace: "{{path.basename}}"
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
          - CreateNamespace=true

Avec cette configuration, créer un dossier services/mon-api/ dans Git suffit pour qu’ArgoCD le découvre et déploie l’application.

Attention au générateur Git en production

La découverte automatique est très puissante mais peut surprendre. Si quelqu’un crée accidentellement un dossier dans services/, ArgoCD tentera de déployer son contenu. Utilisez les AppProjects pour contraindre les sources autorisées (voir le guide Sécuriser ArgoCD).

Choisir entre App of Apps et ApplicationSet

Critère	App of Apps	ApplicationSet
Complexité	Faible — fichiers YAML manuels	Modérée — template + générateur
Flexibilité	Chaque Application est personnalisée	Les Applications partagent le même template
Ajout d’une app	Créer un fichier YAML dans apps/	Dépend du générateur (liste ou dossier)
Différences entre apps	Totalement libre	Limitées aux variables du template
Cas d’usage idéal	Apps hétérogènes, configurations très variables	Microservices similaires, environnements multiples

Glissez pour voir

En pratique, les deux patterns se complètent : une App of Apps pour les services hétérogènes, des ApplicationSets pour les familles de services similaires.

À retenir

• L’App of Apps fait surveiller à ArgoCD son propre dossier de définitions d’Applications. Ajouter une Application = créer un fichier YAML dans Git.
• L’ApplicationSet génère automatiquement des Applications depuis un template et un générateur (Liste, Git, Clusters…).
• Le générateur List convient pour un ensemble fixe et connu d’applications.
• Le générateur Git découvre automatiquement les dossiers — idéal pour les équipes qui s’auto-servent.
• Le finalizer resources-finalizer.argocd.argoproj.io garantit le nettoyage des ressources Kubernetes quand une Application est supprimée.

Prochaines étapes

Intégration CI/CD Connecter votre pipeline CI à ArgoCD sans accès direct au cluster

Multi-environnements Gérer dev, staging et production avec Kustomize et ApplicationSet

Sécuriser ArgoCD RBAC, AppProjects, SSO et gestion des secrets

×

📖 Voir la documentation →