**Aidez à améliorer cette page** 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utiliser ApplicationSets
<a name="argocd-applicationsets"></a>

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
<a name="_prerequisites"></a>
+ Création d'un cluster EKS doté de la fonctionnalité Argo CD
+ Accès au référentiel configuré (voir[Configuration de l'accès au référentiel](argocd-configure-repositories.md))
+  `kubectl`configuré pour communiquer avec votre cluster

**Note**  
Il n'est pas nécessaire de disposer de plusieurs clusters cibles pour ApplicationSets. Vous pouvez utiliser des générateurs autres que le générateur de clusters (tels que des générateurs de listes, de git ou de matrices) pour déployer des applications sans clusters distants.

## Comment ApplicationSets travailler
<a name="_how_applicationsets_work"></a>

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
+  **Générateur de fusion** - Fusionnez les paramètres de plusieurs générateurs

Pour une référence complète sur le générateur, consultez [ApplicationSet la documentation](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/).

## Générateur de listes
<a name="_list_generator"></a>

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:
      - environment: dev
        replicas: "2"
      - environment: staging
        replicas: "3"
      - 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:
        name: '{{environment}}-cluster'
        namespace: guestbook
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

**Note**  
À utiliser `destination.name` avec les noms de clusters pour une meilleure lisibilité. Le `destination.server` champ fonctionne également avec le cluster EKS ARNs si nécessaire.

Cela crée trois applications : `guestbook-dev``guestbook-staging`, et`guestbook-prod`.

## Générateur de clusters
<a name="_cluster_generator"></a>

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** :

`matchLabels`À utiliser pour inclure des clusters spécifiques ou `matchExpressions` pour exclure des clusters :

```
spec:
  generators:
  - clusters:
      selector:
        matchLabels:
          environment: production
        matchExpressions:
        - key: skip-appset
          operator: DoesNotExist
```

## Générateurs Git
<a name="_git_generators"></a>

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:
        name: 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](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/) dans la documentation du CD Argo.

## Générateur de matrices
<a name="_matrix_generator"></a>

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:
        name: '{{name}}'
        namespace: 'app-{{environment}}'
```

Pour plus de détails sur la combinaison de générateurs, voir [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/) dans la documentation d'Argo CD.

## Déploiement multirégional
<a name="_multi_region_deployment"></a>

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:
      - clusterName: prod-us-west
        region: us-west-2
      - clusterName: prod-us-east
        region: us-east-1
      - clusterName: 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:
        name: '{{clusterName}}'
        namespace: app
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
```

## Gérez ApplicationSets
<a name="_manage_applicationsets"></a>

 **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 fait`prune: true`, leurs ressources seront également supprimées des clusters cibles.  
Pour préserver les ressources déployées lors de la suppression d'un ApplicationSet, définissez `.syncPolicy.preserveResourcesOnDeletion` sur `true` dans la ApplicationSet spécification. Pour plus d'informations, consultez la section [Élagage des applications et suppression des ressources](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/) dans la documentation d'Argo CD.

**Important**  
La ApplicationSets fonctionnalité d'Argo CD comporte des considérations de sécurité que vous devez connaître avant de l'utiliser ApplicationSets. Pour plus d'informations, consultez [ApplicationSet la section Sécurité](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/) dans la documentation d'Argo CD.

## Ressources supplémentaires
<a name="_additional_resources"></a>
+  [Travailler avec des projets Argo CD](argocd-projects.md)- Organisez ApplicationSets avec des projets
+  [Création d'applications](argocd-create-application.md)- Comprendre la configuration des applications
+  [ApplicationSet Documentation](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/) - Référence et modèles complets du générateur
+  [Référence du générateur](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/) - Spécifications détaillées du générateur