**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.
# Kontinuierlicher Einsatz mit Argo CD
Argo CD ist ein deklaratives Tool zur GitOps kontinuierlichen Bereitstellung für Kubernetes. Mit Argo CD können Sie die Bereitstellung und das Lebenszyklusmanagement Ihrer Anwendungen in mehreren Clustern und Umgebungen automatisieren. Argo CD unterstützt mehrere Quelltypen, darunter Git-Repositorys, Helm-Registries (HTTP und OCI) und OCI-Images, was Unternehmen mit unterschiedlichen Sicherheits- und Compliance-Anforderungen Flexibilität bietet.
Dank der EKS-Funktionen wird Argo CD vollständig verwaltet AWS, sodass Sie keine Argo-CD-Controller und deren Abhängigkeiten von Ihren Clustern installieren, warten und skalieren müssen.
## Wie funktioniert Argo CD
Argo CD folgt dem GitOps Muster, bei dem Ihre Anwendungsquelle (Git-Repository, Helm-Registry oder OCI-Image) die Quelle der Wahrheit für die Definition des gewünschten Anwendungsstatus ist. Wenn Sie eine `Application` Argo-CD-Ressource erstellen, geben Sie die Quelle an, die Ihre Anwendungsmanifeste enthält, sowie den Kubernetes-Zielcluster und -Namespace. Argo CD überwacht kontinuierlich sowohl den Quell- als auch den Live-Status im Cluster und synchronisiert automatisch alle Änderungen, um sicherzustellen, dass der Clusterstatus dem gewünschten Status entspricht.
**Anmerkung**
Mit der EKS-Funktion für Argo CD läuft die Argo-CD-Software auf der AWS Steuerungsebene, nicht auf Ihren Worker-Knoten. Das bedeutet, dass deine Worker-Knoten keinen direkten Zugriff auf Git-Repositorys oder Helm-Registries benötigen — die Funktion wickelt den Quellzugriff vom Konto aus ab. AWS
Argo CD bietet drei primäre Ressourcentypen:
+ **Anwendung**: Definiert eine Bereitstellung von einem Git-Repository in einem Zielcluster
+ **ApplicationSet**: Generiert mehrere Anwendungen aus Vorlagen für Bereitstellungen mit mehreren Clustern
+ **AppProject**: Bietet logische Gruppierung und Zugriffskontrolle für Anwendungen
**Beispiel: Eine Argo-CD-Anwendung erstellen**
Das folgende Beispiel zeigt, wie eine `Application` Argo-CD-Ressource erstellt wird:
```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: guestbook
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/argoproj/argocd-example-apps.git
targetRevision: HEAD
path: guestbook
destination:
name: in-cluster
namespace: guestbook
syncPolicy:
automated:
prune: true
selfHeal: true
```
**Anmerkung**
Verwenden Sie es `destination.name` zusammen mit dem Clusternamen, den Sie bei der Registrierung des Clusters verwendet haben (wie `in-cluster` für den lokalen Cluster). Das `destination.server` Feld funktioniert auch mit EKS-Clustern ARNs, aus Gründen der besseren Lesbarkeit wird jedoch die Verwendung von Clusternamen empfohlen.
## Vorteile von Argo CD
Argo CD implementiert einen GitOps Workflow, bei dem Sie Ihre Anwendungskonfigurationen in Git-Repositorys definieren und Argo CD Ihre Anwendungen automatisch synchronisiert, damit sie dem gewünschten Status entsprechen. Dieser GIT-zentrierte Ansatz bietet einen vollständigen Prüfpfad aller Änderungen, ermöglicht einfache Rollbacks und lässt sich auf natürliche Weise in Ihre bestehenden Codeüberprüfungs- und Genehmigungsprozesse integrieren. Argo CD erkennt automatisch Abweichungen zwischen dem gewünschten Status in Git und dem tatsächlichen Status in Ihren Clustern und gleicht sie ab, um sicherzustellen, dass Ihre Bereitstellungen mit Ihrer deklarierten Konfiguration konsistent bleiben.
Mit Argo CD können Sie Anwendungen in mehreren Clustern von einer einzigen Argo-CD-Instanz aus bereitstellen und verwalten, was den Betrieb in Umgebungen mit mehreren Clustern und mehreren Regionen vereinfacht. Die Benutzeroberfläche von Argo CD bietet Visualisierungs- und Überwachungsfunktionen, mit denen Sie den Bereitstellungsstatus, den Zustand und den Verlauf Ihrer Anwendungen einsehen können. Die Benutzeroberfläche ist in AWS Identity Center (ehemals AWS SSO) integriert und ermöglicht so eine nahtlose Authentifizierung und Autorisierung, sodass Sie den Zugriff mithilfe Ihrer vorhandenen Identitätsmanagement-Infrastruktur kontrollieren können.
Als Teil von EKS Managed Capabilities wird Argo CD vollständig von verwaltet AWS, sodass die Installation, Konfiguration und Wartung der Argo-CD-Infrastruktur entfällt. AWS kümmert sich um Skalierung, Patching und Betriebsmanagement, sodass sich Ihre Teams auf die Anwendungsbereitstellung statt auf die Wartung der Tools konzentrieren können.
## Integration mit AWS Identity Center
EKS Managed Capabilities bietet eine direkte Integration zwischen Argo CD und AWS Identity Center und ermöglicht so eine nahtlose Authentifizierung und Autorisierung für Ihre Benutzer. Wenn Sie die Argo CD-Funktion aktivieren, können Sie die AWS Identity Center-Integration so konfigurieren, dass Identity Center-Gruppen und -Benutzer den Argo CD RBAC-Rollen zugeordnet werden, sodass Sie kontrollieren können, wer auf Anwendungen in Argo CD zugreifen und diese verwalten kann.
## Integration mit anderen von EKS verwalteten Funktionen
Argo CD lässt sich in andere von EKS verwaltete Funktionen integrieren.
+ ** AWS Controller für Kubernetes (ACK)**: Verwenden Sie Argo CD, um die Bereitstellung von ACK-Ressourcen in mehreren Clustern zu verwalten und GitOps Workflows für Ihre Infrastruktur zu ermöglichen. AWS
+ **kro (Kube Resource Orchestrator)**: Verwenden Sie Argo CD, um Kro-Kompositionen in mehreren Clustern bereitzustellen und so eine konsistente Ressourcenzusammensetzung in Ihrem gesamten Kubernetes-Bestand zu ermöglichen.
## Erste Schritte mit Argo CD
Um mit der EKS-Funktion für Argo CD zu beginnen:
1. Erstellen und konfigurieren Sie eine IAM-Capability-Rolle mit den erforderlichen Berechtigungen, damit Argo CD auf Ihre Quellen zugreifen und Anwendungen verwalten kann.
1. [Erstellen Sie eine Argo-CD-Capability-Ressource](create-argocd-capability.md) auf Ihrem EKS-Cluster über die AWS Konsole, AWS CLI oder Ihr bevorzugtes Infrastructure-as-Code-Tool.
1. Konfigurieren Sie den Repository-Zugriff und registrieren Sie Cluster für die Anwendungsbereitstellung.
1. Erstellen Sie Anwendungsressourcen, um Ihre Anwendungen aus Ihren deklarativen Quellen bereitzustellen.
# Erstellen einer Argo CD-Funktion
In diesem Thema wird erklärt, wie Sie eine Argo-CD-Funktion auf Ihrem Amazon EKS-Cluster erstellen.
## Voraussetzungen
Bevor Sie eine Argo-CD-Funktion erstellen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Ein vorhandener Amazon EKS-Cluster, auf dem eine unterstützte Kubernetes-Version ausgeführt wird (alle Versionen mit Standard- und erweitertem Support werden unterstützt)
+ ** AWS Identity Center konfiguriert** — Für die Argo-CD-Authentifizierung erforderlich (lokale Benutzer werden nicht unterstützt)
+ Eine IAM-Fähigkeitsrolle mit Berechtigungen für Argo CD
+ Ausreichende IAM-Berechtigungen zum Erstellen von Funktionsressourcen auf EKS-Clustern
+ `kubectl`für die Kommunikation mit Ihrem Cluster konfiguriert
+ (Optional) Die Argo-CD-CLI wurde für eine einfachere Cluster- und Repositoryverwaltung installiert
+ (Für CLI/eksCTL) Das entsprechende CLI-Tool wurde installiert und konfiguriert
Anweisungen zum Erstellen der IAM-Capability-Rolle finden Sie unter. [IAM-Rolle für Amazon EKS-Funktionen](capability-role.md) Informationen zur Einrichtung von Identity Center finden Sie unter [Erste Schritte mit AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html).
**Wichtig**
Die von Ihnen angegebene IAM-Fähigkeitsrolle bestimmt, auf welche AWS Ressourcen Argo CD zugreifen kann. Dazu gehören der Zugriff auf das Git-Repository über CodeConnections und Secrets in Secrets Manager. Anleitungen zur Erstellung einer geeigneten Rolle mit den geringsten Rechten finden Sie unter und. [IAM-Rolle für Amazon EKS-Funktionen](capability-role.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Wählen Sie Ihr Tool
Sie können eine Argo-CD-Funktion mit der AWS-Managementkonsole AWS CLI oder eksctl erstellen:
+ [Erstellen Sie mit der Konsole eine Argo-CD-Funktion](argocd-create-console.md)- Verwenden Sie die Konsole für ein geführtes Erlebnis
+ [Erstellen Sie eine Argo-CD-Funktion mit der CLI AWS](argocd-create-cli.md)- Verwenden Sie die AWS CLI für Scripting und Automatisierung
+ [Erstellen Sie eine Argo-CD-Funktion mit eksctl](argocd-create-eksctl.md)- Verwenden Sie eksctl für ein Kubernetes-natives Erlebnis
## Was passiert, wenn Sie eine Argo-CD-Funktion erstellen
Wenn Sie eine Argo-CD-Funktion erstellen:
1. EKS erstellt den Argo-CD-Capability Service auf der Steuerungsebene AWS
1. Benutzerdefinierte Ressourcendefinitionen (CRDs) sind in Ihrem Cluster installiert
1. Für Ihre IAM-Capability Role wird automatisch ein Zugriffseintrag mit funktionsspezifischen Zugangsrichtlinien erstellt, die grundlegende Kubernetes-Berechtigungen gewähren (siehe) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
1. Argo CD beginnt, nach seinen benutzerdefinierten Ressourcen (Anwendungen,,) Ausschau zu halten ApplicationSets AppProjects
1. Der Funktionsstatus ändert sich von zu `CREATING` `ACTIVE`
1. Auf die Benutzeroberfläche von Argo CD kann über ihre URL zugegriffen werden
Sobald sie aktiv sind, können Sie Argo-CD-Anwendungen in Ihrem Cluster erstellen, um sie aus Ihren deklarativen Quellen bereitzustellen.
**Anmerkung**
Der automatisch erstellte Zugriffseintrag gewährt keine Berechtigungen zur Bereitstellung von Anwendungen in Clustern. Um Anwendungen bereitzustellen, müssen Sie zusätzliche Kubernetes-RBAC-Berechtigungen für jeden Zielcluster konfigurieren. Einzelheiten [Zielcluster registrieren](argocd-register-clusters.md) zur Registrierung von Clustern und zur Konfiguration des Zugriffs finden Sie unter.
## Nächste Schritte
Nach der Erstellung der Argo-CD-Funktion:
+ [Argo CD-Konzepte](argocd-concepts.md)- Erfahren Sie mehr über GitOps Prinzipien, Synchronisierungsrichtlinien und Multi-Cluster-Muster
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Konfigurieren Sie den Repository-Zugriff, registrieren Sie Zielcluster und erstellen Sie Anwendungen
+ [Überlegungen zu Argo CD](argocd-considerations.md)- Erkunden Sie Architekturmuster und erweiterte Konfigurationen mit mehreren Clustern
# Erstellen Sie mit der Konsole eine Argo-CD-Funktion
In diesem Thema wird beschrieben, wie Sie mit dem eine Argo-CD-Funktion erstellen. AWS-Managementkonsole
## Voraussetzungen
+ ** AWS Identity Center konfiguriert** — Argo CD benötigt AWS Identity Center für die Authentifizierung. Lokale Benutzer werden nicht unterstützt. Wenn Sie AWS Identity Center nicht eingerichtet haben, finden Sie weitere Informationen unter [Erste Schritte mit AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html), um eine Identity Center-Instanz zu erstellen, und [Benutzer hinzufügen](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) und [Gruppen hinzufügen](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html), um Benutzer und Gruppen für den Zugriff auf Argo CD zu erstellen.
## Erstellen Sie die Argo-CD-Funktion
1. Öffnen Sie die Amazon EKS-Konsole unter https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Wählen Sie Ihren Clusternamen aus, um die Cluster-Detailseite zu öffnen.
1. Wählen Sie die Registerkarte **Funktionen**.
1. Wählen Sie in der linken Navigationsleiste **Argo CD**.
1. Wählen Sie die Funktion „**Argo-CD erstellen**“.
1. Für die **IAM-Fähigkeitsrolle**:
+ Wenn Sie bereits über eine IAM-Fähigkeitsrolle verfügen, wählen Sie sie aus der Dropdownliste aus
+ Wenn Sie eine Rolle erstellen müssen, wählen Sie **Create Argo CD** role
Dadurch wird die IAM-Konsole auf einer neuen Registerkarte mit vorab ausgefüllten Vertrauensrichtlinien und uneingeschränktem Lesezugriff auf Secrets Manager geöffnet. Standardmäßig werden keine weiteren Berechtigungen hinzugefügt, aber Sie können sie bei Bedarf hinzufügen. Wenn Sie CodeCommit Repositorys oder andere AWS Dienste verwenden möchten, fügen Sie die entsprechenden Berechtigungen hinzu, bevor Sie die Rolle erstellen.
Kehren Sie nach dem Erstellen der Rolle zur EKS-Konsole zurück. Die Rolle wird automatisch ausgewählt.
**Anmerkung**
Wenn Sie die optionalen Integrationen mit AWS Secrets Manager oder verwenden möchten AWS CodeConnections, müssen Sie der Rolle Berechtigungen hinzufügen. Beispiele für IAM-Richtlinien und Anleitungen zur Konfiguration finden Sie unter [Anwendungsgeheimnisse mit AWS Secrets Manager verwalten](integration-secrets-manager.md) und. [Connect zu Git-Repositorys her mit AWS CodeConnections](integration-codeconnections.md)
1. Konfigurieren Sie die AWS Identity Center-Integration:
1. Wählen Sie ** AWS Identity Center-Integration aktivieren** aus.
1. Wählen Sie Ihre Identity Center-Instanz aus der Dropdownliste aus.
1. Konfigurieren Sie Rollenzuordnungen für RBAC, indem Sie Benutzer oder Gruppen den Argo-CD-Rollen (ADMIN, EDITOR oder VIEWER) zuweisen
1. Wählen Sie **Erstellen** aus.
Der Prozess zur Erstellung von Fähigkeiten beginnt.
## Stellen Sie sicher, dass die Fähigkeit aktiv ist
1. Sehen Sie sich auf der Registerkarte **Funktionen** den Argo-CD-Funktionsstatus an.
1. Warten Sie, bis sich der Status von `CREATING` zu `ACTIVE` ändert.
1. Sobald die Funktion aktiv ist, ist sie einsatzbereit.
Informationen zum Status der Funktionen und zur Problembehandlung finden Sie unter[Mit Capability-Ressourcen arbeiten](working-with-capabilities.md).
## Greifen Sie auf die Benutzeroberfläche von Argo CD zu
Nachdem die Funktion aktiv ist, können Sie auf die Benutzeroberfläche von Argo CD zugreifen:
1. Wählen Sie auf der Argo-CD-Funktionsseite die Option **Open Argo** CD UI.
1. Die Benutzeroberfläche von Argo CD wird in einem neuen Browser-Tab geöffnet.
1. Sie können jetzt über die Benutzeroberfläche Anwendungen erstellen und Bereitstellungen verwalten.
## Nächste Schritte
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Konfigurieren Sie Repositorys, registrieren Sie Cluster und erstellen Sie Anwendungen
+ [Überlegungen zu Argo CD](argocd-considerations.md)- Multi-Cluster-Architektur und erweiterte Konfiguration
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre Argo-CD-Funktionsressource
# Erstellen Sie eine Argo-CD-Funktion mit der CLI AWS
In diesem Thema wird beschrieben, wie Sie mit der AWS CLI eine Argo-CD-Funktion erstellen.
## Voraussetzungen
+ ** AWS CLI** — Version `2.12.3` oder höher. Führen Sie den Befehl aus, um Ihre Version zu überprüfen`aws --version`. Weitere Informationen finden Sie im Benutzerhandbuch für die AWS Befehlszeilenschnittstelle unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html).
+ ** `kubectl` ** – Ein Befehlszeilentool für die Arbeit mit Kubernetes-Clustern. Weitere Informationen finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).
+ ** AWS Identity Center konfiguriert** — Argo CD benötigt AWS Identity Center für die Authentifizierung. Lokale Benutzer werden nicht unterstützt. Wenn Sie AWS Identity Center nicht eingerichtet haben, finden Sie weitere Informationen unter [Erste Schritte mit AWS Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html), um eine Identity Center-Instanz zu erstellen, und [Benutzer hinzufügen](https://docs.aws.amazon.com/singlesignon/latest/userguide/addusers.html) und [Gruppen hinzufügen](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html), um Benutzer und Gruppen für den Zugriff auf Argo CD zu erstellen.
## Schritt 1: Erstellen Sie eine IAM-Fähigkeitsrolle
Erstellen Sie eine Vertrauensrichtliniendatei:
```
cat > argocd-trust-policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "capabilities.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
EOF
```
Erstellen Sie die IAM-Rolle:
```
aws iam create-role \
--role-name ArgoCDCapabilityRole \
--assume-role-policy-document file://argocd-trust-policy.json
```
**Anmerkung**
Wenn Sie die optionalen Integrationen mit AWS Secrets Manager oder verwenden möchten AWS CodeConnections, müssen Sie der Rolle Berechtigungen hinzufügen. Beispiele für IAM-Richtlinien und Anleitungen zur Konfiguration finden Sie unter [Anwendungsgeheimnisse mit AWS Secrets Manager verwalten](integration-secrets-manager.md) und. [Connect zu Git-Repositorys her mit AWS CodeConnections](integration-codeconnections.md)
## Schritt 2: Erstellen Sie die Argo-CD-Funktion
Erstellen Sie die Argo-CD-Capability-Ressource auf Ihrem Cluster.
Legen Sie zunächst Umgebungsvariablen für Ihre Identity Center-Konfiguration fest:
```
# Get your Identity Center instance ARN (replace region if your IDC instance is in a different region)
export IDC_INSTANCE_ARN=$(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].InstanceArn' --output text)
# Get a user ID for RBAC mapping (replace with your username and region if needed)
export IDC_USER_ID=$(aws identitystore list-users \
--region [.replaceable]`region` \
--identity-store-id $(aws sso-admin list-instances --region [.replaceable]`region` --query 'Instances[0].IdentityStoreId' --output text) \
--query 'Users[?UserName==`your-username`].UserId' --output text)
echo "IDC_INSTANCE_ARN=$IDC_INSTANCE_ARN"
echo "IDC_USER_ID=$IDC_USER_ID"
```
Erstellen Sie die Funktion mit der Identity Center-Integration. *region-code*Ersetzen Sie durch die AWS Region, in der sich Ihr Cluster befindet, sowie *my-cluster* durch Ihren Clusternamen und *idc-region-code* durch den Regionalcode, für den Ihr IAM Identity Center konfiguriert wurde:
```
aws eks create-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-argocd \
--type ARGOCD \
--role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/ArgoCDCapabilityRole \
--delete-propagation-policy RETAIN \
--configuration '{
"argoCd": {
"awsIdc": {
"idcInstanceArn": "'$IDC_INSTANCE_ARN'",
"idcRegion": "'[.replaceable]`idc-region-code`'"
},
"rbacRoleMappings": [{
"role": "ADMIN",
"identities": [{
"id": "'$IDC_USER_ID'",
"type": "SSO_USER"
}]
}]
}
}'
```
Der Befehl kehrt sofort zurück, aber es dauert einige Zeit, bis die Funktion aktiv wird, da EKS die erforderliche Funktionsinfrastruktur und die erforderlichen Komponenten erstellt. EKS installiert die benutzerdefinierten Kubernetes-Ressourcendefinitionen, die sich auf diese Funktion beziehen, in Ihrem Cluster, während dieser erstellt wird.
**Anmerkung**
Wenn Sie eine Fehlermeldung erhalten, dass der Cluster nicht existiert oder Sie keine Berechtigungen haben, überprüfen Sie Folgendes:
Der Clustername ist korrekt
Ihre AWS CLI ist für die richtige Region konfiguriert
Sie verfügen über die erforderlichen IAM-Berechtigungen
## Schritt 3: Stellen Sie sicher, dass die Funktion aktiv ist
Warten Sie, bis die Funktion aktiv wird. *region-code*Ersetzen Sie durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* durch Ihren Clusternamen.
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-argocd \
--query 'capability.status' \
--output text
```
Die Funktion ist bereit, wenn der Status angezeigt wird`ACTIVE`. Fahren Sie erst mit dem nächsten Schritt fort, wenn der Status lautet`ACTIVE`.
Sie können sich auch die vollständigen Funktionsdetails ansehen:
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-argocd
```
## Schritt 4: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte Argo CD-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep argoproj.io
```
Sie sollten die Liste der `ApplicationSet` Ressourcentypen sehen`Application`.
## Nächste Schritte
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Konfigurieren Sie Repositorys, registrieren Sie Cluster und erstellen Sie Anwendungen
+ [Überlegungen zu Argo CD](argocd-considerations.md)- Multi-Cluster-Architektur und erweiterte Konfiguration
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre Argo-CD-Funktionsressource
# Erstellen Sie eine Argo-CD-Funktion mit eksctl
In diesem Thema wird beschrieben, wie Sie mit eksctl eine Argo-CD-Funktion erstellen.
**Anmerkung**
Für die folgenden Schritte ist die Version eksctl oder höher erforderlich. `0.220.0` Führen Sie den Befehl aus, um Ihre Version zu überprüfen. `eksctl version`
## Schritt 1: Erstellen Sie eine IAM-Capability-Rolle
Erstellen Sie eine Vertrauensrichtliniendatei:
```
cat > argocd-trust-policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "capabilities.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
EOF
```
Erstellen Sie die IAM-Rolle:
```
aws iam create-role \
--role-name ArgoCDCapabilityRole \
--assume-role-policy-document file://argocd-trust-policy.json
```
**Anmerkung**
Für diese grundlegende Einrichtung sind keine zusätzlichen IAM-Richtlinien erforderlich. Wenn Sie Secrets Manager für Repository-Anmeldeinformationen oder verwenden möchten CodeConnections, müssen Sie der Rolle Berechtigungen hinzufügen. Beispiele für IAM-Richtlinien und Anleitungen zur Konfiguration finden Sie unter [Anwendungsgeheimnisse mit AWS Secrets Manager verwalten](integration-secrets-manager.md) und[Connect zu Git-Repositorys her mit AWS CodeConnections](integration-codeconnections.md).
## Schritt 2: Holen Sie sich Ihre AWS Identity Center-Konfiguration
Rufen Sie den ARN und die Benutzer-ID Ihrer Identity Center-Instanz für die RBAC-Konfiguration ab:
```
# Get your Identity Center instance ARN
aws sso-admin list-instances --query 'Instances[0].InstanceArn' --output text
# Get a user ID for admin access (replace 'your-username' with your Identity Center username)
aws identitystore list-users \
--identity-store-id $(aws sso-admin list-instances --query 'Instances[0].IdentityStoreId' --output text) \
--query 'Users[?UserName==`your-username`].UserId' --output text
```
Notieren Sie sich diese Werte — Sie benötigen sie im nächsten Schritt.
## Schritt 3: Erstellen Sie eine eksctl-Konfigurationsdatei
Erstellen Sie eine Datei mit dem Namen `argocd-capability.yaml` und dem folgenden Inhalt. Ersetzen Sie die Platzhalterwerte durch den Namen Ihres Clusters, die Cluster-Region, den IAM-Rollen-ARN, den Identity Center-Instanz-ARN, die Identity Center-Region und die Benutzer-ID:
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: my-cluster
region: cluster-region-code
capabilities:
- name: my-argocd
type: ARGOCD
roleArn: arn:aws:iam::[.replaceable]111122223333:role/ArgoCDCapabilityRole
deletePropagationPolicy: RETAIN
configuration:
argocd:
awsIdc:
idcInstanceArn: arn:aws:sso:::instance/ssoins-123abc
idcRegion: idc-region-code
rbacRoleMappings:
- role: ADMIN
identities:
- id: 38414300-1041-708a-01af-5422d6091e34
type: SSO_USER
```
**Anmerkung**
Sie können den RBAC-Zuordnungen mehrere Benutzer oder Gruppen hinzufügen. Verwenden Sie für Gruppen die Gruppen-ID `type: SSO_GROUP` und geben Sie sie an. Verfügbare Rollen sind `ADMIN``EDITOR`, und`VIEWER`.
## Schritt 4: Erstellen Sie die Argo-CD-Funktion
Wenden Sie die Konfigurationsdatei an:
```
eksctl create capability -f argocd-capability.yaml
```
Der Befehl kehrt sofort zurück, aber es dauert einige Zeit, bis die Funktion aktiv wird.
## Schritt 5: Stellen Sie sicher, dass die Funktion aktiv ist
Überprüfen Sie den Status der Fähigkeit. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters.
```
eksctl get capability \
--region region-code \
--cluster my-cluster \
--name my-argocd
```
Die Funktion ist bereit, wenn der Status angezeigt wird`ACTIVE`.
## Schritt 6: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte Argo CD-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep argoproj.io
```
Sie sollten die Liste der `ApplicationSet` Ressourcentypen sehen`Application`.
## Nächste Schritte
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Erfahren Sie, wie Sie Argo-CD-Anwendungen erstellen und verwalten
+ [Überlegungen zu Argo CD](argocd-considerations.md)- Konfigurieren Sie SSO und Multi-Cluster-Zugriff
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre Argo-CD-Funktionsressource
# Argo CD-Konzepte
Argo CD implementiert, GitOps indem es Git als zentrale Informationsquelle für Ihre Anwendungsbereitstellungen behandelt. In diesem Thema wird ein praktisches Beispiel vorgestellt und anschließend die Kernkonzepte erläutert, die Sie bei der Arbeit mit der EKS-Funktion für Argo CD verstehen müssen.
## Erste Schritte mit Argo CD
Nachdem Sie die Argo-CD-Funktion erstellt haben (siehe[Erstellen einer Argo CD-Funktion](create-argocd-capability.md)), können Sie mit der Bereitstellung von Anwendungen beginnen. In diesem Beispiel werden die Registrierung eines Clusters und die Erstellung einer Anwendung beschrieben.
### Schritt 1: Einrichten von
**Registrieren Sie Ihren Cluster** (erforderlich)
Registrieren Sie den Cluster, in dem Sie Anwendungen bereitstellen möchten. In diesem Beispiel registrieren wir denselben Cluster, auf dem Argo CD läuft (Sie können den Namen aus `in-cluster` Kompatibilitätsgründen mit den meisten Argo-CD-Beispielen verwenden):
```
# Get your cluster ARN
CLUSTER_ARN=$(aws eks describe-cluster \
--name my-cluster \
--query 'cluster.arn' \
--output text)
# Register the cluster using Argo CD CLI
argocd cluster add $CLUSTER_ARN \
--aws-cluster-name $CLUSTER_ARN \
--name in-cluster \
--project default
```
**Anmerkung**
Informationen zur Konfiguration der Argo-CD-CLI für die Verwendung mit der Argo-CD-Funktion in EKS finden Sie unter. [Verwenden der Argo-CD-CLI mit der verwalteten Funktion](argocd-comparison.md#argocd-cli-configuration)
Alternativ können Sie den Cluster mit einem Kubernetes Secret registrieren (Einzelheiten finden Sie unter[Zielcluster registrieren](argocd-register-clusters.md)).
**Konfigurieren Sie den Repository-Zugriff** (optional)
In diesem Beispiel wird ein öffentliches GitHub Repository verwendet, sodass keine Repository-Konfiguration erforderlich ist. Für private Repositorys konfigurieren Sie den Zugriff mit AWS Secrets Manager oder Kubernetes Secrets (weitere Informationen finden Sie unter[Repository-Zugriff konfigurieren](argocd-configure-repositories.md)). CodeConnections
AWS Dienste (ECR für Helm-Diagramme und CodeCommit) können Sie direkt in den Anwendungsressourcen referenzieren, ohne ein Repository zu erstellen. CodeConnections Die Capability-Rolle muss über die erforderlichen IAM-Berechtigungen verfügen. Details dazu finden Sie unter [Repository-Zugriff konfigurieren](argocd-configure-repositories.md).
### Schritt 2: Eine Anwendung erstellen
Erstellen Sie dieses Anwendungsmanifest in`my-app.yaml`:
```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: guestbook
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/argoproj/argocd-example-apps.git
targetRevision: HEAD
path: guestbook
destination:
name: in-cluster
namespace: guestbook
syncPolicy:
automated:
prune: true
selfHeal: true
syncOptions:
- CreateNamespace=true
```
Wenden Sie die Anwendung an:
```
kubectl apply -f my-app.yaml
```
Nach dem Anwenden dieser Anwendung, Argo CD: 1. Synchronisiert die Anwendung von Git mit Ihrem Cluster (erste Bereitstellung) 2. Überwacht das Git-Repository auf Änderungen 3. Synchronisiert nachfolgende Änderungen automatisch mit Ihrem Cluster 4. Erkennt und korrigiert jede Abweichung vom gewünschten Zustand 5. Zeigt den Gesundheitsstatus und den Synchronisierungsverlauf auf der Benutzeroberfläche an
Den Status der Anwendung anzeigen:
```
kubectl get application guestbook -n argocd
```
Sie können die Anwendung auch über die Argo-CD-CLI oder die Argo-CD-Benutzeroberfläche anzeigen (zugänglich über die EKS-Konsole auf der Registerkarte Capabilities Ihres Clusters).
**Anmerkung**
Wenn Sie die Argo CD-CLI mit der verwalteten Funktion verwenden, geben Sie Anwendungen mit dem Namespace-Präfix an:. `argocd app get argocd/guestbook`
**Anmerkung**
Verwenden Sie den Clusternamen in `destination.name` (den Namen, den Sie bei der Registrierung des Clusters verwendet haben). Die verwaltete Funktion unterstützt nicht die lokale Standardeinstellung im Cluster (`kubernetes.default.svc`).
## Schlüsselkonzepte
### GitOps Prinzipien und Quelltypen
Argo CD implementiert GitOps, wobei Ihre Anwendungsquelle die zentrale Informationsquelle für Implementierungen ist:
+ **Deklarativ** — Der gewünschte Status wird mithilfe von YAML-Manifesten, Helm-Diagrammen oder Kustomize-Overlays deklariert
+ **Versioniert** — Jede Änderung wird anhand eines vollständigen Prüfprotokolls nachverfolgt
+ **Automatisiert** — Argo CD überwacht kontinuierlich die Quellen und synchronisiert Änderungen automatisch
+ **Selbstheilung** — Erkennt und korrigiert Abweichungen zwischen dem gewünschten und dem tatsächlichen Clusterstatus
**Unterstützte Quelltypen:**
+ **Git-Repositorien** - GitHub, GitLab, Bitbucket, CodeCommit (HTTPS, SSH oder) CodeConnections
+ **Helm-Register** — HTTP-Register (wie`https://aws.github.io/eks-charts`) und OCI-Register (wie) `public.ecr.aws`
+ **OCI-Images — Container-Images**, die Manifeste oder Helm-Charts (ähnlich) enthalten `oci://registry-1.docker.io/user/my-app`
Diese Flexibilität ermöglicht es Unternehmen, Quellen auszuwählen, die ihren Sicherheits- und Compliance-Anforderungen entsprechen. Beispielsweise können Organisationen, die den Git-Zugriff von Clustern aus einschränken, ECR für Helm-Diagramme oder OCI-Images verwenden.
Weitere Informationen finden Sie in der Argo-CD-Dokumentation unter [Anwendungsquellen](https://argo-cd.readthedocs.io/en/stable/user-guide/application-sources/).
### Synchronisieren und Abgleichen
Argo CD überwacht kontinuierlich Ihre Quellen und Cluster, um Unterschiede zu erkennen und zu korrigieren:
1. Fragt Quellen nach Änderungen ab (Standard: alle 6 Minuten)
1. Vergleicht den gewünschten Status mit dem Clusterstatus
1. Markiert Anwendungen als `Synced` oder `OutOfSync`
1. Synchronisiert Änderungen automatisch (falls konfiguriert) oder wartet auf die manuelle Genehmigung
1. Überwacht den Zustand der Ressourcen nach der Synchronisierung
**Synchronisierungswellen** steuern die Reihenfolge der Ressourcenerstellung mithilfe von Anmerkungen:
```
metadata:
annotations:
argocd.argoproj.io/sync-wave: "0" # Default if not specified
```
Ressourcen werden in der Reihenfolge der Wellen angewendet (niedrigere Zahlen zuerst, einschließlich negativer Zahlen wie`-1`). Wave `0` ist die Standardeinstellung, sofern sie nicht angegeben ist. Auf diese Weise können Sie Abhängigkeiten wie Namespaces (Wave`-1`) vor Bereitstellungen (Wave) vor Diensten (Wave`0`) erstellen. `1`
Durch die **Selbstheilung** werden manuelle Änderungen automatisch rückgängig gemacht:
```
spec:
syncPolicy:
automated:
selfHeal: true
```
**Anmerkung**
Die verwaltete Funktion verwendet eine auf Anmerkungen basierende Ressourcenverfolgung (nicht labelbasiert), um die Kompatibilität mit Kubernetes-Konventionen und anderen Tools zu verbessern.
[Ausführliche Informationen zu Synchronisierungsphasen, Hooks und erweiterten Mustern finden Sie in der Argo CD-Synchronisierungsdokumentation.](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-waves/)
### Integrität der Anwendung
Argo CD überwacht den Zustand aller Ressourcen in Ihrer Anwendung:
**Integritätsstatus****: \$1 Fehlerfrei — Alle Ressourcen laufen wie erwartet \$1 **Fortschritt** — Ressourcen werden erstellt oder aktualisiert \$1 **Heruntergestuft** — Einige Ressourcen sind nicht fehlerfrei (Pods stürzen ab, Jobs schlagen fehl) \$1 **Suspendiert** — Anwendung wurde absichtlich angehalten \$1 **Fehlt** — In Git definierte Ressourcen sind nicht im Cluster vorhanden**
Argo CD verfügt über integrierte Integritätsprüfungen für gängige Kubernetes-Ressourcen (Deployments StatefulSets, Jobs usw.) und unterstützt benutzerdefinierte Integritätsprüfungen für. CRDs
Der Zustand einer Anwendung wird durch all ihre Ressourcen bestimmt — wenn es eine Ressource gibt`Degraded`, ist es auch die Anwendung. `Degraded`
Weitere Informationen finden Sie unter [Resource Health](https://argo-cd.readthedocs.io/en/stable/operator-manual/health/) in der Argo-CD-Dokumentation.
### Muster mit mehreren Clustern
Argo CD unterstützt zwei Hauptbereitstellungsmuster:
**H ub-and-spoke** — Führen Sie Argo CD auf einem dedizierten Management-Cluster aus, der auf mehreren Workload-Clustern bereitgestellt wird: \$1 Zentrale Steuerung und Transparenz \$1 Konsistente Richtlinien für alle Cluster \$1 Eine Argo-CD-Instanz zur Verwaltung \$1 Klare Trennung zwischen Steuerungsebene und Workloads
**Pro Cluster** — Führen Sie Argo CD auf jedem Cluster aus und verwalten Sie nur die Anwendungen dieses Clusters: \$1 Clustertrennung (ein Fehler hat keine Auswirkungen auf andere) \$1 Einfachere Vernetzung (keine clusterübergreifende Kommunikation) \$1 Einfachere Ersteinrichtung (keine Clusterregistrierung)
hub-and-spokeEntscheiden Sie sich für Plattformteams, die viele Cluster verwalten, oder pro Cluster für unabhängige Teams oder wenn Cluster vollständig isoliert werden müssen.
Eine detaillierte Konfiguration mehrerer Cluster finden Sie unter. [Überlegungen zu Argo CD](argocd-considerations.md)
### Projekte
Projekte bieten logische Gruppierung und Zugriffskontrolle für Anwendungen:
+ **Quellenbeschränkungen** — Beschränken Sie, welche Git-Repositorys verwendet werden können
+ **Zielbeschränkungen** — Beschränken Sie, welche Cluster und Namespaces als Ziel ausgewählt werden können
+ **Ressourceneinschränkungen** — Beschränken Sie, welche Kubernetes-Ressourcentypen bereitgestellt werden können
+ **RBAC-Integration** — Ordnen Sie Projekte AWS Identity Center-Benutzern und Gruppen zu IDs
Anwendungen gehören zu einem einzigen Projekt. Wenn nicht angegeben, verwenden sie das `default` Projekt, für das standardmäßig keine Einschränkungen gelten. Bearbeiten Sie das `default` Projekt für den produktiven Einsatz, um den Zugriff einzuschränken, und erstellen Sie neue Projekte mit entsprechenden Einschränkungen.
Informationen zur Projektkonfiguration und zu RBAC-Mustern finden Sie unter. [Argo-CD-Berechtigungen konfigurieren](argocd-permissions.md)
### Synchronisierungsoptionen
Optimieren Sie das Synchronisierungsverhalten mit gängigen Optionen:
+ `CreateNamespace=true`— Automatisch einen Ziel-Namespace erstellen
+ `ServerSideApply=true`- Verwenden Sie serverseitiges Anwenden für eine bessere Konfliktlösung
+ `SkipDryRunOnMissingResource=true`- Überspringe den Testlauf, wenn er noch CRDs nicht existiert (nützlich für Kro-Instanzen)
```
spec:
syncPolicy:
syncOptions:
- CreateNamespace=true
- ServerSideApply=true
- SkipDryRunOnMissingResource=true
```
Eine vollständige Liste der Synchronisierungsoptionen finden Sie in der Dokumentation zu den [Argo-CD-Synchronisierungsoptionen](https://argo-cd.readthedocs.io/en/stable/user-guide/sync-options/).
## Nächste Schritte
+ [Repository-Zugriff konfigurieren](argocd-configure-repositories.md)- Git-Repository-Zugriff konfigurieren
+ [Zielcluster registrieren](argocd-register-clusters.md)- Registrieren Sie Zielcluster für die Bereitstellung
+ [Anwendungen erstellen](argocd-create-application.md)- Erstellen Sie Ihre erste Anwendung
+ [Überlegungen zu Argo CD](argocd-considerations.md)- EKS-spezifische Muster, Identity Center-Integration und Multi-Cluster-Konfiguration
+ [Argo-CD-Dokumentation](https://argo-cd.readthedocs.io/en/stable/) — Umfassende Argo-CD-Dokumentation mit Sync-Hooks, Integritätsprüfungen und erweiterten Mustern
# Argo-CD-Berechtigungen konfigurieren
Die verwaltete Funktion von Argo CD ist zur Authentifizierung in AWS Identity Center integriert und verwendet integrierte RBAC-Rollen für die Autorisierung. In diesem Thema wird erklärt, wie Berechtigungen für Benutzer und Teams konfiguriert werden.
## Wie funktionieren Berechtigungen mit Argo CD
Die Argo-CD-Funktion verwendet AWS Identity Center für die Authentifizierung und bietet drei integrierte RBAC-Rollen für die Autorisierung.
Wenn ein Benutzer auf Argo CD zugreift:
1. Sie authentifizieren sich mithilfe von AWS Identity Center (das eine Verbindung zu Ihrem Corporate Identity Provider herstellen kann)
1. AWS Identity Center stellt Benutzer- und Gruppeninformationen für Argo CD bereit
1. Argo CD ordnet Benutzer und Gruppen basierend auf Ihrer Konfiguration RBAC-Rollen zu
1. Benutzer sehen nur die Anwendungen und Ressourcen, für deren Zugriff sie berechtigt sind
## Integrierte RBAC-Rollen
Die Argo-CD-Funktion bietet drei integrierte Rollen, die Sie AWS Identity Center-Benutzern und -Gruppen zuordnen. Dabei handelt es sich um **Rollen mit globalem Geltungsbereich**, die den Zugriff auf Argo CD-Ressourcen wie Projekte, Cluster und Repositorys steuern.
**Wichtig**
Globale Rollen kontrollieren den Zugriff auf Argo CD selbst, nicht auf projektbezogene Ressourcen wie Anwendungen. EDITOR- und VIEWER-Benutzer können Anwendungen standardmäßig nicht sehen oder verwalten — sie benötigen Projektrollen, um auf projektbezogene Ressourcen zugreifen zu können. Einzelheiten [Projektrollen und projektbezogener Zugriff](#project-roles) zur Gewährung des Zugriffs auf Anwendungen und andere projektbezogene Ressourcen finden Sie unter.
**ADMINISTRATOR**
Voller Zugriff auf alle Ressourcen und Einstellungen von Argo CD:
+ Anwendungen in beliebigen Projekten erstellen, aktualisieren und ApplicationSets löschen
+ Verwalten Sie die Argo-CD-Konfiguration
+ Registrieren und verwalten Sie Bereitstellungszielcluster
+ Konfigurieren Sie den Zugriff auf das Repository
+ Projekte erstellen und verwalten
+ Sehen Sie sich den gesamten Bewerbungsstatus und die Historie an
+ Alle Cluster und Repositorys auflisten und darauf zugreifen
**HERAUSGEBER**
Kann Projekte aktualisieren und Projektrollen konfigurieren, aber die globalen Argo-CD-Einstellungen nicht ändern:
+ Bestehende Projekte aktualisieren (Projekte können nicht erstellt oder gelöscht werden)
+ Projektrollen und -berechtigungen konfigurieren
+ GPG-Schlüssel und Zertifikate anzeigen
+ Die globale Argo-CD-Konfiguration kann nicht geändert werden
+ Cluster oder Repositorys können nicht direkt verwaltet werden
+ Anwendungen ohne Projektrollen können nicht angezeigt oder verwaltet werden
**BETRACHTER**
Nur-Lese-Zugriff auf Argo-CD-Ressourcen:
+ Projektkonfigurationen anzeigen
+ Listet alle Projekte auf (einschließlich Projekten, denen der Benutzer nicht zugewiesen ist)
+ GPG-Schlüssel und Zertifikate anzeigen
+ Cluster oder Repositorys können nicht aufgelistet werden
+ Es können keine Änderungen vorgenommen werden
+ Anwendungen ohne Projektrollen können nicht angezeigt oder verwaltet werden
**Anmerkung**
Um EDITOR- oder VIEWER-Benutzern Zugriff auf Anwendungen zu gewähren, muss ein ADMIN oder EDITOR Projektrollen erstellen, die Identity Center-Gruppen bestimmten Berechtigungen innerhalb eines Projekts zuordnen.
## Projektrollen und projektbezogener Zugriff
Globale Rollen (ADMIN, EDITOR, VIEWER) steuern den Zugriff auf Argo CD selbst. Projektrollen steuern den Zugriff auf Ressourcen und Funktionen innerhalb eines bestimmten Projekts, darunter:
+ **Ressourcen**: Anwendungen ApplicationSets, Repository-Anmeldeinformationen, Cluster-Anmeldeinformationen
+ **Funktionen**: Protokollzugriff, Zugriff für Führungskräfte auf Anwendungs-Pods
**Grundlegendes zum zweistufigen Berechtigungsmodell**:
+ **Globaler Geltungsbereich**: Integrierte Rollen bestimmen, was Benutzer mit Projekten, Clustern, Repositorys und Argo-CD-Einstellungen tun können
+ **Projektumfang**: Projektrollen bestimmen, was Benutzer mit Ressourcen und Fähigkeiten innerhalb eines bestimmten Projekts tun können
Das bedeutet Folgendes:
+ ADMIN-Benutzer können ohne zusätzliche Konfiguration auf alle Projektressourcen und Funktionen zugreifen
+ EDITOR- und VIEWER-Benutzern müssen Projektrollen zugewiesen werden, um auf Projektressourcen und Funktionen zugreifen zu können
+ EDITOR-Benutzer können Projektrollen erstellen, um sich selbst und anderen Zugriff auf Projekte zu gewähren, die sie aktualisieren können
**Beispiel für einen Arbeitsablauf**:
1. Ein ADMIN ordnet der Rolle EDITOR weltweit eine Identity Center-Gruppe zu
1. Ein ADMIN erstellt ein Projekt für ein Team
1. Der EDITOR konfiguriert die Projektrollen innerhalb dieses Projekts, um Teammitgliedern Zugriff auf projektbezogene Ressourcen zu gewähren
1. Teammitglieder (die möglicherweise die globale VIEWER-Rolle haben) können nun Anwendungen in diesem Projekt auf der Grundlage ihrer Projektrollenberechtigungen sehen und verwalten
Einzelheiten zur Konfiguration von Projektrollen finden Sie unter[Projektbasierte Zugriffskontrolle](#_project_based_access_control).
## Konfigurieren Sie Rollenzuordnungen
Ordnen Sie AWS Identity Center-Benutzer und -Gruppen bei der Erstellung oder Aktualisierung der Funktion den Argo-CD-Rollen zu.
**Beispiel für eine Rollenzuweisung**:
```
{
"rbacRoleMapping": {
"ADMIN": ["AdminGroup", "alice@example.com"],
"EDITOR": ["DeveloperGroup", "DevOpsTeam"],
"VIEWER": ["ReadOnlyGroup", "bob@example.com"]
}
}
```
**Anmerkung**
Bei Rollennamen wird zwischen Groß- und Kleinschreibung unterschieden und sie müssen in Großbuchstaben geschrieben werden (ADMIN, EDITOR, VIEWER).
**Wichtig**
Die Integration von EKS Capabilities in AWS Identity Center unterstützt bis zu 1.000 Identitäten pro Argo-CD-Funktion. Eine Identität kann ein Benutzer oder eine Gruppe sein.
**Rollenzuordnungen aktualisieren**:
```
aws eks update-capability \
--region us-east-1 \
--cluster-name cluster \
--capability-name capname \
--endpoint "https://eks.ap-northeast-2.amazonaws.com" \
--role-arn "arn:aws:iam::[.replaceable]111122223333:role/[.replaceable]`EKSCapabilityRole`" \
--configuration '{
"argoCd": {
"rbacRoleMappings": {
"addOrUpdateRoleMappings": [
{
"role": "ADMIN",
"identities": [
{ "id": "686103e0-f051-7068-b225-e6392b959d9e", "type": "SSO_USER" }
]
}
]
}
}
}'
```
## Nutzung des Admin-Kontos
Das Administratorkonto ist für die Ersteinrichtung und administrative Aufgaben wie die Registrierung von Clustern und die Konfiguration von Repositorys konzipiert.
**Wenn das Administratorkonto geeignet ist**:
+ Erstmalige Einrichtung und Konfiguration der Funktionen
+ Einzelentwicklung oder schnelle Vorführungen
+ Administrative Aufgaben (Clusterregistrierung, Repository-Konfiguration, Projekterstellung)
**Bewährte Methoden für Administratorkonten**:
+ Übergeben Sie Konto-Tokens nicht der Versionskontrolle
+ Wechseln Sie Tokens sofort, wenn sie offengelegt werden
+ Beschränken Sie die Verwendung von Konto-Tokens auf Einrichtungs- und Verwaltungsaufgaben
+ Legen Sie kurze Ablaufzeiten fest (maximal 12 Stunden)
+ Es können jeweils nur 5 Konto-Tokens erstellt werden
**Wann sollte stattdessen der projektbasierte Zugriff** verwendet werden:
+ Gemeinsame Entwicklungsumgebungen mit mehreren Benutzern
+ Jede Umgebung, die der Produktion ähnelt
+ Wenn Sie Prüfprotokolle darüber benötigen, wer Aktionen ausgeführt hat
+ Wenn Sie Ressourcen- oder Zugriffsbeschränkungen durchsetzen müssen
Verwenden Sie für Produktionsumgebungen und Szenarien mit mehreren Benutzern eine projektbasierte Zugriffskontrolle mit speziellen RBAC-Rollen, die Identity Center-Gruppen zugeordnet sind. AWS
## Projektbasierte Zugriffskontrolle
Verwenden Sie Argo CD Projects (AppProject), um Teams eine detaillierte Zugriffskontrolle und Ressourcenisolierung zu bieten.
**Wichtig**
Bevor Sie Benutzern oder Gruppen projektspezifischen Rollen zuweisen, müssen Sie sie zunächst einer globalen Argo-CD-Rolle (ADMIN, EDITOR oder VIEWER) in der Funktionskonfiguration zuordnen. Benutzer können ohne eine globale Rollenzuweisung nicht auf Argo CD zugreifen, selbst wenn sie Projektrollen zugewiesen sind.
Erwägen Sie, Benutzer global der VIEWER-Rolle zuzuordnen und dann zusätzliche Berechtigungen über projektspezifische Rollen zu gewähren. Dies bietet Basiszugriff und ermöglicht gleichzeitig eine detaillierte Steuerung auf Projektebene.
Projekte bieten:
+ **Quellenbeschränkungen**: Beschränken Sie, welche Git-Repositorys verwendet werden können
+ **Zieleinschränkungen**: Beschränken Sie, welche Cluster und Namespaces als Ziel ausgewählt werden können
+ **Ressourceneinschränkungen**: Beschränken Sie, welche Kubernetes-Ressourcentypen bereitgestellt werden können
+ **RBAC-Integration**: Ordnen Sie Projekte AWS Identity Center-Gruppen oder Argo-CD-Rollen zu
**Beispielprojekt für** die Isolierung von Teams:
```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
name: team-a
namespace: argocd
spec:
description: Team A applications
# Required: Specify which namespaces this project watches for Applications
sourceNamespaces:
- argocd
# Source restrictions
sourceRepos:
- https://github.com/myorg/team-a-apps
# Destination restrictions
destinations:
- namespace: team-a-*
server: arn:aws:eks:us-west-2:111122223333:cluster/production
# Resource restrictions
clusterResourceWhitelist:
- group: ''
kind: Namespace
namespaceResourceWhitelist:
- group: 'apps'
kind: Deployment
- group: ''
kind: Service
- group: ''
kind: ConfigMap
```
### Quell-Namespaces
Wenn Sie die EKS Argo CD-Funktion verwenden, ist das `spec.sourceNamespaces` Feld in Definitionen erforderlich. AppProject Dieses Feld gibt an, welcher Namespace Anwendungen enthalten kann oder ApplicationSets die auf dieses Projekt verweisen.
**Wichtig**
Die EKS Argo-CD-Funktion unterstützt nur einen einzigen Namespace für Anwendungen und ApplicationSets den Namespace, den Sie bei der Erstellung der Funktion angegeben haben (normalerweise). `argocd` Dies unterscheidet sich von der Open-Source-Version von Argo CD, die mehrere Namespaces unterstützt.
**AppProject Konfiguration**
Alle AppProjects müssen den konfigurierten Namespace der Fähigkeit enthalten in`sourceNamespaces`:
```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
name: team-a-project
namespace: argocd
spec:
description: Applications for Team A
# Required: Specify the capability's configured namespace (configuration.argoCd.namespace)
sourceNamespaces:
- argocd # Must match your capability's namespace configuration
# Source repositories this project can deploy from
sourceRepos:
- 'https://github.com/my-org/team-a-*'
# Destination restrictions
destinations:
- namespace: 'team-a-*'
server: arn:aws:eks:us-west-2:111122223333:cluster/my-cluster
```
**Anmerkung**
Wenn Sie den Namespace der Fähigkeit weglassen`sourceNamespaces`, können Anwendungen oder ApplicationSets in diesem Namespace nicht auf dieses Projekt verweisen, was zu Bereitstellungsfehlern führt.
**Weisen Sie Benutzer Projekten** zu:
Projektrollen gewähren EDITOR- und VIEWER-Benutzern Zugriff auf Projektressourcen (Anwendungen ApplicationSets, Repository- und Cluster-Anmeldeinformationen) und Funktionen (Logs, Exec). Ohne Projektrollen können diese Benutzer nicht auf diese Ressourcen zugreifen, selbst wenn sie globalen Rollenzugriff haben.
ADMIN-Benutzer haben Zugriff auf alle Anwendungen, ohne Projektrollen zu benötigen.
**Beispiel: Teammitgliedern Anwendungszugriff gewähren**
```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
name: team-a
namespace: argocd
spec:
# ... project configuration ...
sourceNamespaces:
- argocd
# Project roles grant Application-level access
roles:
- name: developer
description: Team A developers - can manage Applications
policies:
- p, proj:team-a:developer, applications, *, team-a/*, allow
- p, proj:team-a:developer, clusters, get, *, allow # See cluster names in UI
groups:
- 686103e0-f051-7068-b225-e6392b959d9e # Identity Center group ID
- name: viewer
description: Team A viewers - read-only Application access
policies:
- p, proj:team-a:viewer, applications, get, team-a/*, allow
- p, proj:team-a:viewer, clusters, get, *, allow # See cluster names in UI
groups:
- 786203e0-f051-7068-b225-e6392b959d9f # Identity Center group ID
```
**Anmerkung**
Fügen Sie Rollen `clusters, get, *, allow` in das Projekt ein, damit Benutzer Clusternamen in der Benutzeroberfläche sehen können. Ohne diese Berechtigung wird der Zielcluster als „unbekannt“ angezeigt.
**Grundlegendes zu den Richtlinien für Projektrollen**:
Das Richtlinienformat lautet: `p, proj::, , ,