**Contribuisci a migliorare questa pagina** 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

ApplicationSets genera più applicazioni da modelli, consentendoti di distribuire la stessa applicazione su più cluster, ambienti o namespace con un'unica definizione di risorsa.

## Prerequisiti
<a name="_prerequisites"></a>
+ È stato creato un cluster EKS con funzionalità Argo CD
+ Accesso al repository configurato (vedi) [Configurare l'accesso al repository](argocd-configure-repositories.md)
+  `kubectl`configurato per comunicare con il cluster

**Nota**  
Non sono necessari cluster di destinazione multipli per ApplicationSets. È possibile utilizzare generatori diversi dal generatore di cluster (come i generatori list, git o matrix) per distribuire applicazioni senza cluster remoti.

## Come funziona ApplicationSets
<a name="_how_applicationsets_work"></a>

ApplicationSets utilizzate i generatori per produrre parametri, quindi applicate tali parametri a un modello di applicazione. Ogni set di parametri generati crea un'applicazione.

Generatori comuni per le implementazioni EKS:
+  **Generatore di elenchi**: definisce in modo esplicito cluster e parametri per ogni ambiente
+  **Generatore di cluster**: implementa automaticamente su tutti i cluster registrati
+  **Generatore Git**: genera applicazioni dalla struttura del repository
+  **Generatore di matrici**: combina generatori per implementazioni multidimensionali
+  Generatore di **fusione: unisce i parametri di più generatori**

[Per un riferimento completo al generatore, consultate la Documentazione. ApplicationSet ](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/)

## Generatore di elenchi
<a name="_list_generator"></a>

Esegui la distribuzione su più cluster con configurazione esplicita:

```
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
```

**Nota**  
Utilizzalo `destination.name` con i nomi dei cluster per una migliore leggibilità. ARNs Se necessario, il `destination.server` campo funziona anche con il cluster EKS.

Questo crea tre applicazioni: `guestbook-dev``guestbook-staging`, e`guestbook-prod`.

## Generatore di cluster
<a name="_cluster_generator"></a>

Implementa automaticamente su tutti i cluster registrati:

```
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
```

Questo crea automaticamente un'applicazione per ogni cluster registrato.

 **Cluster di filtri:**

Utilizza `matchLabels` per includere cluster specifici o `matchExpressions` per escludere cluster:

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

## Generatori Git
<a name="_git_generators"></a>

I generatori Git creano applicazioni basate sulla struttura del repository:
+  **Generatore di directory**: distribuisci ogni directory come applicazione separata (utile per i microservizi)
+  **Generatore di file**: genera applicazioni da file di parametri (utile per le implementazioni multi-tenant)

 **Esempio: implementazione di microservizi** 

```
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
```

Per i dettagli sui generatori Git e sulla configurazione basata su file, consultate [Git Generator nella documentazione](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Git/) del CD Argo.

## Generatore di matrici
<a name="_matrix_generator"></a>

Combina più generatori da implementare su più dimensioni (ambienti × cluster):

```
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}}'
```

Per i dettagli sulla combinazione dei generatori, consultate [Matrix Generator](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators-Matrix/) nella documentazione di Argo CD.

## Implementazione in più regioni
<a name="_multi_region_deployment"></a>

Implementa su cluster in più regioni:

```
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
```

## Gestisci ApplicationSets
<a name="_manage_applicationsets"></a>

 **Visualizza ApplicationSets e genera applicazioni**:

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

 **Aggiorna un ApplicationSet**:

Modifica le ApplicationSet specifiche e riapplica. Argo CD aggiorna automaticamente tutte le applicazioni generate:

```
kubectl apply -f applicationset.yaml
```

 **Eliminare un ApplicationSet**:

```
kubectl delete applicationset <name> -n argocd
```

**avvertimento**  
Eliminazione ed ApplicationSet eliminazione di tutte le applicazioni generate. Se tali applicazioni lo hanno fatto`prune: true`, le relative risorse verranno eliminate anche dai cluster di destinazione.  
Per preservare le risorse distribuite durante l'eliminazione di un file ApplicationSet, impostate su `true` nelle `.syncPolicy.preserveResourcesOnDeletion` specifiche. ApplicationSet Per ulteriori informazioni, consultate [Application Pruning & Resource Deletion](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Application-Deletion/) nella documentazione del CD Argo.

**Importante**  
La ApplicationSets funzionalità di Argo CD prevede considerazioni sulla sicurezza di cui è necessario tenere conto prima di utilizzarla. ApplicationSets Per ulteriori informazioni, consultate la sezione [ApplicationSet Sicurezza](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Security/) nella documentazione del CD Argo.

## Risorse aggiuntive
<a name="_additional_resources"></a>
+  [Lavorare con Argo CD Projects](argocd-projects.md)- Organizza ApplicationSets con progetti
+  [Crea applicazioni](argocd-create-application.md)- Comprendi la configurazione dell'applicazione
+  [ApplicationSet Documentazione](https://argo-cd.readthedocs.io/en/stable/user-guide/application-set/): riferimenti e modelli completi del generatore
+  [Generator Reference](https://argo-cd.readthedocs.io/en/stable/operator-manual/applicationset/Generators/) - Specifiche dettagliate del generatore