Utiliser ApplicationSets

ApplicationSets générez plusieurs applications à partir de modèles, ce qui vous permet de déployer la même application sur plusieurs clusters, environnements ou espaces de noms avec une seule définition de ressource.

Conditions préalables

• Création d'un cluster EKS doté de la fonctionnalité Argo CD

• Plusieurs clusters cibles enregistrés (voirEnregistrer les clusters cibles)

• Accès au référentiel configuré (voirConfiguration de l'accès au référentiel)

• kubectlconfiguré pour communiquer avec votre cluster

Comment ApplicationSets travailler

ApplicationSets utilisez des générateurs pour produire des paramètres, puis appliquez ces paramètres à un modèle d'application. Chaque ensemble de paramètres générés crée une application.

Générateurs courants pour les déploiements EKS :

• Générateur de listes - Définissez explicitement les clusters et les paramètres pour chaque environnement

• Générateur de clusters - Déploiement automatique sur tous les clusters enregistrés

• Générateur Git - Génère des applications à partir de la structure du référentiel

• Générateur de matrices - Combinez des générateurs pour des déploiements multidimensionnels

Pour une référence complète sur le générateur, consultez ApplicationSet la documentation.

Générateur de listes

Déployez sur plusieurs clusters avec une configuration explicite :

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: guestbook-all-clusters
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - cluster: arn:aws:eks:us-west-2:111122223333:cluster/dev-cluster
        environment: dev
        replicas: "2"
      - cluster: arn:aws:eks:us-west-2:111122223333:cluster/staging-cluster
        environment: staging
        replicas: "3"
      - cluster: arn:aws:eks:us-west-2:111122223333:cluster/prod-cluster
        environment: prod
        replicas: "5"
  template:
    metadata:
      name: 'guestbook-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/guestbook
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        server: '{{cluster}}'
        namespace: guestbook
      syncPolicy:
        automated:
          prune: true
          selfHeal: true

Note

Utilisez le cluster EKS server sur ARNs le terrain lorsque vous ciblez des clusters EKS enregistrés. Vous pouvez également utiliser les noms de cluster avec destination.name au lieu dedestination.server.

Cela crée trois applications : guestbook-devguestbook-staging, etguestbook-prod.

Générateur de clusters

Déployez automatiquement sur tous les clusters enregistrés :

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: cluster-addons
  namespace: argocd
spec:
  generators:
  - clusters: {}
  template:
    metadata:
      name: '{{name}}-addons'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/cluster-addons
        targetRevision: HEAD
        path: addons
      destination:
        server: '{{server}}'
        namespace: kube-system
      syncPolicy:
        automated:
          prune: true
          selfHeal: true

Cela crée automatiquement une application pour chaque cluster enregistré.

Clusters de filtres :

spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          environment: production

Générateurs Git

Les générateurs Git créent des applications basées sur la structure du référentiel :

• Générateur de répertoires - Déployez chaque répertoire en tant qu'application distincte (utile pour les microservices)

• Générateur de fichiers : générez des applications à partir de fichiers de paramètres (utile pour les déploiements multi-locataires)

Exemple : déploiement de microservices

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: microservices
  namespace: argocd
spec:
  generators:
  - git:
      repoURL: https://github.com/example/microservices
      revision: HEAD
      directories:
      - path: services/*
  template:
    metadata:
      name: '{{path.basename}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/microservices
        targetRevision: HEAD
        path: '{{path}}'
      destination:
        server: arn:aws:eks:us-west-2:111122223333:cluster/my-cluster
        namespace: '{{path.basename}}'
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
        - CreateNamespace=true

Pour plus de détails sur les générateurs Git et la configuration basée sur des fichiers, consultez Git Generator dans la documentation du CD Argo.

Générateur de matrices

Combinez plusieurs générateurs pour les déployer sur plusieurs dimensions (environnements × clusters) :

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: multi-env-multi-cluster
  namespace: argocd
spec:
  generators:
  - matrix:
      generators:
      - list:
          elements:
          - environment: dev
          - environment: staging
          - environment: prod
      - clusters:
          selector:
            matchLabels:
              region: us-west-2
  template:
    metadata:
      name: 'app-{{environment}}-{{name}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        server: '{{server}}'
        namespace: 'app-{{environment}}'

Pour plus de détails sur la combinaison de générateurs, voir Matrix Generator dans la documentation d'Argo CD.

Déploiement progressif

Déployez dans des environnements séquentiellement avec différentes politiques de synchronisation :

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: progressive-rollout
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - environment: dev
        autoSync: "true"
      - environment: staging
        autoSync: "true"
      - environment: prod
        autoSync: "false"
  template:
    metadata:
      name: 'app-{{environment}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: 'overlays/{{environment}}'
      destination:
        server: arn:aws:eks:us-west-2:111122223333:cluster/{{environment}}-cluster
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: '{{autoSync}}'

Le développement et la mise en scène se synchronisent automatiquement, tandis que la production nécessite une approbation manuelle.

Déploiement multirégional

Déployez sur des clusters répartis dans plusieurs régions :

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: global-app
  namespace: argocd
spec:
  generators:
  - list:
      elements:
      - cluster: arn:aws:eks:us-west-2:111122223333:cluster/prod-us-west
        region: us-west-2
      - cluster: arn:aws:eks:us-east-1:111122223333:cluster/prod-us-east
        region: us-east-1
      - cluster: arn:aws:eks:eu-west-1:111122223333:cluster/prod-eu-west
        region: eu-west-1
  template:
    metadata:
      name: 'app-{{region}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/example/app
        targetRevision: HEAD
        path: kubernetes
        helm:
          parameters:
          - name: region
            value: '{{region}}'
      destination:
        server: '{{cluster}}'
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: true

Gérez ApplicationSets

Afficher ApplicationSets et générer les applications :

kubectl get applicationsets -n argocd
kubectl get applications -n argocd -l argocd.argoproj.io/application-set-name=<applicationset-name>

Mettez à jour et ApplicationSet :

Modifiez les ApplicationSet spécifications et réappliquez. Argo CD met automatiquement à jour toutes les applications générées :

kubectl apply -f applicationset.yaml

Supprimer un ApplicationSet :

kubectl delete applicationset <name> -n argocd

Avertissement

La suppression et la ApplicationSet suppression de toutes les applications générées. Si ces applications l'ont faitprune: true, leurs ressources seront également supprimées des clusters cibles.

Ressources supplémentaires

• Travailler avec des projets Argo CD- Organisez ApplicationSets avec des projets

• Création d'applications- Comprendre la configuration des applications

• ApplicationSet Documentation - Référence et modèles complets du générateur

• Référence du générateur - Spécifications détaillées du générateur