**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à.

# Creazione di applicazioni
<a name="argocd-create-application"></a>

Le applicazioni rappresentano distribuzioni nei cluster di destinazione. Ogni applicazione definisce una fonte (repository Git) e una destinazione (cluster e namespace). Una volta applicato, Argo CD creerà le risorse specificate dai manifest nel repository Git nello spazio dei nomi del cluster. Le applicazioni spesso specificano le distribuzioni dei carichi di lavoro, ma possono gestire qualsiasi risorsa Kubernetes disponibile nel cluster di destinazione.

## 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)
+ Cluster di destinazione registrato (vedi[Registra i cluster di destinazione](argocd-register-clusters.md))
+  `kubectl`configurato per comunicare con il cluster

## Crea un'applicazione di base
<a name="_create_a_basic_application"></a>

Definisci un'applicazione che viene distribuita da un repository Git:

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: guestbook
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/argoproj/argocd-example-apps
    targetRevision: HEAD
    path: guestbook
  destination:
    name: in-cluster
    namespace: default
```

**Nota**  
Usalo `destination.name` con il nome del cluster che hai usato durante la registrazione del cluster (come `in-cluster` per il cluster locale). Il `destination.server` campo funziona anche con gli ARN dei cluster EKS, ma si consiglia di utilizzare i nomi dei cluster per una migliore leggibilità.

Applica l'applicazione:

```
kubectl apply -f application.yaml
```

Visualizza lo stato dell'applicazione:

```
kubectl get application guestbook -n argocd
```

## Configurazione dell'origine
<a name="_source_configuration"></a>

 **Archivio Git**:

```
spec:
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: main
    path: kubernetes/manifests
```

 **Tag o commit Git specifici**:

```
spec:
  source:
    targetRevision: v1.2.0  # or commit SHA
```

 **Diagramma di Helm**:

```
spec:
  source:
    repoURL: https://github.com/example/helm-charts
    targetRevision: main
    path: charts/my-app
    helm:
      valueFiles:
      - values.yaml
      parameters:
      - name: image.tag
        value: v1.2.0
```

 **Grafico Helm con valori dal repository Git esterno (modello** multi-source):

```
spec:
  sources:
  - repoURL: https://github.com/example/helm-charts
    targetRevision: main
    path: charts/my-app
    helm:
      valueFiles:
      - $values/environments/production/values.yaml
  - repoURL: https://github.com/example/config-repo
    targetRevision: main
    ref: values
```

Per ulteriori informazioni, consultate [Helm Value Files from External Git Repository](https://argo-cd.readthedocs.io/en/stable/user-guide/multiple_sources/#helm-value-files-from-external-git-repository) nella documentazione del CD Argo.

 **Diagramma Helm tratto da ECR:**

```
spec:
  source:
    repoURL: oci://{{account-id}}.dkr.ecr.{{region}}.amazonaws.com/{{repository-name}}
    targetRevision: {{chart-version}}
    chart: {{chart-name}}
```

Se il Capability Role dispone delle autorizzazioni ECR richieste, il repository viene utilizzato direttamente e non è richiesta alcuna configurazione del repository. Per informazioni dettagliate, vedi [Configurare l'accesso al repository](argocd-configure-repositories.md).

 **Repository Git da CodeCommit**:

```
spec:
  source:
    repoURL: https://git-codecommit.{{region}}.amazonaws.com/v1/repos/{{repository-name}}
    targetRevision: main
    path: kubernetes/manifests
```

Se il Capability Role dispone delle CodeCommit autorizzazioni richieste, il repository viene utilizzato direttamente e non è richiesta alcuna configurazione del repository. Per informazioni dettagliate, vedi [Configurare l'accesso al repository](argocd-configure-repositories.md).

 **Repository Git da CodeConnections**:

```
spec:
  source:
    repoURL: https://codeconnections.{{region}}.amazonaws.com/git-http/{{account-id}}/{{region}}/{{connection-id}}/{{owner}}/{{repository}}.git
    targetRevision: main
    path: kubernetes/manifests
```

Il formato dell'URL del repository è derivato dall'ARN della CodeConnections connessione. Se il Capability Role dispone delle CodeConnections autorizzazioni richieste ed è configurata una connessione, il repository viene utilizzato direttamente e non è richiesta alcuna configurazione del repository. Per informazioni dettagliate, vedi [Configurare l'accesso al repository](argocd-configure-repositories.md).

 **Personalizza:**

```
spec:
  source:
    repoURL: https://github.com/example/kustomize-app
    targetRevision: main
    path: overlays/production
    kustomize:
      namePrefix: prod-
```

## Politiche di sincronizzazione
<a name="_sync_policies"></a>

Controlla il modo in cui Argo CD sincronizza le applicazioni.

 **Sincronizzazione manuale (impostazione predefinita)**:

Le applicazioni richiedono l'approvazione manuale per la sincronizzazione:

```
spec:
  syncPolicy: {}  # No automated sync
```

Attiva manualmente la sincronizzazione:

```
kubectl patch application guestbook -n argocd \
  --type merge \
  --patch '{"operation": {"initiatedBy": {"username": "admin"}, "sync": {}}}'
```

 **Sincronizzazione automatica**:

Le applicazioni si sincronizzano automaticamente quando vengono rilevate modifiche a Git:

```
spec:
  syncPolicy:
    automated: {}
```

 **Self-healing**:

Ripristina automaticamente le modifiche manuali al cluster:

```
spec:
  syncPolicy:
    automated:
      selfHeal: true
```

Se abilitato, Argo CD ripristina qualsiasi modifica manuale apportata direttamente al cluster, assicurando che Git rimanga la fonte della verità.

 **Potatura:**

Elimina automaticamente le risorse rimosse da Git:

```
spec:
  syncPolicy:
    automated:
      prune: true
```

**avvertimento**  
Il pruning eliminerà le risorse dal cluster. Usare con cautela negli ambienti di produzione.

 **Sincronizzazione automatica combinata**:

```
spec:
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
    - CreateNamespace=true
```

 **Riprova la configurazione**:

Configura il comportamento dei tentativi di ripetizione per le sincronizzazioni non riuscite:

```
spec:
  syncPolicy:
    retry:
      limit: 5  # Number of failed sync attempts; unlimited if less than 0
      backoff:
        duration: 5s  # Amount to back off (default unit: seconds, also supports "2m", "1h")
        factor: 2  # Factor to multiply the base duration after each failed retry
        maxDuration: 3m  # Maximum amount of time allowed for the backoff strategy
```

Ciò è particolarmente utile per le risorse che dipendono dalla creazione iniziale dei CRD o quando si lavora con istanze kro in cui il CRD potrebbe non essere immediatamente disponibile.

## Opzioni di sincronizzazione
<a name="_sync_options"></a>

Configurazione di sincronizzazione aggiuntiva:

 **Crea lo spazio dei nomi se non esiste**:

```
spec:
  syncPolicy:
    syncOptions:
    - CreateNamespace=true
```

 **Salta la corsa a secco per** le risorse mancanti:

Utile quando si applicano risorse che dipendono da CRD che non esistono ancora (come le istanze kro):

```
spec:
  syncPolicy:
    syncOptions:
    - SkipDryRunOnMissingResource=true
```

Questo può essere applicato anche a risorse specifiche utilizzando un'etichetta sulla risorsa stessa.

 **Convalida le risorse prima di applicarle**:

```
spec:
  syncPolicy:
    syncOptions:
    - Validate=true
```

 **Applica solo non sincronizzato**:

```
spec:
  syncPolicy:
    syncOptions:
    - ApplyOutOfSyncOnly=true
```

## Funzionalità di sincronizzazione avanzate
<a name="_advanced_sync_features"></a>

Argo CD supporta funzionalità di sincronizzazione avanzate per implementazioni complesse:
+  **Sync waves**: controlla l'ordine di creazione delle risorse con le annotazioni `argocd.argoproj.io/sync-wave`
+  **Sync hooks**: esegui i lavori prima o dopo la sincronizzazione con `argocd.argoproj.io/hook` le annotazioni (PreSync,,) PostSync SyncFail
+  **Valutazione dello stato delle risorse**: controlli di integrità personalizzati per le risorse specifiche dell'applicazione

Per i dettagli, consultate [Sync Waves](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/) e [Resource Hooks nella documentazione](https://argo-cd.readthedocs.io/en/stable/user-guide/resource_hooks/) del CD Argo.

## Ignora le differenze
<a name="_ignore_differences"></a>

Impedisci ad Argo CD di sincronizzare campi specifici gestiti da altri controller (come HPA che gestisce le repliche):

```
spec:
  ignoreDifferences:
  - group: apps
    kind: Deployment
    jsonPointers:
    - /spec/replicas
```

Per i dettagli sugli schemi di ignoramento e sulle esclusioni dei campi, consultate [Diffing](https://argo-cd.readthedocs.io/en/stable/user-guide/diffing/) Customization nella documentazione del CD Argo.

## Multi-environment distribuzione
<a name="_multi_environment_deployment"></a>

Implementa la stessa applicazione in più ambienti:

 **Sviluppo**:

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-dev
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: develop
    path: overlays/development
  destination:
    name: dev-cluster
    namespace: my-app
```

 **Produzione**:

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-prod
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/example/my-app
    targetRevision: main
    path: overlays/production
  destination:
    name: prod-cluster
    namespace: my-app
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
```

## Monitora e gestisci le applicazioni
<a name="_monitor_and_manage_applications"></a>

 **Visualizza lo stato dell'applicazione**:

```
kubectl get application my-app -n argocd
```

 **Accedi all'interfaccia utente di Argo CD:**

Apri l'interfaccia utente di Argo CD tramite la console EKS per visualizzare la topologia dell'applicazione, lo stato di sincronizzazione, lo stato delle risorse e la cronologia di distribuzione. Vedi [Lavorare con Argo CD](working-with-argocd.md) per le istruzioni di accesso all'interfaccia utente.

 **Applicazioni di rollback**:

Ripristina una revisione precedente utilizzando l'interfaccia utente di Argo CD, l'Argo CD CLI o aggiornando le specifiche `targetRevision` dell'applicazione a un commit o tag Git precedente.

Utilizzo dell'Argo CD CLI:

```
argocd app rollback argocd/my-app <revision-id>
```

**Nota**  
Quando si utilizza l'Argo CD CLI con la funzionalità gestita, specificare le applicazioni con il prefisso dello spazio dei nomi:. `namespace/appname`

Per ulteriori informazioni, consulta il rollback dell'[app argocd](https://argo-cd.readthedocs.io/en/stable/user-guide/commands/argocd_app_rollback/) nella documentazione di Argo CD.

## Risorse aggiuntive
<a name="_additional_resources"></a>
+  [Lavorare con Argo CD Projects](argocd-projects.md)- Organizza le applicazioni con Projects per ambienti multi-tenant
+  [Usa ApplicationSets](argocd-applicationsets.md)- Implementa su più cluster con modelli
+  [Specifiche dell'applicazione: riferimento](https://argo-cd.readthedocs.io/en/stable/user-guide/application-specification/) completo all'API dell'applicazione
+  [Opzioni di sincronizzazione](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/): configurazione di sincronizzazione avanzata