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

# Configuration de l'accès au référentiel
<a name="argocd-configure-repositories"></a>

Avant de déployer des applications, configurez Argo CD pour accéder à vos référentiels Git et à vos registres de diagrammes Helm. Argo CD prend en charge plusieurs méthodes d'authentification pour GitHub GitLab, Bitbucket et AWS CodeCommit AWS ECR.

**Note**  
Pour les intégrations de AWS services directes (graphiques ECR Helm, CodeCommit référentiels, etc. CodeConnections), vous pouvez les référencer directement dans les ressources de l'application sans créer de configurations de référentiel. Le rôle de capacité doit disposer des autorisations IAM requises. Consultez [Configurer les autorisations d'Argo CD](argocd-permissions.md) pour plus de détails.

## Conditions préalables
<a name="_prerequisites"></a>
+ Création d'un cluster EKS doté de la fonctionnalité Argo CD
+ Référentiels Git contenant des manifestes Kubernetes
+  `kubectl`configuré pour communiquer avec votre cluster

**Note**  
 AWS CodeConnections peut se connecter à des serveurs Git situés dans AWS le cloud ou sur site. Pour de plus amples informations, veuillez consulter [AWS CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/userguide/welcome.html).

## Méthodes d’authentification
<a name="_authentication_methods"></a>


<table>
<thead>
  <tr><th>Method</th><th>Cas d’utilisation</th><th>Autorisations IAM nécessaires</th></tr>
</thead>
<tbody>
  <tr><td colspan="3"> **Intégration directe aux AWS services** </td></tr>
  <tr><td>CodeCommit</td><td>Intégration directe avec les référentiels AWS CodeCommit Git. Aucune configuration du référentiel n'est nécessaire.</td><td> `codecommit:GitPull` </td></tr>
  <tr><td>CodeConnections</td><td>Connectez-vous à GitHub Bitbucket ou connectez-vous à Bitbucket grâce à l'authentification gérée. GitLab Nécessite la configuration de la connexion.</td><td> `codeconnections:UseConnection` </td></tr>
  <tr><td>Artefacts OCI ECR</td><td>Intégration directe avec AWS ECR pour les graphiques OCI Helm et les images de manifeste. Aucune configuration du référentiel n'est nécessaire.</td><td> `arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly` </td></tr>
  <tr><td colspan="3"> **Configuration du référentiel avec informations d'identification** </td></tr>
  <tr><td> AWS Secrets Manager (nom d'utilisateur/jeton)</td><td>Stockez des jetons d'accès ou des mots de passe personnels. Permet la rotation des informations d'identification sans accès à Kubernetes.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td> AWS Gestionnaire de Secrets (clé SSH)</td><td>Utilisez l'authentification par clé SSH. Permet la rotation des informations d'identification sans accès à Kubernetes.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td> AWS Secrets Manager (GitHub App)</td><td>GitHub Authentification de l'application avec clé privée. Permet la rotation des informations d'identification sans accès à Kubernetes.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td>Le secret de Kubernetes</td><td>Méthode Argo CD standard utilisant des secrets intégrés au cluster</td><td>Aucune (autorisations gérées par EKS Access Entry avec Kubernetes RBAC)</td></tr>
</tbody>
</table>


## Accès direct aux AWS services
<a name="direct_access_to_shared_aws_services"></a>

Pour les AWS services, vous pouvez les référencer directement dans les ressources de l'application sans créer de configurations de référentiel. Le rôle de capacité doit disposer des autorisations IAM requises.

### CodeCommit référentiels
<a name="_codecommit_repositories"></a>

 CodeCommit Référencez les référentiels directement dans les applications :

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

Autorisations de rôle de capacité requises :

```
{
  "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 GitLab, ou référentiels Bitbucket via. CodeConnections Le format de l'URL du référentiel est dérivé de l'ARN de CodeConnections connexion.

Le format de l'URL du référentiel est le suivant :

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

Autorisations de rôle de capacité requises :

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

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

L'ECR stocke les diagrammes Helm sous forme d'artefacts OCI. Argo CD permet de les référencer de deux manières :

 **Format Helm** (recommandé pour les diagrammes 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
```

Remarque : N'incluez pas le `oci://` préfixe lorsque vous utilisez le format Helm. Utilisez le `chart` champ pour spécifier le nom du graphique.

 **Format OCI** (pour les artefacts OCI avec des manifestes 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}}
```

Remarque : Incluez le `oci://` préfixe lorsque vous utilisez le format OCI. Utilisez le `path` champ au lieu de`chart`.

Autorisations de rôle de capacité requises : attachez la politique gérée :

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

Cette politique inclut les autorisations ECR nécessaires : `ecr:GetAuthorizationToken``ecr:BatchGetImage`, et`ecr:GetDownloadUrlForLayer`.

## Utilisation de AWS Secrets Manager
<a name="using_shared_aws_secrets_manager"></a>

Stockez les informations d'identification du référentiel dans Secrets Manager et référencez-les dans les configurations du référentiel Argo CD. L'utilisation de Secrets Manager permet une rotation automatique des informations d'identification sans nécessiter l'accès à Kubernetes RBAC. Les informations d'identification peuvent être modifiées à l'aide des autorisations IAM vers Secrets Manager, et Argo CD lit automatiquement les valeurs mises à jour.

**Note**  
Pour la réutilisation des informations d'identification dans plusieurs référentiels (par exemple, tous les référentiels d'une GitHub organisation), utilisez des modèles d'informations d'identification de référentiel avec. `argocd.argoproj.io/secret-type: repo-creds` Cela fournit une meilleure expérience utilisateur que la création de secrets de dépôt individuels. Pour plus d'informations, consultez la section Informations [d'identification du référentiel](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) dans la documentation Argo CD.

### Authentification par nom d'utilisateur et token
<a name="_username_and_token_authentication"></a>

Pour les référentiels HTTPS dotés de jetons d'accès ou de mots de passe personnels :

 **Créez le secret dans 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"}'
```

 **Champs de certificat client TLS facultatifs** (pour les serveurs Git privés) :

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

**Note**  
Les `tlsClientCertKey` valeurs `tlsClientCertData` et doivent être codées en base64.

 **Créez un secret de dépôt faisant référence à 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
```

### Authentification par clé SSH
<a name="_ssh_key_authentication"></a>

Pour un accès Git basé sur SSH, stockez la clé privée en texte brut (et non en JSON) :

 **Créez le secret avec la clé privée 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-----"
```

 **Créez un secret de dépôt pour 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 Authentification par application
<a name="_github_app_authentication"></a>

Pour GitHub l'authentification des applications à l'aide d'une clé privée :

 **Créez le secret à l'aide des informations d'identification de GitHub l'application** :

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

**Note**  
La `githubAppPrivateKeySecret` valeur doit être codée en base64.

 **Champ facultatif pour GitHub Enterprise** :

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

 **Créez un secret de dépôt pour GitHub l'application** :

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

### Modèles d'informations d'identification du référentiel
<a name="_repository_credential_templates"></a>

Pour la réutilisation des informations d'identification dans plusieurs référentiels (par exemple, tous les référentiels d'une GitHub organisation ou d'un utilisateur), utilisez des modèles d'informations d'identification de référentiel avec. `argocd.argoproj.io/secret-type: repo-creds` Cela fournit une meilleure expérience utilisateur que la création de secrets de dépôt individuels pour chaque référentiel.

 **Créez un modèle d'identification de référentiel** :

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

Ce modèle d'identification s'applique à tous les référentiels correspondant au préfixe d'URL. `https://github.com/your-org` Vous pouvez ensuite référencer n'importe quel référentiel relevant de cette organisation dans Applications sans créer de secrets supplémentaires.

Pour plus d'informations, consultez la section Informations [d'identification du référentiel](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) dans la documentation Argo CD.

**Important**  
Assurez-vous que votre rôle de capacité IAM est `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` associé à la politique gérée ou à des autorisations équivalentes, y compris `secretsmanager:GetSecretValue` des autorisations de déchiffrement KMS. Voir [Considérations relatives à Argo CD](argocd-considerations.md) pour la configuration de la politique IAM.

## En utilisant AWS CodeConnections
<a name="using_shared_aws_codeconnections"></a>

Pour CodeConnections l'intégration, voir[Connectez-vous aux référentiels Git avec AWS CodeConnections](integration-codeconnections.md).

CodeConnections fournit une authentification gérée pour GitHub GitLab, et Bitbucket sans stocker les informations d'identification.

## Utilisation des secrets de Kubernetes
<a name="_using_kubernetes_secrets"></a>

Stockez les informations d'identification directement dans Kubernetes à l'aide de la méthode Argo CD standard.

 **Pour le protocole HTTPS avec jeton d'accès personnel** :

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

 **Pour 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 référentiels
<a name="_codecommit_repositories_2"></a>

Pour AWS CodeCommit, accordez les CodeCommit autorisations de votre rôle de capacité IAM (`codecommit:GitPull`).

Configurez le référentiel :

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

Pour une configuration détaillée de la politique IAM, consultez[Considérations relatives à Argo CD](argocd-considerations.md).

## Vérifier la connexion au référentiel
<a name="_verify_repository_connection"></a>

Vérifiez l'état de la connexion via l'interface utilisateur d'Argo CD sous Paramètres → Référentiels. L'interface utilisateur indique l'état de la connexion et les éventuelles erreurs d'authentification.

Les secrets du référentiel n'incluent pas d'informations sur le statut.

## Ressources supplémentaires
<a name="_additional_resources"></a>
+  [Enregistrer les clusters cibles](argocd-register-clusters.md)- Enregistrez les clusters cibles pour les déploiements
+  [Création d'applications](argocd-create-application.md)- Créez votre première application
+  [Considérations relatives à Argo CD](argocd-considerations.md)- Autorisations IAM et configuration de sécurité
+  [Référentiels privés - Référence](https://argo-cd.readthedocs.io/en/stable/user-guide/private-repositories/) de configuration des référentiels en amont