**Unterstützung für die Verbesserung dieser Seite beitragen** 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Repository-Zugriff konfigurieren
<a name="argocd-configure-repositories"></a>

Bevor Sie Anwendungen bereitstellen, konfigurieren Sie Argo CD für den Zugriff auf Ihre Git-Repositorys und Helm-Chart-Registries. Argo CD unterstützt mehrere Authentifizierungsmethoden für GitHub, GitLab, Bitbucket und ECR. AWS CodeCommit AWS 

**Anmerkung**  
Bei direkten AWS Serviceintegrationen (ECR-Helm-Diagramme, CodeCommit Repositorys und CodeConnections) können Sie direkt in den Anwendungsressourcen darauf verweisen, ohne Repository-Konfigurationen erstellen zu müssen. Die Capability-Rolle muss über die erforderlichen IAM-Berechtigungen verfügen. Details dazu finden Sie unter [Argo-CD-Berechtigungen konfigurieren](argocd-permissions.md).

## Voraussetzungen
<a name="_prerequisites"></a>
+ Es wurde ein EKS-Cluster mit der Argo-CD-Funktion erstellt
+ Git-Repositorys, die Kubernetes-Manifeste enthalten
+  `kubectl`konfiguriert für die Kommunikation mit Ihrem Cluster

**Anmerkung**  
 AWS CodeConnections kann eine Verbindung zu Git-Servern herstellen, die sich in der AWS Cloud oder vor Ort befinden. Weitere Informationen finden Sie unter [AWS CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/userguide/welcome.html).

## Authentifizierungsmethoden
<a name="_authentication_methods"></a>


<table>
<thead>
  <tr><th>Methode</th><th>Anwendungsfall</th><th>Erforderliche IAM-Berechtigungen</th></tr>
</thead>
<tbody>
  <tr><td colspan="3"> **Direkte Integration mit Diensten AWS ** </td></tr>
  <tr><td>CodeCommit</td><td>Direkte Integration mit AWS CodeCommit Git-Repositorys. Keine Repository-Konfiguration erforderlich.</td><td> `codecommit:GitPull` </td></tr>
  <tr><td>CodeConnections</td><td>Stellen Sie mit verwalteter Authentifizierung eine Connect zu GitHub GitLab, oder Bitbucket her. Erfordert eine Verbindungseinrichtung.</td><td> `codeconnections:UseConnection` </td></tr>
  <tr><td>ECR OCI-Artefakte</td><td>Direkte Integration mit AWS ECR für OCI Helm-Diagramme und Manifestbilder. Keine Repository-Konfiguration erforderlich.</td><td> `arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly` </td></tr>
  <tr><td colspan="3"> **Repository-Konfiguration mit Anmeldeinformationen** </td></tr>
  <tr><td> AWS Secrets Manager (Benutzername/Token)</td><td>Speichern Sie persönliche Zugriffstoken oder Passwörter. Ermöglicht die Rotation von Anmeldeinformationen ohne Kubernetes-Zugriff.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td> AWS Secrets Manager (SSH-Schlüssel)</td><td>Verwenden Sie die SSH-Schlüsselauthentifizierung. Ermöglicht die Rotation von Anmeldeinformationen ohne Kubernetes-Zugriff.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td> AWS Secrets Manager (GitHub App)</td><td>GitHub App-Authentifizierung mit privatem Schlüssel. Ermöglicht die Rotation von Anmeldeinformationen ohne Kubernetes-Zugriff.</td><td> `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` </td></tr>
  <tr><td>Kubernetes-Geheimnis</td><td>Standard-Argo-CD-Methode mit Cluster-internen Geheimnissen</td><td>Keine (Berechtigungen werden von EKS Access Entry mit Kubernetes RBAC verwaltet)</td></tr>
</tbody>
</table>


## Direkter Zugriff auf Dienste AWS
<a name="direct_access_to_shared_aws_services"></a>

 AWS Dienste können Sie direkt in den Anwendungsressourcen referenzieren, ohne Repository-Konfigurationen erstellen zu müssen. Die Capability-Rolle muss über die erforderlichen IAM-Berechtigungen verfügen.

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

 CodeCommit Referenz-Repositorien direkt in Anwendungen:

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

Erforderliche Berechtigungen für Capability Role:

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

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

Referenz GitHub - GitLab oder Bitbucket-Repositorys durch. CodeConnections Das Repository-URL-Format wird vom CodeConnections Verbindungs-ARN abgeleitet.

Das Repository-URL-Format ist:

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

Erforderliche Berechtigungen für Capability Role:

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

### ECR-Helm-Diagramme
<a name="_ecr_helm_charts"></a>

ECR speichert Helm-Diagramme als OCI-Artefakte. Argo CD unterstützt zwei Möglichkeiten, auf sie zu verweisen:

 **Helm-Format** (empfohlen für Helm-Charts):

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

Hinweis: Geben Sie das `oci://` Präfix nicht an, wenn Sie das Helm-Format verwenden. Verwenden Sie das `chart` Feld, um den Namen des Diagramms anzugeben.

 **OCI-Format** (für OCI-Artefakte mit Kubernetes-Manifesten):

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

Hinweis: Geben Sie das `oci://` Präfix an, wenn Sie das OCI-Format verwenden. Verwenden Sie das `path` Feld anstelle von. `chart`

Erforderliche Berechtigungen für Capability Role — fügen Sie die verwaltete Richtlinie an:

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

Diese Richtlinie umfasst die erforderlichen ECR-Berechtigungen: `ecr:GetAuthorizationToken``ecr:BatchGetImage`, und`ecr:GetDownloadUrlForLayer`.

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

Speichern Sie die Repository-Anmeldeinformationen in Secrets Manager und referenzieren Sie sie in den Argo CD Repository-Konfigurationen. Die Verwendung von Secrets Manager ermöglicht die automatische Rotation von Anmeldeinformationen, ohne dass Kubernetes RBAC-Zugriff erforderlich ist. Anmeldeinformationen können mithilfe von IAM-Berechtigungen an Secrets Manager rotiert werden, und Argo CD liest die aktualisierten Werte automatisch.

**Anmerkung**  
Für die Wiederverwendung von Anmeldeinformationen in mehreren Repositorys (z. B. für alle Repositorys innerhalb einer Organisation) verwenden Sie Vorlagen für Repository-Anmeldeinformationen mit. GitHub `argocd.argoproj.io/secret-type: repo-creds` Dies bietet eine bessere Benutzererfahrung als die Erstellung einzelner Repository-Geheimnisse. Weitere Informationen finden Sie unter [Repository-Anmeldeinformationen](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) in der Argo-CD-Dokumentation.

### Authentifizierung mit Benutzername und Token
<a name="_username_and_token_authentication"></a>

Für HTTPS-Repositorys mit persönlichen Zugriffstoken oder Passwörtern:

 **Erstellen Sie das Geheimnis 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"}'
```

 **Optionale Felder für TLS-Client-Zertifikate** (für private Git-Server):

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

**Anmerkung**  
Die `tlsClientCertKey` Werte `tlsClientCertData` und müssen base64-codiert sein.

 **Erstellen Sie ein Repository-Geheimnis, das auf Secrets Manager verweist**:

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

### SSH-Schlüsselauthentifizierung
<a name="_ssh_key_authentication"></a>

Für SSH-basierten Git-Zugriff speichern Sie den privaten Schlüssel als Klartext (nicht JSON):

 **Erstelle das Geheimnis mit dem privaten SSH-Schlüssel**:

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

 **Erstellen Sie ein Repository-Geheimnis für 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 App-Authentifizierung
<a name="_github_app_authentication"></a>

Für die GitHub App-Authentifizierung mit einem privaten Schlüssel:

 **Erstellen Sie das Geheimnis mit den Anmeldeinformationen für die GitHub App**:

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

**Anmerkung**  
Der `githubAppPrivateKeySecret` Wert muss Base64-codiert sein.

 **Optionales Feld für 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"
  }'
```

 **Erstellen Sie einen geheimen Repository-Schlüssel für die GitHub 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
```

### Vorlagen für Repository-Anmeldeinformationen
<a name="_repository_credential_templates"></a>

Für die Wiederverwendung von Anmeldeinformationen in mehreren Repositorys (z. B. für alle Repositorys einer GitHub Organisation oder eines Benutzers) verwenden Sie Vorlagen für Repository-Anmeldeinformationen mit. `argocd.argoproj.io/secret-type: repo-creds` Dies bietet eine bessere Benutzererfahrung als die Erstellung von individuellen Repository-Geheimnissen für jedes Repository.

 **Erstellen Sie eine Vorlage für Repository-Anmeldeinformationen**:

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

Diese Vorlage für Anmeldeinformationen gilt für alle Repositorys, die dem URL-Präfix entsprechen. `https://github.com/your-org` Sie können dann in Anwendungen auf jedes Repository dieser Organisation verweisen, ohne zusätzliche Geheimnisse zu erstellen.

Weitere Informationen finden Sie unter [Repository-Anmeldeinformationen](https://argo-cd.readthedocs.io/en/stable/operator-manual/argocd-repo-creds-yaml/) in der Argo-CD-Dokumentation.

**Wichtig**  
Stellen Sie sicher, dass Ihrer IAM-Capability-Rolle die verwaltete Richtlinie oder gleichwertige Berechtigungen, einschließlich `secretsmanager:GetSecretValue` KMS-Entschlüsselungsberechtigungen, `arn:aws:iam::aws:policy/AWSSecretsManagerClientReadOnlyAccess` zugewiesen sind. Informationen [Überlegungen zu Argo CD](argocd-considerations.md) zur Konfiguration der IAM-Richtlinie finden Sie unter.

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

Informationen zur CodeConnections Integration finden Sie unter[Connect zu Git-Repositorys her mit AWS CodeConnections](integration-codeconnections.md).

CodeConnections bietet verwaltete Authentifizierung für GitHub GitLab, und Bitbucket, ohne Anmeldeinformationen zu speichern.

## Verwendung von Kubernetes Secrets
<a name="_using_kubernetes_secrets"></a>

Speichern Sie Anmeldeinformationen mithilfe der Standard-Argo-CD-Methode direkt in Kubernetes.

 **Für HTTPS mit persönlichem Zugriffstoken**:

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

 **Für 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 Repositorien
<a name="_codecommit_repositories_2"></a>

Erteilen Sie für AWS CodeCommit Ihre CodeCommit IAM-Capability-Rollenberechtigungen ()`codecommit:GitPull`.

Konfigurieren Sie das 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
```

Eine detaillierte Konfiguration der IAM-Richtlinien finden Sie unter[Überlegungen zu Argo CD](argocd-considerations.md).

## Überprüfen Sie die Verbindung zum Repository
<a name="_verify_repository_connection"></a>

Überprüfen Sie den Verbindungsstatus über die Benutzeroberfläche von Argo CD unter Einstellungen → Repositories. Die Benutzeroberfläche zeigt den Verbindungsstatus und alle Authentifizierungsfehler an.

Repository Secrets enthalten keine Statusinformationen.

## Weitere Ressourcen
<a name="_additional_resources"></a>
+  [Zielcluster registrieren](argocd-register-clusters.md)— Registrieren Sie Zielcluster für Bereitstellungen
+  [Anwendungen erstellen](argocd-create-application.md)- Erstellen Sie Ihre erste Anwendung
+  [Überlegungen zu Argo CD](argocd-considerations.md)- IAM-Berechtigungen und Sicherheitskonfiguration
+  [Private Repositorys](https://argo-cd.readthedocs.io/en/stable/user-guide/private-repositories/) — Referenz zur Konfiguration des Upstream-Repositorys