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

# Configurare l'accesso al repository
<a name="argocd-configure-repositories"></a>

Prima di distribuire le applicazioni, configura Argo CD per accedere ai tuoi repository Git e ai registri cartografici Helm. Argo CD supporta diversi metodi di autenticazione per GitHub, GitLab Bitbucket ed ECR. AWS CodeCommit AWS 

**Nota**  
Per le integrazioni dirette dei AWS servizi (grafici ECR Helm, CodeCommit repository e CodeConnections), è possibile farvi riferimento direttamente nelle risorse dell'applicazione senza creare configurazioni di repository. Il Capability Role deve disporre delle autorizzazioni IAM richieste. Per informazioni dettagliate, vedi [Configurare le autorizzazioni di Argo CD](argocd-permissions.md).

## Prerequisiti
<a name="_prerequisites"></a>
+ È stato creato un cluster EKS con funzionalità Argo CD
+ Archivi Git contenenti manifesti di Kubernetes
+  `kubectl`configurato per comunicare con il tuo cluster

**Nota**  
 AWS CodeConnections può connettersi a server Git situati nel AWS Cloud o in locale. Per ulteriori informazioni, consulta [AWS CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/userguide/welcome.html).

## Metodi di autenticazione
<a name="_authentication_methods"></a>


| Metodo | Caso d'uso | Autorizzazioni IAM richieste | 
| --- | --- | --- | 
|   **Integrazione diretta con i servizi AWS **   | 
|  CodeCommit  |  Integrazione diretta con i AWS CodeCommit repository Git. Non è necessaria alcuna configurazione del repository.  |   `codecommit:GitPull`   | 
|  CodeConnections  |  Connect o Bitbucket con autenticazione gestita. GitHub GitLab Richiede la configurazione della connessione.  |   `codeconnections:UseConnection`   | 
|  Artefatti ECR OCI  |  Integrazione diretta con AWS ECR per grafici e immagini manifest OCI Helm. Non è necessaria alcuna configurazione del repository.  |   `arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly`   | 
|   **Configurazione del repository con credenziali**   | 
|   AWS Secrets Manager (nome utente/token)  |  Memorizza token o password di accesso personali. Abilita la rotazione delle credenziali senza accesso a Kubernetes.  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|   AWS Secrets Manager (chiave SSH)  |  Usa l'autenticazione tramite chiave SSH. Abilita la rotazione delle credenziali senza accesso a Kubernetes.  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|   AWS Secrets Manager (GitHub App)  |  GitHub Autenticazione dell'app con chiave privata. Abilita la rotazione delle credenziali senza accesso a Kubernetes.  |   `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess`   | 
|  Kubernetes Secret  |  Metodo Argo CD standard che utilizza segreti all'interno del cluster  |  Nessuna (autorizzazioni gestite da EKS Access Entry con Kubernetes RBAC)  | 

## AWS Accesso diretto ai servizi
<a name="direct_access_to_shared_aws_services"></a>

Per quanto riguarda AWS i servizi, è possibile farvi riferimento direttamente nelle risorse dell'applicazione senza creare configurazioni del repository. Il Capability Role deve disporre delle autorizzazioni IAM richieste.

### CodeCommit repository
<a name="_codecommit_repositories"></a>

Fai riferimento ai CodeCommit repository direttamente nelle applicazioni:

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  source:
    repoURL: https://git-codecommit.region.amazonaws.com/v1/repos/repository-name
    targetRevision: main
    path: kubernetes/manifests
```

Autorizzazioni necessarie per il ruolo di capacità:

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "codecommit:GitPull",
      "Resource": "arn:aws:codecommit:region:account-id:repository-name"
    }
  ]
}
```

### CodeConnections
<a name="_codeconnections"></a>

Reference GitHub o GitLab tramite Bitbucket repository. CodeConnections Il formato dell'URL del repository è derivato dall'ARN della CodeConnections connessione.

Il formato dell'URL del repository è:

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  source:
    repoURL: https://codeconnections.region.amazonaws.com/git-http/account-id/region/connection-id/owner/repository.git
    targetRevision: main
    path: kubernetes/manifests
```

Autorizzazioni necessarie per il ruolo di capacità:

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "codeconnections:UseConnection",
      "Resource": "arn:aws:codeconnections:region:account-id:connection/connection-id"
    }
  ]
}
```

### Grafici ECR Helm
<a name="_ecr_helm_charts"></a>

ECR memorizza i grafici Helm come artefatti OCI. Argo CD supporta due modi per farvi riferimento:

 **Formato Helm** (consigliato per i grafici Helm):

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-helm
  namespace: argocd
spec:
  source:
    repoURL: account-id.dkr.ecr.region.amazonaws.com/repository-name
    targetRevision: chart-version
    chart: chart-name
    helm:
      valueFiles:
        - values.yaml
```

Nota: non includere il `oci://` prefisso quando si utilizza il formato Helm. Usa il `chart` campo per specificare il nome del grafico.

 **Formato OCI** (per artefatti OCI con manifesti Kubernetes):

```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app-oci
  namespace: argocd
spec:
  source:
    repoURL: oci://account-id.dkr.ecr.region.amazonaws.com/repository-name
    targetRevision: artifact-version
    path: path-to-manifests
```

Nota: includi il prefisso quando usi il formato OCI. `oci://` Usa il `path` campo invece di. `chart`

Autorizzazioni Capability Role richieste: allega la policy gestita:

```
arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly
```

Questa politica include le autorizzazioni ECR necessarie:`ecr:GetAuthorizationToken`,, `ecr:BatchGetImage` e. `ecr:GetDownloadUrlForLayer`

## Utilizzo di AWS Secrets Manager
<a name="using_shared_aws_secrets_manager"></a>

Archivia le credenziali del repository in Secrets Manager e fai riferimento ad esse nelle configurazioni di Argo CD Repository. L'utilizzo di Secrets Manager consente la rotazione automatica delle credenziali senza richiedere l'accesso RBAC a Kubernetes: le credenziali possono essere ruotate utilizzando le autorizzazioni IAM verso Secrets Manager e Argo CD legge automaticamente i valori aggiornati.

**Nota**  
Per il riutilizzo delle credenziali su più repository (ad esempio, tutti gli archivi di un'organizzazione), utilizza i modelli di credenziali di repository con. GitHub `argocd.argoproj.io/secret-type: repo-creds` Ciò offre un'esperienza utente migliore rispetto alla creazione di segreti di repository individuali. Per ulteriori informazioni, consultate [Repository Credentials nella documentazione](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) di Argo CD.

### Autenticazione con nome utente e token
<a name="_username_and_token_authentication"></a>

Per gli archivi HTTPS con token di accesso o password personali:

 **Crea il segreto in Secrets Manager**:

```
aws secretsmanager create-secret \
  --name argocd/my-repo \
  --description "GitHub credentials for Argo CD" \
  --secret-string '{"username":"your-username","token":"your-personal-access-token"}'
```

 **Campi opzionali del certificato client TLS** (per server Git privati):

```
aws secretsmanager create-secret \
  --name argocd/my-private-repo \
  --secret-string '{
    "username":"your-username",
    "token":"your-token",
    "tlsClientCertData":"LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCi4uLgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0t",
    "tlsClientCertKey":"LS0tLS1CRUdJTiBQUklWQVRFIEtFWS0tLS0tCi4uLgotLS0tLUVORCBQUklWQVRFIEtFWS0tLS0t"
  }'
```

**Nota**  
I `tlsClientCertKey` valori `tlsClientCertData` and devono essere codificati in base 64.

 **Crea un Repository Secret facendo riferimento a Secrets** Manager:

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/my-repo-AbCdEf
  project: default
```

### autenticazione con chiave SSH
<a name="_ssh_key_authentication"></a>

Per l'accesso Git basato su SSH, memorizza la chiave privata come testo semplice (non JSON):

 **Crea il segreto con la chiave privata SSH**:

```
aws secretsmanager create-secret \
  --name argocd/my-repo-ssh \
  --description "SSH key for Argo CD" \
  --secret-string "-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
...
-----END OPENSSH PRIVATE KEY-----"
```

 **Crea un repository segreto per SSH**:

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-ssh
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: git@github.com:your-org/your-repo.git
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/my-repo-ssh-AbCdEf
  project: default
```

### GitHub Autenticazione dell'app
<a name="_github_app_authentication"></a>

Per GitHub l'autenticazione dell'app con una chiave privata:

 **Crea il segreto con le credenziali GitHub dell'app**:

```
aws secretsmanager create-secret \
  --name argocd/github-app \
  --description "GitHub App credentials for Argo CD" \
  --secret-string '{
    "githubAppPrivateKeySecret":"LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQouLi4KLS0tLS1FTkQgUlNBIFBSSVZBVEUgS0VZLS0tLS0=",
    "githubAppID":"123456",
    "githubAppInstallationID":"12345678"
  }'
```

**Nota**  
Il `githubAppPrivateKeySecret` valore deve essere codificato in base64.

 **Campo opzionale** per Enterprise: GitHub 

```
aws secretsmanager create-secret \
  --name argocd/github-enterprise-app \
  --secret-string '{
    "githubAppPrivateKeySecret":"LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQouLi4KLS0tLS1FTkQgUlNBIFBSSVZBVEUgS0VZLS0tLS0=",
    "githubAppID":"123456",
    "githubAppInstallationID":"12345678",
    "githubAppEnterpriseBaseUrl":"https://github.example.com/api/v3"
  }'
```

 **Crea un repository segreto per GitHub l'app**:

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-github-app
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/github-app-AbCdEf
  project: default
```

### Modelli di credenziali di repository
<a name="_repository_credential_templates"></a>

Per il riutilizzo delle credenziali su più repository (ad esempio, tutti gli archivi di GitHub un'organizzazione o di un utente), utilizza i modelli di credenziali di repository con. `argocd.argoproj.io/secret-type: repo-creds` Ciò offre una migliore esperienza utente rispetto alla creazione di segreti di repository individuali per ogni repository.

 **Crea un modello di credenziali di repository:**

```
apiVersion: v1
kind: Secret
metadata:
  name: github-org-creds
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repo-creds
stringData:
  type: git
  url: https://github.com/your-org
  secretArn: arn:aws:secretsmanager:us-west-2:111122223333:secret:argocd/github-org-AbCdEf
```

Questo modello di credenziali si applica a tutti gli archivi che corrispondono al prefisso URL. `https://github.com/your-org` È quindi possibile fare riferimento a qualsiasi repository di questa organizzazione in Applicazioni senza creare segreti aggiuntivi.

Per ulteriori informazioni, consultate [Repository Credentials nella documentazione](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) del CD Argo.

**Importante**  
Assicurati che al tuo IAM Capability Role sia `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` associata la policy gestita o autorizzazioni equivalenti, incluse `secretsmanager:GetSecretValue` le autorizzazioni di decrittografia KMS. Vedi per la configurazione delle policy IAM[Considerazioni su Argo CD](argocd-considerations.md).

## Usando AWS CodeConnections
<a name="using_shared_aws_codeconnections"></a>

Per CodeConnections l'integrazione, vedi[Connect ai repository Git con AWS CodeConnections](integration-codeconnections.md).

CodeConnections fornisce l'autenticazione gestita per GitHub e Bitbucket senza memorizzare le credenziali. GitLab

## Utilizzo di Kubernetes Secrets
<a name="_using_kubernetes_secrets"></a>

Archivia le credenziali direttamente in Kubernetes utilizzando il metodo Argo CD standard.

 **Per HTTPS** con token di accesso personale:

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://github.com/your-org/your-repo
  username: your-username
  password: your-personal-access-token
```

 **Per SSH:**

```
apiVersion: v1
kind: Secret
metadata:
  name: my-repo-ssh
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: git@github.com:your-org/your-repo.git
  sshPrivateKey: |
    -----BEGIN OPENSSH PRIVATE KEY-----
    ... your private key ...
    -----END OPENSSH PRIVATE KEY-----
```

## CodeCommit repository
<a name="_codecommit_repositories_2"></a>

Per AWS CodeCommit, concedi le CodeCommit autorizzazioni a IAM Capability Role ()`codecommit:GitPull`.

Configura il repository:

```
apiVersion: v1
kind: Secret
metadata:
  name: codecommit-repo
  namespace: argocd
  labels:
    argocd.argoproj.io/secret-type: repository
stringData:
  type: git
  url: https://git-codecommit.us-west-2.amazonaws.com/v1/repos/my-repo
  project: default
```

Per una configurazione dettagliata delle policy IAM, consulta[Considerazioni su Argo CD](argocd-considerations.md).

## Verifica la connessione al repository
<a name="_verify_repository_connection"></a>

Controlla lo stato della connessione tramite l'interfaccia utente di Argo CD in Impostazioni → Repository. L'interfaccia utente mostra lo stato della connessione e gli eventuali errori di autenticazione.

I Repository Secrets non includono informazioni sullo stato.

## Risorse aggiuntive
<a name="_additional_resources"></a>
+  [Registra i cluster di destinazione](argocd-register-clusters.md)- Registra i cluster di destinazione per le distribuzioni
+  [Crea applicazioni](argocd-create-application.md)- Crea la tua prima applicazione
+  [Considerazioni su Argo CD](argocd-considerations.md)- Autorizzazioni IAM e configurazione di sicurezza
+  [Archivi privati: riferimento alla configurazione del repository](https://argo-cd.readthedocs.io/en/stable/user-guide/private-repositories/) upstream