**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.
# EKS-Fähigkeiten
**Tipp**
[Erste Schritte: [ACK-Fähigkeit erstellen](create-ack-capability.md) \$1 [Argo-CD-Funktion erstellen \$1 Kro-Fähigkeit](create-argocd-capability.md) erstellen](create-kro-capability.md)
Amazon EKS Capabilities ist ein mehrschichtiger Satz vollständig verwalteter Cluster-Funktionen, mit denen Entwickler schneller arbeiten und die Komplexität der Erstellung und Skalierung mit Kubernetes verringern können. EKS-Funktionen sind native Kubernetes-Funktionen für die deklarative kontinuierliche Bereitstellung, das AWS Ressourcenmanagement sowie die Erstellung und Orchestrierung von Kubernetes-Ressourcen, die alle vollständig von verwaltet werden. AWS Mit EKS Capabilities können Sie sich mehr auf den Aufbau und die Skalierung Ihrer Workloads konzentrieren und die betriebliche Belastung dieser grundlegenden Plattformdienste auf diese abwälzen. AWS Diese Funktionen werden innerhalb von EKS und nicht in Ihren Clustern ausgeführt, sodass Sie wichtige Plattformkomponenten auf Ihren Worker-Knoten nicht mehr installieren, warten und skalieren müssen.
Zu Beginn können Sie eine oder mehrere EKS-Funktionen auf einem neuen oder vorhandenen EKS-Cluster erstellen. Dazu können Sie die AWS CLI, EKS AWS-Managementkonsole APIs, eksctl oder Ihre bevorzugten infrastructure-as-code Tools verwenden. EKS-Funktionen sind zwar so konzipiert, dass sie zusammenarbeiten, es handelt sich jedoch um unabhängige Cloud-Ressourcen, die Sie je nach Anwendungsfall und Anforderungen auswählen können.
Alle von EKS unterstützten Kubernetes-Versionen werden für EKS-Funktionen unterstützt.
**Anmerkung**
EKS-Funktionen sind in allen AWS Handelsregionen verfügbar, in denen Amazon EKS verfügbar ist. Eine Liste der unterstützten Regionen finden Sie unter [Amazon EKS-Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/eks.html) in der AWS Allgemeinen Referenz.
## Verfügbare Funktionen
### AWS Controller für Kubernetes (ACK)
ACK ermöglicht die Verwaltung von AWS Ressourcen mithilfe von Kubernetes APIs, sodass Sie S3-Buckets, RDS-Datenbanken, IAM-Rollen und andere AWS Ressourcen mithilfe von benutzerdefinierten Kubernetes-Ressourcen erstellen und verwalten können. ACK gleicht Ihren gewünschten Status kontinuierlich mit dem aktuellen Status ab und korrigiert alle Abweichungen im Laufe der Zeit AWS, um sicherzustellen, dass Ihr System einwandfrei funktioniert und Ihre Ressourcen wie angegeben konfiguriert sind. Sie können AWS Ressourcen zusammen mit Ihren Kubernetes-Workloads mithilfe derselben Tools und Workflows verwalten, wobei mehr als 50 AWS Dienste unterstützt werden, darunter S3, RDS, DynamoDB und Lambda. ACK unterstützt konto- und regionsübergreifendes Ressourcenmanagement und ermöglicht so komplexe Systemverwaltungsarchitekturen mit mehreren Konten und Clustern. ACK unterstützt schreibgeschützte Ressourcen und die Einführung von schreibgeschützten Ressourcen und erleichtert so die Migration von anderen Infrastruktur-as-Code-Tools zu Ihren Kubernetes-basierten Systemen.
[Erfahren Sie mehr über ACK →](ack.md)
### Argo CD
Argo CD implementiert eine GitOps basierte kontinuierliche Bereitstellung für Ihre Anwendungen und verwendet Git-Repositorys als Informationsquelle für Ihre Workloads und den Systemstatus. Argo CD synchronisiert automatisch Anwendungsressourcen aus Ihren Git-Repositorys mit Ihren Clustern und erkennt und behebt Abweichungen, um sicherzustellen, dass Ihre bereitgestellten Anwendungen dem gewünschten Status entsprechen. Sie können Anwendungen in mehreren Clustern von einer einzigen Argo-CD-Instanz aus bereitstellen und verwalten, wobei die automatische Bereitstellung aus Git-Repositorys erfolgt, wann immer Änderungen festgeschrieben werden. Die gemeinsame Verwendung von Argo CD und ACK bietet ein grundlegendes GitOps System, das die Verwaltung der Abhängigkeit von Arbeitslasten vereinfacht und Systemdesigns unterstützt, einschließlich Cluster- und Infrastrukturmanagement im großen Maßstab. Argo CD lässt sich zur Authentifizierung und Autorisierung in AWS Identity Center integrieren und bietet eine gehostete Argo-Benutzeroberfläche zur Visualisierung des Anwendungszustands und des Bereitstellungsstatus.
[Erfahren Sie mehr über Argo CD →](argocd.md)
### kro (Kube Resource Orchestrator)
Mit kro können Sie benutzerdefinierte Kubernetes erstellen, die mehrere Ressourcen zu Abstraktionen auf höherer Ebene zusammensetzen APIs , sodass Plattformteams wiederverwendbare Muster für gängige Ressourcenkombinationen — Cloud-Bausteine — definieren können. Mit kro können Sie sowohl Kubernetes als auch AWS Ressourcen zu einheitlichen Abstraktionen zusammenfassen und dabei eine einfache Syntax verwenden, um dynamische Konfigurationen und bedingte Logik zu ermöglichen. kro ermöglicht es Plattformteams, Self-Service-Funktionen mit geeigneten Leitplanken bereitzustellen, sodass Entwickler komplexe Infrastrukturen mithilfe einfacher, speziell entwickelter Systeme bereitstellen und APIs gleichzeitig organisatorische Standards und Best Practices einhalten können. KRO-Ressourcen sind einfach Kubernetes-Ressourcen und werden in Kubernetes-Manifesten spezifiziert, die in Git gespeichert oder per Push übertragen werden können zu OCI- kompatible Register wie Amazon ECR für eine breite organisatorische Verteilung.
[Erfahren Sie mehr über Kro →](kro.md)
## Vorteile der EKS-Fähigkeiten
Die Funktionen von EKS werden vollständig von verwaltet AWS, sodass keine Installation, Wartung und Skalierung grundlegender Cluster-Services erforderlich sind. AWS kümmert sich um Sicherheitspatches, Updates und Betriebsmanagement, sodass sich Ihre Teams auf die Entwicklung und AWS nicht auf den Clusterbetrieb konzentrieren können. Im Gegensatz zu herkömmlichen Kubernetes-Add-Ons, die Cluster-Ressourcen verbrauchen, werden Funktionen in EKS und nicht auf Ihren Worker-Knoten ausgeführt. Dadurch werden Clusterkapazität und Ressourcen für Ihre Workloads freigegeben und gleichzeitig der Betriebsaufwand für die Verwaltung von Cluster-Controllern und anderen Plattformkomponenten minimiert.
Mit EKS-Funktionen können Sie Bereitstellungen, Ressourcen, benutzerdefinierte AWS Kubernetes-Ressourcen und Kompositionen mithilfe von nativem Kubernetes und Tools wie verwalten. APIs `kubectl` Alle Funktionen funktionieren im Kontext Ihrer Cluster und erkennen und korrigieren automatisch Konfigurationsabweichungen sowohl bei Anwendungs- als auch bei Cloud-Infrastrukturressourcen. Sie können Ressourcen für mehrere Cluster, AWS Konten und Regionen von einem einzigen Kontrollpunkt aus bereitstellen und verwalten und so den Betrieb in komplexen, verteilten Umgebungen vereinfachen.
Die EKS-Funktionen sind für GitOps Workflows konzipiert und bieten deklaratives, versionskontrolliertes Infrastruktur- und Anwendungsmanagement. Änderungen fließen von Git durch das System und bieten Audit-Trails, Rollback-Funktionen und Workflows für die Zusammenarbeit, die sich in Ihre bestehenden Entwicklungspraktiken integrieren lassen. Dieser Kubernetes-native Ansatz bedeutet, dass Sie nicht mehrere Tools verwenden oder infrastructure-as-code Systeme außerhalb Ihrer Cluster verwalten müssen, und es gibt eine einzige Informationsquelle, auf die Sie sich verlassen können. Ihr gewünschter Status, der in der deklarativen Konfiguration von Kubernetes mit Versionskontrolle definiert ist, wird in Ihrer gesamten Umgebung kontinuierlich durchgesetzt.
## Preisgestaltung
Mit EKS-Funktionen gibt es keine Vorabverpflichtungen oder Mindestgebühren. Ihnen wird jede Capability-Ressource für jede Stunde, in der sie in Ihrem Amazon EKS-Cluster aktiv ist, in Rechnung gestellt. Bestimmte Kubernetes-Ressourcen, die von EKS Capabilities verwaltet werden, werden ebenfalls nach einem Stundensatz abgerechnet.
Aktuelle Preisinformationen finden Sie auf der [Amazon EKS-Preisseite](https://aws.amazon.com/eks/pricing/).
**Tipp**
Sie können den AWS Cost Explorer und die Kosten- und Nutzungsberichte verwenden, um die Kapazitätskosten getrennt von anderen EKS-Gebühren zu verfolgen. Sie können Ihre Kapazitäten mit Clusternamen, Fähigkeitstyp und anderen Details zur Kostenzuweisung kennzeichnen.
## So funktionieren die Funktionen von EKS
Jede Funktion ist eine AWS Ressource, die Sie auf Ihrem EKS-Cluster erstellen. Nach der Erstellung wird die Funktion in EKS ausgeführt und vollständig von verwaltet AWS.
**Anmerkung**
Sie können für jeden Typ (Argo CD, ACK und Kro) eine Capability-Ressource für einen bestimmten Cluster erstellen. Sie können nicht mehrere Capability-Ressourcen desselben Typs auf demselben Cluster erstellen.
Sie interagieren mit den Funktionen in Ihrem Cluster mithilfe von Standard-Kubernetes APIs und Tools:
+ Wird verwendet`kubectl`, um benutzerdefinierte Kubernetes-Ressourcen anzuwenden
+ Verwenden Sie Git-Repositorys als Informationsquelle für Workflows GitOps
Für einige Funktionen werden zusätzliche Tools unterstützt. Beispiel:
+ Verwenden Sie die Argo-CD-CLI, um Repositorys und Cluster in Ihrer Argo-CD-Funktion zu konfigurieren und zu verwalten
+ Verwenden Sie die Argo-CD-Benutzeroberfläche, um Anwendungen zu visualisieren und zu verwalten, die von Ihrer Argo-CD-Funktion verwaltet werden
Die Funktionen sind so konzipiert, dass sie zusammenarbeiten, aber unabhängig voneinander und vollständig aktiviert sind. Sie können je nach Bedarf eine, zwei oder alle drei Funktionen aktivieren und Ihre Konfiguration aktualisieren, wenn sich Ihre Anforderungen weiterentwickeln.
Alle EKS-Compute-Typen werden für die Verwendung mit EKS-Funktionen unterstützt. Weitere Informationen finden Sie unter [Verwaltung von Datenverarbeitungsressourcen mithilfe von Knoten](eks-compute.md).
Informationen zur Sicherheitskonfiguration und Einzelheiten zu IAM-Rollen finden Sie unter[Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md). Architekturmuster für mehrere Cluster finden Sie unter. [Überlegungen zu den EKS-Fähigkeiten](capabilities-considerations.md)
## Häufige Anwendungsfälle
**GitOps für Anwendungen und Infrastruktur**
Verwenden Sie Argo CD, um Anwendungen und Betriebskomponenten bereitzustellen, und ACK, um Clusterkonfigurationen zu verwalten und Infrastruktur bereitzustellen, beide aus Git-Repositorys. Ihr gesamter Stack — Anwendungen, Datenbanken, Speicher und Netzwerke — wird als Code definiert und automatisch bereitgestellt.
Beispiel: Ein Entwicklungsteam überträgt Änderungen an Git. Argo CD stellt die aktualisierte Anwendung bereit und ACK stellt eine neue RDS-Datenbank mit der richtigen Konfiguration bereit. Alle Änderungen sind überprüfbar, reversibel und in allen Umgebungen konsistent.
**Plattformentwicklung mit Self-Service**
Verwenden Sie kro, um benutzerdefinierte APIs ACK- und Kubernetes-Ressourcen zu erstellen. Plattformteams definieren genehmigte Muster anhand von Leitplanken. Anwendungsteams verwenden einfache, übergeordnete Methoden, APIs um komplette Stacks bereitzustellen.
Beispiel: Ein Plattformteam erstellt eine "WebApplication" API, die einen Deployment-, Service-, Ingress- und S3-Bucket bereitstellt. Entwickler verwenden diese API, ohne die zugrunde liegende Komplexität oder AWS die Berechtigungen verstehen zu müssen.
**Anwendungsmanagement mit mehreren Clustern**
Verwenden Sie Argo CD, um Anwendungen auf mehreren EKS-Clustern in verschiedenen Regionen oder Konten bereitzustellen. Verwalten Sie alle Bereitstellungen von einer einzigen Argo CD-Instanz aus mit konsistenten Richtlinien und Workflows.
Beispiel: Stellen Sie dieselbe Anwendung für Entwicklungs-, Staging- und Produktionscluster in mehreren Regionen bereit. Argo CD stellt sicher, dass jede Umgebung mit dem entsprechenden Git-Zweig synchron bleibt.
**Verwaltung mehrerer Cluster**
Verwenden Sie ACK, um EKS-Cluster zu definieren und bereitzustellen, Kro, um Cluster-Konfigurationen an organisatorische Standards anzupassen, und Argo CD, um den Cluster-Lebenszyklus und die Konfiguration zu verwalten. Dies ermöglicht die end-to-end Clusterverwaltung von der Erstellung bis zum laufenden Betrieb.
Beispiel: Definieren Sie EKS-Cluster mithilfe von ACK und Kro zur Bereitstellung und Verwaltung der Cluster-Infrastruktur und definieren Sie organisatorische Standards für Netzwerke, Sicherheitsrichtlinien, Add-Ons und andere Konfigurationen. Verwenden Sie Argo CD, um Cluster, Konfigurationen und Kubernetes-Versionsupdates für Ihre gesamte Flotte zu erstellen und kontinuierlich zu verwalten. Dabei profitieren Sie von konsistenten Standards und automatisiertem Lebenszyklusmanagement.
**Migrationen und Modernisierung**
Vereinfachen Sie die Migration zu EKS mit nativer Cloud-Ressourcenbereitstellung und Workflows. GitOps Verwenden Sie ACK, um vorhandene AWS Ressourcen zu übernehmen, ohne sie neu zu erstellen, und Argo CD, um Workload-Bereitstellungen von Git aus zu operationalisieren.
Beispiel: Ein Team, das von EC2 zu EKS migriert, übernimmt seine vorhandenen RDS-Datenbanken und S3-Buckets mithilfe von ACK und verwendet dann Argo CD, um containerisierte Anwendungen von Git bereitzustellen. Der Migrationspfad ist klar und die Abläufe sind vom ersten Tag an standardisiert.
**Konto und regionales Bootstrapping**
Automatisieren Sie die Implementierung der Infrastruktur über Konten und Regionen hinweg, indem Sie Argo CD und ACK zusammen verwenden. Definieren Sie Ihre Infrastruktur als Code in Git und lassen Sie Capabilities die Bereitstellung und Verwaltung übernehmen.
Beispiel: Ein Plattformteam verwaltet Git-Repositorys, in denen StandardkontenkonfigurationenVPCs, IAM-Rollen, RDS-Instanzen und Monitoring-Stacks definiert werden. Argo CD stellt diese Konfigurationen automatisch für neue Konten und Regionen bereit, wodurch Konsistenz gewährleistet und die Zeit für die manuelle Einrichtung von Tagen auf Minuten reduziert wird.
# Mit Capability-Ressourcen arbeiten
In diesem Thema werden allgemeine Verfahren zur Verwaltung von Fähigkeitsressourcen für alle Fähigkeitstypen beschrieben.
## Ressourcen für EKS-Fähigkeiten
EKS-Funktionen sind AWS Ressourcen, die verwaltete Funktionen in Ihrem Amazon EKS-Cluster ermöglichen. Die Funktionen werden in EKS ausgeführt, sodass Sie keine Controller und andere Betriebskomponenten auf Ihren Worker-Knoten installieren und warten müssen. Funktionen werden für einen bestimmten EKS-Cluster erstellt und bleiben während ihres gesamten Lebenszyklus diesem Cluster zugeordnet.
Jede Capability-Ressource hat:
+ Ein eindeutiger Name innerhalb Ihres Clusters
+ Ein Fähigkeitstyp (ACK, ARGOCD oder KRO)
+ Ein Amazon-Ressourcenname (ARN), der sowohl Name als auch Typ angibt
+ Eine IAM-Rolle für Fähigkeiten
+ Ein Status, der den aktuellen Status angibt
+ Konfiguration, sowohl generisch als auch spezifisch für den Funktionstyp
## Den Status der Fähigkeit verstehen
Fähigkeitsressourcen haben einen Status, der ihren aktuellen Status angibt. Sie können den Status und den Zustand der Funktionen in der EKS-Konsole oder über die AWS CLI anzeigen.
**Konsole**:
1. Öffnen Sie die Amazon EKS-Konsole unter https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Wählen Sie Ihren Clusternamen aus.
1. Wählen Sie die Registerkarte **Funktionen**, um den Status aller Funktionen anzuzeigen.
1. Für detaillierte Gesundheitsinformationen wählen Sie die Registerkarte **Observability**, dann **Monitor cluster** und dann die Registerkarte **Capabilities**.
** AWS CLI**:
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-capability-name
```
### Status der Fähigkeiten
**ERSTELLUNG**: Die Fähigkeit wird eingerichtet. Sie können von der Konsole weg navigieren — die Funktion erstellt weiterhin im Hintergrund.
**AKTIV**: Die Funktion wird ausgeführt und ist einsatzbereit. Wenn Ressourcen nicht wie erwartet funktionieren, überprüfen Sie den Ressourcenstatus und die IAM-Berechtigungen. Anleitungen finden Sie unter [Problembehebung bei EKS-Funktionen](capabilities-troubleshooting.md).
**AKTUALISIERUNG**: Die Konfigurationsänderungen werden übernommen. Warten Sie, bis der Status wieder angezeigt wird`ACTIVE`.
**LÖSCHEN**: Die Fähigkeit wird aus dem Cluster entfernt.
**CREATE\$1FAILED**: Beim Setup ist ein Fehler aufgetreten. Zu den häufigsten Ursachen gehören:
+ Die Vertrauensrichtlinie für IAM-Rollen ist falsch oder fehlt
+ Die IAM-Rolle ist nicht vorhanden oder es kann nicht darauf zugegriffen werden
+ Probleme mit dem Clusterzugriff
+ Ungültige Konfigurationsparameter
Spezifische Fehlerdetails finden Sie im Abschnitt zur Funktionsintegrität.
**UPDATE\$1FAILED: Das Konfigurationsupdate ist fehlgeschlagen**. Einzelheiten finden Sie im Abschnitt zur Funktionsintegrität und überprüfen Sie die IAM-Berechtigungen.
**Tipp**
Eine ausführliche Anleitung zur Fehlerbehebung finden Sie unter:
[Problembehebung bei EKS-Funktionen](capabilities-troubleshooting.md)- Allgemeine Problembehebung bei Funktionen
[Probleme mit ACK-Funktionen beheben](ack-troubleshooting.md)- ACK-spezifische Probleme
[Probleme mit den Funktionen von Argo CD beheben](argocd-troubleshooting.md)- CD-spezifische Probleme mit Argo
[Probleme mit KRO-Funktionen beheben](kro-troubleshooting.md)- Kro-spezifische Probleme
## Fähigkeiten schaffen
Informationen zum Erstellen einer Funktion in Ihrem Cluster finden Sie in den folgenden Themen:
+ [Erstellen Sie eine ACK-Fähigkeit](create-ack-capability.md)— Erstellen Sie eine ACK-Fähigkeit zur Verwaltung von AWS Ressourcen mithilfe von Kubernetes APIs
+ [Erstellen einer Argo CD-Funktion](create-argocd-capability.md)— Erstellen Sie eine Argo-CD-Funktion für kontinuierliche Bereitstellung GitOps
+ [Eine Kro-Fähigkeit erstellen](create-kro-capability.md)— Schaffen Sie eine Kro-Funktion für die Zusammenstellung und Orchestrierung von Ressourcen
## Funktionen auflisten
Sie können alle Capability-Ressourcen in einem Cluster auflisten.
### Konsole
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. Sehen Sie sich die Ressourcen zu den Funktionen unter **Verwaltete Funktionen** an.
### AWS CLI
Verwenden Sie den `list-capabilities` Befehl, um alle Funktionen Ihres Clusters anzuzeigen. *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.
```
aws eks list-capabilities \
--region region-code \
--cluster-name my-cluster
```
```
{
"capabilities": [
{
"capabilityName": "my-ack",
"arn": "arn:aws:eks:us-west-2:111122223333:capability/my-cluster/ack/my-ack/abc123",
"type": "ACK",
"status": "ACTIVE",
"createdAt": "2025-11-02T10:30:00.000000-07:00",
"modifiedAt": "2025-11-02T10:32:15.000000-07:00",
},
{
"capabilityName": "my-kro",
"arn": "arn:aws:eks:us-west-2:111122223333:capability/my-cluster/kro/my-kro/abc123",
"type": "KRO",
"status": "ACTIVE",
"version": "v0.6.3",
"createdAt": "2025-11-02T10:30:00.000000-07:00",
"modifiedAt": "2025-11-02T10:32:15.000000-07:00",
},
{
"capabilityName": "my-argocd",
"arn": "arn:aws:eks:us-west-2:111122223333:capability/my-cluster/argocd/my-argocd/abc123",
"type": "ARGOCD",
"status": "ACTIVE",
"version": "3.1.8-eks-1",
"createdAt": "2025-11-21T08:22:28.486000-05:00",
"modifiedAt": "2025-11-21T08:22:28.486000-05:00"
}
]
}
```
## Beschreiben Sie eine Fähigkeit
Erhalten Sie detaillierte Informationen zu einer bestimmten Funktion, einschließlich ihrer Konfiguration und ihres Status.
### Konsole
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 unter **Verwaltete Funktionen** die Funktion aus, die Sie anzeigen möchten.
1. Sehen Sie sich die Funktionsdetails an, einschließlich Status, Konfiguration und Erstellungszeit.
### AWS CLI
Verwenden Sie den `describe-capability` Befehl, um detaillierte Informationen anzuzeigen. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters und *capability-name* ersetzen Sie es durch den Namen der Fähigkeit (ack, argocd oder kro).
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name capability-name
```
**Beispielausgabe:**
```
{
"capability": {
"capabilityName": "my-ack",
"capabilityArn": "arn:aws:eks:us-west-2:111122223333:capability/my-cluster/ack/my-ack/abc123",
"clusterName": "my-cluster",
"type": "ACK",
"roleArn": "arn:aws:iam::111122223333:role/AmazonEKSCapabilityACKRole",
"status": "ACTIVE",
"configuration": {},
"tags": {},
"health": {
"issues": []
},
"createdAt": "2025-11-19T17:11:30.242000-05:00",
"modifiedAt": "2025-11-19T17:11:30.242000-05:00",
"deletePropagationPolicy": "RETAIN"
}
}
```
## Aktualisieren Sie die Konfiguration einer Funktion
Sie können bestimmte Aspekte der Konfiguration einer Funktion nach der Erstellung aktualisieren. Die spezifischen Konfigurationsoptionen variieren je nach Funktionstyp.
**Anmerkung**
Die Ressourcen der EKS-Funktionen werden vollständig verwaltet, einschließlich Patches und Versionsupdates. Die Aktualisierung einer Funktion aktualisiert die Ressourcenkonfiguration und führt nicht zu Versionsupdates der verwalteten Funktionskomponenten.
### AWS CLI
Verwenden Sie den `update-capability` Befehl, um eine Funktion zu ändern:
```
aws eks update-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name capability-name \
--role-arn arn:aws:iam::[.replaceable]111122223333:role/NewCapabilityRole
```
**Anmerkung**
Nicht alle Funktionseigenschaften können nach der Erstellung aktualisiert werden. Einzelheiten dazu, was geändert werden kann, finden Sie in der funktionsspezifischen Dokumentation.
## Löschen Sie eine Funktion
Wenn Sie eine Funktion in Ihrem Cluster nicht mehr benötigen, können Sie die Fähigkeitsressource löschen.
**Wichtig**
**Löschen Sie die Clusterressourcen, bevor Sie die Funktion löschen.**
Durch das Löschen einer Funktionsressource werden nicht automatisch Ressourcen gelöscht, die mit dieser Fähigkeit erstellt wurden:
Alle benutzerdefinierten Kubernetes-Ressourcendefinitionen (CRDs) bleiben in Ihrem Cluster installiert.
ACK-Ressourcen verbleiben in Ihrem Cluster und die entsprechenden AWS Ressourcen verbleiben in Ihrem Konto
Argo CD-Anwendungen und ihre Kubernetes-Ressourcen verbleiben in Ihrem Cluster
Kro ResourceGraphDefinitions und Instanzen verbleiben in Ihrem Cluster
Sie sollten diese Ressourcen löschen, bevor Sie die Funktion löschen, um verwaiste Ressourcen zu vermeiden.
Sie können sich optional dafür entscheiden, AWS Ressourcen beizubehalten, die mit ACK Kubernetes-Ressourcen verknüpft sind. [Siehe Überlegungen zu ACK](ack-considerations.md)
### Konsole
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 die Funktion, die Sie löschen möchten, aus der Liste der **verwalteten Funktionen** aus.
1. Wählen Sie „**Funktion löschen**“.
1. Geben Sie im Bestätigungsdialogfeld den Namen der Funktion ein, um das Löschen zu bestätigen.
1. Wählen Sie **Löschen** aus.
### AWS CLI
Verwenden Sie den `delete-capability` Befehl, um eine Capability-Ressource zu löschen:
*region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet, *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters und *capability-name* ersetzen Sie es durch den Namen der zu löschenden Funktion.
```
aws eks delete-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name capability-name
```
## Nächste Schritte
+ [Fähigkeiten — Kubernetes-Ressourcen](capability-kubernetes-resources.md)— Erfahren Sie mehr über die Kubernetes-Ressourcen, die von den einzelnen Funktionstypen bereitgestellt werden
+ [ACK-Konzepte](ack-concepts.md)— Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [Arbeiten mit Argo CD](working-with-argocd.md)— Arbeiten mit den Funktionen von Argo CD für Workflows GitOps
+ [Kro-Konzepte](kro-concepts.md)— Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
# Fähigkeiten — Kubernetes-Ressourcen
Nachdem Sie eine Funktion in Ihrem Cluster aktiviert haben, interagieren Sie meistens mit ihr, indem Sie benutzerdefinierte Kubernetes-Ressourcen in Ihrem Cluster erstellen und verwalten. Jede Funktion bietet ihre eigenen benutzerdefinierten Ressourcendefinitionen (CRDs), die die Kubernetes-API um funktionsspezifische Funktionen erweitern.
## Ressourcen von Argo CD
Wenn Sie die Argo-CD-Funktion aktivieren, können Sie die folgenden Kubernetes-Ressourcen erstellen und verwalten:
**Anwendung**
Definiert eine Bereitstellung von einem Git-Repository in einem Zielcluster. `Application`Ressourcen spezifizieren das Quell-Repository, den Ziel-Namespace und die Synchronisierungsrichtlinie. Sie können bis zu 1000 `Application` Ressourcen pro Argo-CD-Capability-Instance erstellen.
**ApplicationSet**
Generiert mehrere `Application` Ressourcen aus Vorlagen und ermöglicht so Bereitstellungen in mehreren Clustern und Umgebungen. `ApplicationSet`Ressourcen verwenden Generatoren, um `Application` Ressourcen dynamisch auf der Grundlage von Clusterlisten, Git-Verzeichnissen oder anderen Quellen zu erstellen.
**AppProject**
Bietet logische Gruppierung und Zugriffskontrolle für `Application` Ressourcen. `AppProject`Ressourcen definieren, welche Repositorys, Cluster und Namespaces `Application` Ressourcen verwenden können, wodurch Mehrmandantenfähigkeit und Sicherheitsgrenzen ermöglicht werden.
Beispielressource: `Application`
```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: my-app
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/org/repo
targetRevision: main
path: manifests
destination:
server: https://kubernetes.default.svc
namespace: production
```
Weitere Informationen zu den Ressourcen und Konzepten von Argo CD finden Sie unter[Argo CD-Konzepte](argocd-concepts.md).
## Kro-Ressourcen
Wenn Sie die Kro-Funktion aktivieren, können Sie die folgenden Kubernetes-Ressourcen erstellen und verwalten:
**ResourceGraphDefinition (RGD)**
Definiert eine benutzerdefinierte API, die mehrere Kubernetes und AWS Ressourcen zu einer Abstraktion auf höherer Ebene zusammenfasst. Plattformteams erstellen `ResourceGraphDefinition` Ressourcen, um wiederverwendbare Muster mit Leitplanken bereitzustellen.
**Benutzerdefinierte Ressourceninstanzen**
Nachdem Sie eine `ResourceGraphDefinition` Ressource erstellt haben, können Sie Instanzen der von der definierten benutzerdefinierten API erstellen`ResourceGraphDefinition`. kro erstellt und verwaltet automatisch die in der `ResourceGraphDefinition` angegebenen Ressourcen.
`ResourceGraphDefinition`Beispielressource:
```
apiVersion: kro.run/v1alpha1
kind: ResourceGraphDefinition
metadata:
name: web-application
spec:
schema:
apiVersion: v1alpha1
kind: WebApplication
spec:
name: string
replicas: integer
resources:
- id: deployment
template:
apiVersion: apps/v1
kind: Deployment
# ... deployment spec
- id: service
template:
apiVersion: v1
kind: Service
# ... service spec
```
`WebApplication`Beispielinstanz:
```
apiVersion: v1alpha1
kind: WebApplication
metadata:
name: my-web-app
namespace: default
spec:
name: my-web-app
replicas: 3
```
Wenn Sie diese Instanz anwenden, erstellt kro automatisch die `Deployment` in der `ResourceGraphDefinition` definierten `Service` Ressourcen.
Weitere Informationen zu den Ressourcen und Konzepten von Kro finden Sie unter. [Kro-Konzepte](kro-concepts.md)
## ACK-Ressourcen
Wenn Sie die ACK-Fähigkeit aktivieren, können Sie AWS Ressourcen mithilfe von benutzerdefinierten Kubernetes-Ressourcen erstellen und verwalten. ACK bietet über 200 Dienste CRDs für mehr als 50 AWS Dienste, sodass Sie AWS Ressourcen neben Ihren Kubernetes-Workloads definieren und dedizierte AWS Infrastrukturressourcen mit Kubernetes verwalten können.
Beispiele für ACK-Ressourcen:
**S3 Bucket (S3-Bucket)**
`Bucket`Ressourcen erstellen und verwalten Amazon S3 S3-Buckets mit Versionierungs-, Verschlüsselungs- und Lebenszyklusrichtlinien.
**RDS DBInstance**
`DBInstance`Bereitstellung und Verwaltung von Amazon RDS-Datenbank-Instances mit automatisierten Backups und Wartungsfenstern.
**DynamoDB-Tabelle**
`Table`Ressourcen erstellen und verwalten DynamoDB-Tabellen mit bereitgestellter oder bedarfsgesteuerter Kapazität.
**IAM Role** (IAM-Rolle)
`Role`Ressourcen definieren IAM-Rollen mit Vertrauensrichtlinien und Berechtigungsrichtlinien für den Servicezugriff. AWS
**Lambda-Funktion**
`Function`Ressourcen erstellen und verwalten Lambda-Funktionen mit Code-, Laufzeit- und Ausführungsrollenkonfiguration.
Beispiel für die Spezifikation einer `Bucket` Ressource:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: my-app-bucket
spec:
name: my-unique-bucket-name-12345
versioning:
status: Enabled
encryption:
rules:
- applyServerSideEncryptionByDefault:
sseAlgorithm: AES256
```
Weitere Informationen zu ACK-Ressourcen und Konzepten finden Sie unter[ACK-Konzepte](ack-concepts.md).
## Ressourcenlimits
Für EKS-Funktionen gelten die folgenden Ressourcengrenzen:
**Nutzungsbeschränkungen für Argo CD**:
+ Maximal 1000 `Application` Ressourcen pro Argo-CD-Capability-Instanz
+ Pro Argo-CD-Capability-Instanz sind maximal 100 Remote-Cluster konfiguriert
**Grenzwerte für die Ressourcenkonfiguration**:
+ Maximal 150 Kubernetes-Ressourcen pro `Application` Ressource in Argo CD
+ Maximal 64 Kubernetes-Ressourcen pro in Kro `ResourceGraphDefinition`
**Anmerkung**
Diese Grenzwerte gelten für die Anzahl der Ressourcen, die von jeder Capability-Instanz verwaltet werden. Wenn Sie höhere Grenzwerte benötigen, können Sie Funktionen auf mehreren Clustern bereitstellen.
## Nächste Schritte
Informationen zu funktionsspezifischen Aufgaben und zur erweiterten Konfiguration finden Sie in den folgenden Themen:
+ [ACK-Konzepte](ack-concepts.md)— Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [Arbeiten mit Argo CD](working-with-argocd.md)— Arbeiten mit den Funktionen von Argo CD für Workflows GitOps
+ [Kro-Konzepte](kro-concepts.md)— Verstehen Sie die KRO-Konzepte und die Zusammensetzung der Ressourcen
# Überlegungen zu den EKS-Fähigkeiten
In diesem Thema werden wichtige Überlegungen zur Nutzung von EKS-Funktionen behandelt, darunter das Design der Zugriffskontrolle, die Wahl zwischen EKS-Funktionen und selbstverwalteten Lösungen, Architekturmuster für Bereitstellungen mit mehreren Clustern und bewährte Verfahren für den Betrieb.
## Capability: IAM-Rollen und Kubernetes RBAC
Jede EKS-Capability-Ressource hat eine konfigurierte Capability-IAM-Rolle. Die Capability-Rolle wird verwendet, um AWS Dienstberechtigungen für EKS-Funktionen zu erteilen, damit sie in Ihrem Namen agieren können. Um beispielsweise die EKS-Funktion für ACK zur Verwaltung von Amazon S3 S3-Buckets zu verwenden, gewähren Sie S3 Bucket Administratorberechtigungen für die Funktion, sodass sie Buckets erstellen und verwalten kann.
Sobald die Funktion konfiguriert ist, können S3-Ressourcen in AWS mit benutzerdefinierten Kubernetes-Ressourcen in Ihrem Cluster erstellt und verwaltet werden. Kubernetes RBAC ist der Cluster-interne Zugriffskontrollmechanismus, mit dem bestimmt wird, welche Benutzer und Gruppen diese benutzerdefinierten Ressourcen erstellen und verwalten können. Erteilen Sie beispielsweise bestimmten Kubernetes RBAC-Benutzern und -Gruppen Berechtigungen zum Erstellen und Verwalten von Ressourcen in Namespaces Ihrer Wahl. `Bucket`
Auf diese Weise sind IAM und Kubernetes RBAC zwei Hälften des Zugriffskontrollsystems, das die Berechtigungen im Zusammenhang mit den end-to-end Funktionen und Ressourcen von EKS regelt. Es ist wichtig, die richtige Kombination aus IAM-Berechtigungen und RBAC-Zugriffsrichtlinien für Ihren Anwendungsfall zu entwerfen.
Weitere Informationen zu Capability IAM-Rollen und Kubernetes-Berechtigungen finden Sie unter. [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Architekturmuster mit mehreren Clustern
Bei der Bereitstellung von Funktionen in mehreren Clustern sollten Sie die folgenden gängigen Architekturmuster berücksichtigen:
**Hub and Spoke mit zentralisierter Verwaltung**
Führen Sie alle drei Funktionen in einem zentral verwalteten Cluster aus, um Workloads zu orchestrieren und die Cloud-Infrastruktur über mehrere Workload-Cluster hinweg zu verwalten.
+ Argo CD auf dem Management-Cluster stellt Anwendungen für Workload-Cluster in verschiedenen Regionen oder Konten bereit
+ ACK auf dem Management-Cluster stellt AWS Ressourcen (RDS, S3, IAM) für alle Cluster bereit
+ kro auf dem Management-Cluster erstellt tragbare Plattformabstraktionen, die in allen Clustern funktionieren
Dieses Muster zentralisiert das Workload- und Cloud-Infrastrukturmanagement und kann den Betrieb für Unternehmen, die viele Cluster verwalten, vereinfachen.
**Dezentralisiert GitOps**
Workloads und Cloud-Infrastruktur werden über Funktionen auf demselben Cluster verwaltet, auf dem die Workloads ausgeführt werden.
+ Argo CD verwaltet Anwendungsressourcen auf dem lokalen Cluster.
+ ACK-Ressourcen werden für Cluster- und Workload-Anforderungen verwendet.
+ Die Abstraktionen der Kro-Plattform werden installiert und orchestrieren lokale Ressourcen.
Dieses Muster dezentralisiert den Betrieb, wobei die Teams ihre eigenen dedizierten Plattformdienste in einem oder mehreren Clustern verwalten.
**Hub-and-Spoke-Lösung mit hybrider ACK-Bereitstellung**
Kombinieren Sie zentralisierte und dezentrale Modelle mit zentralisierter Anwendungsbereitstellung und Ressourcenverwaltung auf der Grundlage von Umfang und Eigentümerschaft.
+ Hub-Cluster:
+ Argo CD verwaltet GitOps Bereitstellungen auf dem lokalen Cluster und allen Remote-Workload-Clustern
+ ACK wird auf dem Management-Cluster für Ressourcen im Administratorbereich (Produktionsdatenbanken, IAM-Rollen,) verwendet VPCs
+ kro wird auf dem Management-Cluster für wiederverwendbare Plattformabstraktionen verwendet
+ Spoke-Cluster:
+ Workloads werden über Argo CD auf dem zentralisierten Hub-Cluster verwaltet
+ ACK wird lokal für Ressourcen im Workloadbereich (S3-Buckets, Instanzen, SQS-Warteschlangen) verwendet ElastiCache
+ kro wird lokal für die Zusammenstellung von Ressourcen und für Bausteinmuster verwendet
Dieses Muster unterscheidet die einzelnen Anliegen: Plattformteams verwalten kritische Infrastrukturen zentral auf Managementclustern, optional einschließlich Workload-Clustern, während Anwendungsteams Cloud-Ressourcen zusammen mit Workloads spezifizieren und verwalten.
**Ein Muster auswählen**
Berücksichtigen Sie bei der Auswahl einer Architektur die folgenden Faktoren:
+ **Organisationsstruktur**: Zentralisierte Plattformteams bevorzugen Hub-Modelle; dezentrale Teams bevorzugen möglicherweise Funktionen pro Cluster
+ **Umfang der Ressourcen**: Ressourcen mit Administratorrechten (Datenbanken, IAM) profitieren häufig von einer zentralen Verwaltung; Workload-Ressourcen (Buckets, Warteschlangen) können lokal verwaltet werden
+ **Self-Service**: Zentralisierte Plattformteams können präskriptive benutzerdefinierte Ressourcen erstellen und verteilen, um Cloud-Ressourcen für allgemeine Workload-Anforderungen sicher selbst zu verwalten
+ **Cluster-Flottenmanagement**: Zentralisierte Management-Cluster bieten eine kundeneigene Steuerungsebene für das EKS-Cluster-Flottenmanagement, zusammen mit anderen administrativen Ressourcen
+ **Compliance-Anforderungen**: Einige Unternehmen benötigen eine zentrale Steuerung für Audit und Governance
+ **Operative Komplexität**: Weniger Funktionsinstanzen vereinfachen den Betrieb, können aber zu Engpässen führen
**Anmerkung**
Sie können mit einem Muster beginnen und sich mit zunehmender Reife Ihrer Plattform zu einem anderen weiterentwickeln. Die Funktionen sind unabhängig — Sie können sie je nach Bedarf in den Clustern unterschiedlich einsetzen.
## Vergleich der EKS-Funktionen mit selbstverwalteten Lösungen
EKS-Funktionen bieten vollständig verwaltete Funktionen für beliebte Kubernetes-Tools und -Controller, die in EKS ausgeführt werden. Dies unterscheidet sich von selbstverwalteten Lösungen, die Sie in Ihrem Cluster installieren und betreiben.
### Die wichtigsten Unterschiede
**Bereitstellung und Verwaltung**
AWS verwaltet die EKS-Funktionen vollständig, ohne dass eine Installation, Konfiguration oder Wartung der Komponentensoftware erforderlich ist. AWS installiert und verwaltet automatisch alle erforderlichen benutzerdefinierten Kubernetes-Ressourcendefinitionen (CRDs) im Cluster.
Bei selbstverwalteten Lösungen installieren und konfigurieren Sie Clustersoftware mithilfe von Helm Charts, Kubectl oder anderen Operatoren. Sie haben die volle Kontrolle über den Softwarelebenszyklus und die Laufzeitkonfiguration Ihrer selbstverwalteten Lösungen und können Anpassungen auf jeder Ebene der Lösung vornehmen.
**Betrieb und Wartung**
AWS verwaltet Patching- und andere Softwarelebenszyklusvorgänge für EKS-Funktionen mit automatischen Updates und Sicherheitspatches. Die Funktionen von EKS sind in AWS Funktionen für optimierte Konfigurationen integriert, bieten integrierte Hochverfügbarkeit und Fehlertoleranz und machen die Behebung von Controller-Workloads im Cluster überflüssig.
Bei selbstverwalteten Lösungen müssen Sie den Zustand und die Protokolle der Komponenten überwachen, Sicherheitspatches und Versionsupdates anwenden, Hochverfügbarkeit mit mehreren Replikaten und Budgets für Pod-Unterbrechungen konfigurieren, Probleme mit der Controller-Arbeitslast beheben und beheben sowie Releases und Versionen verwalten. Sie haben die volle Kontrolle über Ihre Bereitstellungen, aber dafür sind häufig maßgeschneiderte Lösungen für den privaten Clusterzugriff und andere Integrationen erforderlich, die den Unternehmensstandards und den Sicherheitsbestimmungen entsprechen müssen.
**Ressourcenverbrauch**
EKS-Funktionen werden in EKS und außerhalb Ihrer Cluster ausgeführt, wodurch Knoten- und Clusterressourcen freigesetzt werden. Capabilities nutzen keine Cluster-Workload-Ressourcen, verbrauchen weder CPU noch Arbeitsspeicher auf Ihren Worker-Knoten, skalieren automatisch und haben nur minimale Auswirkungen auf die Cluster-Kapazitätsplanung.
Selbstverwaltete Lösungen führen Controller und andere Komponenten auf Ihren Worker-Knoten aus und verbrauchen dabei direkt Worker-Knotenressourcen IPs, Cluster und andere Clusterressourcen. Die Verwaltung von Clusterdiensten erfordert eine Kapazitätsplanung für deren Workloads sowie die Planung und Konfiguration von Ressourcenanforderungen und -limits, um Skalierungs- und Hochverfügbarkeitsanforderungen zu bewältigen.
**Unterstützung von Funktionen**
Als vollständig verwaltete Servicefunktionen sind EKS Capabilities von Natur aus eigensinnig im Vergleich zu selbstverwalteten Lösungen. Die Funktionen werden zwar die meisten Funktionen und Anwendungsfälle unterstützen, allerdings wird es im Vergleich zu selbstverwalteten Lösungen einen Unterschied in der Abdeckung geben.
Bei selbstverwalteten Lösungen haben Sie die vollständige Kontrolle über die Konfiguration, optionale Funktionen und andere Aspekte der Funktionalität Ihrer Software. Sie können sich dafür entscheiden, Ihre eigenen benutzerdefinierten Images auszuführen, alle Aspekte der Konfiguration anzupassen und die Funktionen Ihrer selbstverwalteten Lösung vollständig zu kontrollieren.
**Überlegungen zu den Kosten**
Für jede EKS-Funktionsressource fallen Kosten pro Stunde an, die je nach Fähigkeitstyp unterschiedlich sind. Für Clusterressourcen, die von der Funktion verwaltet werden, fallen auch stündliche Kosten mit eigenen Preisen an. Weitere Informationen finden Sie unter [Amazon EKS – Preise](https://aws.amazon.com/eks/pricing/).
Bei selbstverwalteten Lösungen fallen keine direkten Kosten im Zusammenhang mit AWS Gebühren an. Sie zahlen jedoch für Cluster-Rechenressourcen, die von Controllern genutzt werden, und für die damit verbundenen Workloads. Neben dem Ressourcenverbrauch von Knoten und Clustern umfassen die Gesamtbetriebskosten bei selbstverwalteten Lösungen auch die Betriebskosten sowie die Kosten für Wartung, Fehlerbehebung und Support.
### Sie haben die Wahl zwischen EKS-Funktionen und selbstverwalteten Lösungen
**EKS-Funktionen** Ziehen Sie diese Wahl in Betracht, wenn Sie den betrieblichen Aufwand reduzieren und sich auf den Mehrwert Ihrer Software und Systeme konzentrieren möchten, anstatt den Betrieb der Clusterplattform für grundlegende Anforderungen zu bündeln. Verwenden Sie EKS Capabilities, wenn Sie den betrieblichen Aufwand durch Sicherheitspatches und Software-Lebenszyklusmanagement minimieren, Knoten- und Clusterressourcen für Anwendungsworkloads freigeben, die Konfiguration und das Sicherheitsmanagement vereinfachen und vom AWS Support profitieren möchten. Die EKS-Funktionen eignen sich ideal für die meisten Anwendungsfälle in der Produktion und sind der empfohlene Ansatz für neue Implementierungen.
**Selbstverwaltete Lösungen** Ziehen Sie diese Wahl in Betracht, wenn Sie bestimmte Versionen der Kubernetes-Ressourcen-API oder benutzerdefinierte Controller-Builds benötigen, bereits vorhandene Automatisierungs- und Tools auf selbstverwalteten Bereitstellungen aufbauen möchten oder wenn Sie umfassende Anpassungen der Controller-Laufzeitkonfigurationen benötigen. Selbstverwaltete Lösungen bieten Flexibilität für spezielle Anwendungsfälle, und Sie haben die vollständige Kontrolle über Ihre Bereitstellung und Laufzeitkonfiguration.
**Anmerkung**
EKS-Funktionen können in Ihrem Cluster mit selbstverwalteten Lösungen koexistieren, und schrittweise Migrationen sind möglich.
### Fähigkeitsspezifische Vergleiche
Detaillierte Vergleiche, einschließlich funktionsspezifischer Funktionen, Upstream-Unterschiede und Migrationspfade, finden Sie unter:
+ [Vergleich der EKS-Funktionen für ACK mit selbstverwaltetem ACK](ack-comparison.md)
+ [Vergleich der EKS-Funktionen für Argo CD mit selbstverwalteter Argo-CD](argocd-comparison.md)
+ [Vergleich der EKS-Funktionen für Kro mit selbstverwaltetem Kro](kro-comparison.md)
# Stellen Sie AWS Ressourcen aus Kubernetes mit AWS Controllers for Kubernetes (ACK) bereit
AWS Mit Controllers for Kubernetes (ACK) können Sie Serviceressourcen direkt von Kubernetes aus definieren und verwalten. AWS Mit AWS Controllers for Kubernetes (ACK) können Sie Workload-Ressourcen und Cloud-Infrastruktur mithilfe von benutzerdefinierten Kubernetes-Ressourcen direkt neben Ihren Anwendungs-Workloads mit vertrauten Kubernetes und Tools verwalten. APIs
Mit EKS-Funktionen wird ACK vollständig verwaltet AWS, sodass Sie keine ACK-Controller auf Ihren Clustern installieren, warten und skalieren müssen.
## Wie funktioniert ACK
ACK übersetzt benutzerdefinierte Kubernetes-Ressourcenspezifikationen in AWS API-Aufrufe. Wenn Sie eine benutzerdefinierte Kubernetes-Ressource, die eine AWS Dienstressource darstellt, erstellen, aktualisieren oder löschen, führt ACK die erforderlichen AWS API-Aufrufe durch, um die Ressource zu erstellen, zu aktualisieren oder zu löschen. AWS
Jede von ACK unterstützte AWS Ressource hat ihre eigene benutzerdefinierte Ressourcendefinition (CRD), die das Kubernetes-API-Schema für die Angabe ihrer Konfiguration definiert. ACK bietet CRDs beispielsweise S3 einschließlich Buckets, Bucket-Richtlinien und andere S3-Ressourcen.
ACK gleicht den Status Ihrer AWS Ressourcen kontinuierlich mit dem gewünschten Status ab, der in Ihren benutzerdefinierten Kubernetes-Ressourcen definiert ist. Wenn eine Ressource von ihrem gewünschten Zustand abweicht, erkennt ACK dies und ergreift Korrekturmaßnahmen, um sie wieder in Einklang zu bringen. Änderungen an Kubernetes-Ressourcen wirken sich sofort auf den AWS Ressourcenstatus aus, während die passive Drift-Erkennung und Behebung von AWS Upstream-Ressourcenänderungen bis zu 10 Stunden dauern kann (die Resynchronisierungszeit), in der Regel jedoch viel früher erfolgt.
**Beispiel für ein S3-Bucket-Ressourcenmanifest**
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: my-ack-bucket
spec:
name: my-unique-bucket-name
```
Wenn Sie diese benutzerdefinierte Ressource auf Ihren Cluster anwenden, erstellt ACK einen Amazon S3 S3-Bucket in Ihrem Konto, falls dieser noch nicht vorhanden ist. Spätere Änderungen an dieser Ressource, z. B. die Angabe einer nicht standardmäßigen Speicherstufe oder das Hinzufügen einer Richtlinie, werden auf die S3-Ressource in AWS angewendet. Wenn diese Ressource aus dem Cluster gelöscht wird, wird der AWS darin enthaltene S3-Bucket standardmäßig gelöscht.
## Vorteile von ACK
ACK bietet Kubernetes-natives AWS Ressourcenmanagement, sodass Sie AWS Ressourcen mit demselben Kubernetes APIs und denselben Tools verwalten können, die Sie für Ihre Anwendungen verwenden. Dieser einheitliche Ansatz vereinfacht Ihren Infrastrukturmanagement-Workflow, da Sie nicht mehr zwischen verschiedenen Tools wechseln oder separate Systeme erlernen müssen. infrastructure-as-code Sie definieren Ihre AWS Ressourcen deklarativ in Kubernetes-Manifesten und ermöglichen so GitOps Workflows und Infrastruktur als Code-Praktiken, die sich nahtlos in Ihre bestehenden Entwicklungsprozesse integrieren lassen.
ACK gleicht kontinuierlich den gewünschten Zustand Ihrer AWS Ressourcen mit ihrem tatsächlichen Zustand ab, korrigiert Abweichungen und sorgt für Konsistenz in Ihrer gesamten Infrastruktur. Dieser kontinuierliche Abgleich bedeutet, dass wichtige out-of-band Änderungen an AWS Ressourcen automatisch rückgängig gemacht werden, sodass sie Ihrer deklarierten Konfiguration entsprechen, sodass die Integrität Ihrer Infrastruktur als Code gewahrt bleibt. Sie können ACK so konfigurieren, dass Ressourcen über mehrere AWS Konten und Regionen hinweg verwaltet werden, sodass komplexe Architekturen mit mehreren Konten ohne zusätzliche Tools ermöglicht werden.
Für Unternehmen, die von anderen Infrastrukturmanagement-Tools migrieren, unterstützt ACK die Einführung von Ressourcen, sodass Sie vorhandene AWS Ressourcen unter das ACK-Management stellen können, ohne sie neu erstellen zu müssen. ACK bietet außerdem schreibgeschützte Ressourcen für die AWS Ressourcenbeobachtung ohne Änderungszugriff sowie Anmerkungen, um AWS Ressourcen optional auch dann beizubehalten, wenn die Kubernetes-Ressource aus dem Cluster gelöscht wird.
Weitere Informationen und erste Schritte mit der EKS-Funktion für ACK finden Sie unter und. [ACK-Konzepte](ack-concepts.md) [ACK-Überlegungen für EKS](ack-considerations.md)
## Unterstützte AWS Dienste
ACK unterstützt eine breite Palette von AWS Diensten, einschließlich, aber nicht beschränkt auf:
+ Amazon EC2
+ Amazon S3
+ Amazon RDS
+ Amazon DynamoDB
+ Amazon ElastiCache
+ Amazon EKS
+ Amazon SQS
+ Amazon SNS
+ AWS Lambda
+ AWS ICH BIN
Alle AWS Dienste, die im Upstream-Bereich als allgemein verfügbar aufgeführt sind, werden von der EKS-Funktion für ACK unterstützt. Einzelheiten finden Sie in [der vollständigen Liste der unterstützten AWS Dienste](https://aws-controllers-k8s.github.io/community/docs/community/services/).
## Integration mit anderen von EKS verwalteten Funktionen
ACK lässt sich in andere von EKS verwaltete Funktionen integrieren.
+ **Argo CD**: Verwenden Sie Argo CD, um die Bereitstellung von ACK-Ressourcen in mehreren Clustern zu verwalten und so GitOps Workflows für Ihre AWS Infrastruktur zu ermöglichen.
+ ACK erweitert die Vorteile von GitOps , wenn es mit ArgoCD kombiniert wird, aber ACK erfordert keine Integration mit Git.
+ **kro (Kube Resource Orchestrator)**: Verwenden Sie Kro, um komplexe Ressourcen aus ACK-Ressourcen zusammenzustellen und so Abstraktionen auf höherer Ebene zu erstellen, die das Ressourcenmanagement vereinfachen.
+ Sie können mit kro zusammengesetzte benutzerdefinierte Ressourcen erstellen, die sowohl Kubernetes-Ressourcen als auch Ressourcen definieren. AWS Teammitglieder können diese benutzerdefinierten Ressourcen verwenden, um komplexe Anwendungen schnell bereitzustellen.
## Erste Schritte mit ACK
Erste Schritte mit der EKS-Funktion für ACK:
1. Erstellen und konfigurieren Sie eine IAM-Capability-Rolle mit den erforderlichen Berechtigungen, damit ACK AWS Ressourcen in Ihrem Namen verwalten kann.
1. [Erstellen Sie eine ACK-Fähigkeitsressource](create-ack-capability.md) auf Ihrem EKS-Cluster über die AWS Konsole, AWS CLI oder Ihr bevorzugtes Infrastructure-as-Code-Tool.
1. Wenden Sie benutzerdefinierte Kubernetes-Ressourcen auf Ihren Cluster an, um mit der Verwaltung Ihrer AWS Ressourcen in Kubernetes zu beginnen.
# Erstellen Sie eine ACK-Fähigkeit
In diesem Kapitel wird erklärt, wie Sie eine ACK-Fähigkeit in Ihrem Amazon EKS-Cluster erstellen.
## Voraussetzungen
Bevor Sie eine ACK-Fähigkeit erstellen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Ein Amazon-EKS-Cluster
+ Eine IAM-Fähigkeitsrolle mit Berechtigungen für ACK zur Verwaltung von Ressourcen AWS
+ Ausreichende IAM-Berechtigungen zum Erstellen von Funktionsressourcen auf EKS-Clustern
+ Das entsprechende installierte und konfigurierte CLI-Tool oder Zugriff auf die EKS-Konsole
Anweisungen zur Erstellung der IAM-Capability-Rolle finden Sie unter[IAM-Rolle für Amazon EKS-Funktionen](capability-role.md).
**Wichtig**
ACK ist eine Infrastrukturverwaltungsfunktion, die das Erstellen, Ändern und Löschen von AWS Ressourcen ermöglicht. Dabei handelt es sich um eine Funktion für Administratoren, die sorgfältig kontrolliert werden sollte. Jeder, der die Erlaubnis hat, Kubernetes-Ressourcen in Ihrem Cluster zu erstellen, kann Ressourcen effektiv über ACK erstellen, sofern die Berechtigungen für die AWS IAM-Capability Role erfüllt sind. Die von Ihnen bereitgestellte IAM-Capability-Rolle bestimmt, welche AWS Ressourcen ACK erstellen und verwalten kann. Anleitungen zum Erstellen 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 ACK-Fähigkeit mit der AWS-Managementkonsole AWS CLI oder eksctl erstellen:
+ [Erstellen Sie eine ACK-Fähigkeit mithilfe der Konsole](ack-create-console.md)- Verwenden Sie die Konsole für ein geführtes Erlebnis
+ [Erstellen Sie eine ACK-Fähigkeit mit der AWS CLI](ack-create-cli.md)- Verwenden Sie die AWS CLI für Scripting und Automatisierung
+ [Erstellen Sie eine ACK-Fähigkeit mit eksctl](ack-create-eksctl.md)- Verwenden Sie eksctl für ein Kubernetes-natives Erlebnis
## Was passiert, wenn Sie eine ACK-Fähigkeit erstellen
Wenn Sie eine ACK-Fähigkeit erstellen:
1. EKS erstellt den ACK-Fähigkeitsdienst und konfiguriert ihn für die Überwachung und Verwaltung der Ressourcen in Ihrem Cluster
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. Die Funktion setzt die von Ihnen bereitgestellte IAM-Fähigkeitsrolle voraus
1. ACK beginnt, in Ihrem Cluster nach seinen benutzerdefinierten Ressourcen Ausschau zu halten
1. Der Funktionsstatus ändert sich von `CREATING` zu `ACTIVE`
Sobald sie aktiv sind, können Sie benutzerdefinierte ACK-Ressourcen in Ihrem Cluster erstellen, um AWS Ressourcen zu verwalten.
**Anmerkung**
Der automatisch erstellte Zugriffseintrag umfasst den`AmazonEKSACKPolicy`, der ACK-Berechtigungen zur Verwaltung von AWS Ressourcen gewährt. Für einige ACK-Ressourcen, die auf geheime Kubernetes-Geheimnisse verweisen (z. B. RDS-Datenbanken mit Passwörtern), sind zusätzliche Zugriffsrichtlinien erforderlich. Weitere Informationen zu Zugriffseinträgen und zur Konfiguration zusätzlicher Berechtigungen finden Sie unter. [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Nächste Schritte
Nach dem Erstellen der ACK-Fähigkeit:
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und beginnen Sie mit AWS Ressourcen
+ [ACK-Konzepte](ack-concepts.md)- Erfahren Sie mehr über Abstimmungen, Feldexporte und Muster bei der Nutzung von Ressourcen
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM-Berechtigungen und Muster für mehrere Konten
# Erstellen Sie eine ACK-Fähigkeit mithilfe der Konsole
In diesem Thema wird beschrieben, wie Sie eine AWS Controllers for Kubernetes (ACK) -Funktion mithilfe von erstellen. AWS-Managementkonsole
## Erstellen Sie die ACK-Fähigkeit
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 ** AWS Controllers for Kubernetes (ACK)** aus.
1. Wählen Sie **Create AWS Controllers for Kubernetes** Capability aus.
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 Administratorrolle **erstellen**
Dadurch wird die IAM-Konsole auf einer neuen Registerkarte mit vorab ausgefüllten Vertrauensrichtlinien und der `AdministratorAccess` verwalteten Richtlinie geöffnet. Sie können die Auswahl dieser Richtlinie aufheben und bei Bedarf weitere Berechtigungen hinzufügen.
Kehren Sie nach dem Erstellen der Rolle zur EKS-Konsole zurück. Die Rolle wird automatisch ausgewählt.
**Wichtig**
Die vorgeschlagene `AdministratorAccess` Richtlinie gewährt umfassende Berechtigungen und soll den Einstieg vereinfachen. Für den produktiven Einsatz sollten Sie diese Richtlinie durch eine benutzerdefinierte Richtlinie ersetzen, die nur die Berechtigungen gewährt, die für die spezifischen AWS Dienste erforderlich sind, die Sie mit ACK verwalten möchten. Anleitungen zur Erstellung von Richtlinien mit den geringsten Rechten finden Sie unter und. [ACK-Berechtigungen konfigurieren](ack-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
1. Wählen Sie **Erstellen** aus.
Der Prozess zur Schaffung von Fähigkeiten beginnt.
## Stellen Sie sicher, dass die Fähigkeit aktiv ist
1. Sehen Sie sich auf der Registerkarte **Funktionen** den Status der ACK-Fähigkeit an.
1. Warten Sie, bis sich der Status von `CREATING` zu ändert`ACTIVE`.
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).
## Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Stellen Sie nach der Aktivierung der Funktion sicher, dass benutzerdefinierte ACK-Ressourcen in Ihrem Cluster verfügbar sind.
**Verwenden der Konsole**
1. Navigieren Sie in der Amazon EKS-Konsole zu Ihrem Cluster.
1. Wählen Sie die Registerkarte **Ressourcen**
1. Wählen Sie **Erweiterungen**
1. Wählen Sie **CustomResourceDefinitions** aus.
Sie sollten eine Reihe von AWS Ressourcen CRDs auflisten sehen.
**Verwenden Sie kubectl**
```
kubectl api-resources | grep services.k8s.aws
```
Sie sollten eine Reihe von Ressourcen APIs aufgelistet sehen. AWS
**Anmerkung**
Die Funktion für AWS Controller for Kubernetes wird eine Reihe von CRDs für eine Vielzahl von AWS Ressourcen installieren.
## Nächste Schritte
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und legen Sie los
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM-Berechtigungen für andere Dienste AWS
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre ACK-Fähigkeitsressource
# Erstellen Sie eine ACK-Fähigkeit mit der AWS CLI
In diesem Thema wird beschrieben, wie Sie mithilfe der AWS CLI eine Controllers for Kubernetes-Funktion (ACK) erstellen. AWS
## 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).
## Schritt 1: Erstellen Sie eine IAM-Capability-Rolle
Erstellen Sie eine Vertrauensrichtliniendatei:
```
cat > ack-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 ACKCapabilityRole \
--assume-role-policy-document file://ack-trust-policy.json
```
Hängen Sie die `AdministratorAccess` verwaltete Richtlinie an die Rolle an:
```
aws iam attach-role-policy \
--role-name ACKCapabilityRole \
--policy-arn arn:aws:iam::aws:policy/AdministratorAccess
```
**Wichtig**
Die vorgeschlagene `AdministratorAccess` Richtlinie gewährt umfassende Berechtigungen und soll den Einstieg vereinfachen. Für den produktiven Einsatz sollten Sie diese Richtlinie durch eine benutzerdefinierte Richtlinie ersetzen, die nur die Berechtigungen gewährt, die für die spezifischen AWS Dienste erforderlich sind, die Sie mit ACK verwalten möchten. Anleitungen zur Erstellung von Richtlinien mit den geringsten Rechten finden Sie unter und. [ACK-Berechtigungen konfigurieren](ack-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
## Schritt 2: Erstellen Sie die ACK-Fähigkeit
Erstellen Sie die ACK-Fähigkeitsressource auf Ihrem Cluster. *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.
```
aws eks create-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-ack \
--type ACK \
--role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/ACKCapabilityRole \
--delete-propagation-policy RETAIN
```
Der Befehl wird sofort zurückgegeben, 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 es durch die AWS Region, in der sich Ihr Cluster befindet, und *my-cluster* ersetzen Sie es durch den Namen Ihres Clusters.
```
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-ack \
--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-ack
```
## Schritt 4: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte ACK-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep services.k8s.aws
```
Sie sollten eine Reihe von AWS Ressourcen in der APIs Liste sehen.
**Anmerkung**
Die Funktion für AWS Controller for Kubernetes wird eine Reihe von CRDs für eine Vielzahl von AWS Ressourcen installieren.
## Nächste Schritte
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und legen Sie los
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM-Berechtigungen für andere Dienste AWS
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre ACK-Fähigkeitsressource
# Erstellen Sie eine ACK-Fähigkeit mit eksctl
In diesem Thema wird beschrieben, wie Sie mit eksctl eine AWS Controllers for Kubernetes-Funktion (ACK) 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 > ack-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 ACKCapabilityRole \
--assume-role-policy-document file://ack-trust-policy.json
```
Hängen Sie die `AdministratorAccess` verwaltete Richtlinie an die Rolle an:
```
aws iam attach-role-policy \
--role-name ACKCapabilityRole \
--policy-arn arn:aws:iam::aws:policy/AdministratorAccess
```
**Wichtig**
Die vorgeschlagene `AdministratorAccess` Richtlinie gewährt umfassende Berechtigungen und soll den Einstieg vereinfachen. Für den produktiven Einsatz sollten Sie diese Richtlinie durch eine benutzerdefinierte Richtlinie ersetzen, die nur die Berechtigungen gewährt, die für die spezifischen AWS Dienste erforderlich sind, die Sie mit ACK verwalten möchten. Anleitungen zur Erstellung von Richtlinien mit den geringsten Rechten finden Sie unter und. [ACK-Berechtigungen konfigurieren](ack-permissions.md) [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)
**Wichtig**
Diese Richtlinie gewährt Berechtigungen für die S3-Bucketverwaltung mit`"Resource": "*"`, wodurch Operationen auf allen S3-Buckets möglich sind.
Für Produktionszwecke: \$1 Beschränken Sie das `Resource` Feld auf bestimmte Bucket ARNs - oder Namensmuster \$1 Verwenden Sie IAM-Bedingungsschlüssel, um den Zugriff anhand von Ressourcen-Tags einzuschränken \$1 Gewähren Sie nur die für Ihren Anwendungsfall erforderlichen Mindestberechtigungen
Weitere AWS Dienste finden Sie unter[ACK-Berechtigungen konfigurieren](ack-permissions.md).
Fügen Sie die Richtlinie an die Rolle an:
```
aws iam attach-role-policy \
--role-name ACKCapabilityRole \
--policy-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):policy/ACKS3Policy
```
## Schritt 2: Erstellen Sie die ACK-Fähigkeit
Erstellen Sie die ACK-Fähigkeit mit eksctl. *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 create capability \
--cluster [.replaceable]`my-cluster` \
--region [.replaceable]`region-code` \
--name ack \
--type ACK \
--role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/ACKCapabilityRole \
--ack-service-controllers s3
```
**Anmerkung**
Die `--ack-service-controllers` Flagge ist optional. Wenn es weggelassen wird, aktiviert ACK alle verfügbaren Controller. Für eine bessere Leistung und Sicherheit sollten Sie erwägen, nur die Controller zu aktivieren, die Sie benötigen. Sie können mehrere Controller angeben: `--ack-service-controllers s3,rds,dynamodb`
Der Befehl kehrt sofort zurück, aber es dauert einige Zeit, bis die Funktion aktiv wird.
## Schritt 3: Stellen Sie sicher, dass die Funktion aktiv ist
Überprüfen Sie den Status der Fähigkeit:
```
eksctl get capability \
--cluster [.replaceable]`my-cluster` \
--region [.replaceable]`region-code` \
--name ack
```
Die Fähigkeit ist bereit, wenn der Status angezeigt wird`ACTIVE`.
## Schritt 4: Stellen Sie sicher, dass benutzerdefinierte Ressourcen verfügbar sind
Nachdem die Funktion aktiviert ist, stellen Sie sicher, dass benutzerdefinierte ACK-Ressourcen in Ihrem Cluster verfügbar sind:
```
kubectl api-resources | grep services.k8s.aws
```
Sie sollten eine Reihe von AWS Ressourcen in der APIs Liste sehen.
**Anmerkung**
Die Funktion für AWS Controller for Kubernetes wird eine Reihe von CRDs für eine Vielzahl von AWS Ressourcen installieren.
## Nächste Schritte
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und legen Sie los
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM-Berechtigungen für andere Dienste AWS
+ [Mit Capability-Ressourcen arbeiten](working-with-capabilities.md)- Verwalten Sie Ihre ACK-Fähigkeitsressource
# ACK-Konzepte
ACK verwaltet AWS Ressourcen über Kubernetes, APIs indem es kontinuierlich den gewünschten Status in Ihren Manifesten mit dem tatsächlichen Status in abgleicht. AWS Wenn Sie eine benutzerdefinierte Kubernetes-Ressource erstellen oder aktualisieren, führt ACK die erforderlichen AWS API-Aufrufe durch, um die entsprechende AWS Ressource zu erstellen oder zu ändern, überwacht sie dann auf Abweichungen und aktualisiert den Kubernetes-Status, um den aktuellen Status widerzuspiegeln. Mit diesem Ansatz können Sie die Infrastruktur mithilfe vertrauter Kubernetes-Tools und -Workflows verwalten und gleichzeitig die Konsistenz zwischen Ihrem Cluster und aufrechterhalten. AWS
In diesem Thema werden die grundlegenden Konzepte erläutert, die der Verwaltung von AWS Ressourcen durch ACK über Kubernetes zugrunde liegen. APIs
## Erste Schritte mit ACK
Nachdem Sie die ACK-Fähigkeit erstellt haben (siehe[Erstellen Sie eine ACK-Fähigkeit](create-ack-capability.md)), können Sie mit der Verwaltung von AWS Ressourcen mithilfe von Kubernetes-Manifesten in Ihrem Cluster beginnen.
Erstellen Sie beispielsweise dieses S3-Bucket-Manifest in und wählen Sie `bucket.yaml` dabei Ihren eigenen eindeutigen Bucket-Namen.
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: my-test-bucket
namespace: default
spec:
name: my-unique-bucket-name-12345
```
Wenden Sie das Manifest an:
```
kubectl apply -f bucket.yaml
```
Überprüfen Sie den Status:
```
kubectl get bucket my-test-bucket
kubectl describe bucket my-test-bucket
```
Stellen Sie sicher, dass der Bucket erstellt wurde in AWS:
```
aws s3 ls | grep my-unique-bucket-name-12345
```
Löschen Sie die Kubernetes-Ressource:
```
kubectl delete bucket my-test-bucket
```
Stellen Sie sicher, dass der Bucket gelöscht wurde aus: AWS
```
aws s3 ls | grep my-unique-bucket-name-12345
```
Der Bucket sollte nicht mehr in der Liste erscheinen, was zeigt, dass ACK den gesamten Lebenszyklus von AWS Ressourcen verwaltet.
Weitere Informationen zu den ersten Schritten mit ACK finden Sie unter [Erste Schritte mit ACK](https://aws-controllers-k8s.github.io/community/docs/user-docs/getting-started/).
## Lebenszyklus und Abstimmung von Ressourcen
ACK verwendet eine kontinuierliche Abstimmungsschleife, um sicherzustellen, dass Ihre AWS Ressourcen dem gewünschten Status entsprechen, der in Ihren Kubernetes-Manifesten definiert ist.
**So funktioniert der Abgleich**:
1. Sie erstellen oder aktualisieren eine benutzerdefinierte Kubernetes-Ressource (z. B. einen S3-Bucket)
1. ACK erkennt die Änderung und vergleicht den gewünschten Zustand mit dem tatsächlichen Zustand in AWS
1. Wenn sie sich unterscheiden, führt ACK AWS API-Aufrufe durch, um den Unterschied auszugleichen
1. ACK aktualisiert den Ressourcenstatus in Kubernetes, um den aktuellen Status widerzuspiegeln
1. Die Schleife wiederholt sich kontinuierlich, in der Regel alle paar Stunden
Der Abgleich wird ausgelöst, wenn Sie eine neue Kubernetes-Ressource erstellen, die einer vorhandenen Ressource aktualisieren oder wenn ACK feststellt`spec`, dass aufgrund manueller Änderungen, die außerhalb AWS von ACK vorgenommen wurden, Abweichungen auftreten. Darüber hinaus führt ACK einen regelmäßigen Abgleich mit einer Resynchronisierungszeit von 10 Stunden durch. Änderungen an Kubernetes-Ressourcen lösen einen sofortigen Abgleich aus, während die passive Drift-Erkennung von AWS Upstream-Ressourcenänderungen während der regelmäßigen Neusynchronisierung erfolgt.
Bei der Bearbeitung des obigen Beispiels für die ersten Schritte führt ACK die folgenden Schritte aus:
1. Prüft, ob ein Bucket existiert in AWS
1. Wenn nicht, ruft `s3:CreateBucket`
1. Aktualisiert den Kubernetes-Status mit dem Bucket ARN und dem Status
1. Setzt die Überwachung auf Drift fort
Weitere Informationen zur Funktionsweise von ACK finden Sie unter [ACK Reconciliation](https://aws-controllers-k8s.github.io/community/docs/user-docs/reconciliation/).
## Statusbedingungen
ACK-Ressourcen verwenden Statusbedingungen, um ihren Status zu kommunizieren. Wenn Sie diese Bedingungen verstehen, können Sie Probleme beheben und den Zustand der Ressourcen besser verstehen.
+ **Bereit**: Zeigt an, dass die Ressource bereit ist, genutzt zu werden (standardisierter Kubernetes-Zustand).
+ **ZURÜCK. ResourceSynced**: Zeigt an, dass die Ressourcenspezifikation dem AWS Ressourcenstatus entspricht.
+ **ack.Terminal**: Zeigt an, dass ein nicht behebbarer Fehler aufgetreten ist.
+ **ack.Adopted**: Zeigt an, dass die Ressource aus einer vorhandenen Ressource übernommen und nicht neu erstellt wurde. AWS
+ **Ack.Recoverable: Weist auf einen behebbaren** Fehler hin, der ohne Aktualisierung der Spezifikation behoben werden kann.
+ **ACK.Advisory**: Stellt Beratungsinformationen zu der Ressource bereit.
+ **ACK. LateInitialized**: Zeigt an, ob die späte Initialisierung der Felder abgeschlossen ist.
+ **ZURÜCK. ReferencesResolved**: Gibt an, ob alle `AWSResourceReference` Felder aufgelöst wurden.
+ **ZURÜCK. IAMRoleAusgewählt**: Gibt an, ob ein IAMRole Selektor für die Verwaltung dieser Ressource ausgewählt wurde.
Überprüfen Sie den Ressourcenstatus:
```
# Check if resource is ready
kubectl get bucket my-bucket -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}'
# Check for terminal errors
kubectl get bucket my-bucket -o jsonpath='{.status.conditions[?(@.type=="ACK.Terminal")]}'
```
Beispiel für einen Status:
```
status:
conditions:
- type: Ready
status: "True"
lastTransitionTime: "2024-01-15T10:30:00Z"
- type: ACK.ResourceSynced
status: "True"
lastTransitionTime: "2024-01-15T10:30:00Z"
- type: ACK.Terminal
status: "True"
ackResourceMetadata:
arn: arn:aws:s3:::my-unique-bucket-name
ownerAccountID: "111122223333"
region: us-west-2
```
Weitere Informationen zum ACK-Status und zu den ACK-Bedingungen finden Sie unter [ACK-Bedingungen](https://aws-controllers-k8s.github.io/community/docs/user-docs/conditions/).
## Richtlinien zum Löschen
Die Löschrichtlinie von ACK steuert, was mit AWS Ressourcen passiert, wenn Sie die Kubernetes-Ressource löschen.
**Löschen (Standard)**
Die AWS Ressource wird gelöscht, wenn Sie die Kubernetes-Ressource löschen: Dies ist das Standardverhalten.
```
# No annotation needed - this is the default
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: temp-bucket
spec:
name: temporary-bucket
```
Durch das Löschen dieser Ressource wird der S3-Bucket in gelöscht. AWS
**Beibehalten**
Die AWS Ressource bleibt erhalten, wenn Sie die Kubernetes-Ressource löschen:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: important-bucket
annotations:
services.k8s.aws/deletion-policy: "retain"
spec:
name: production-data-bucket
```
Wenn Sie diese Ressource löschen, wird sie aus Kubernetes entfernt, der S3-Bucket bleibt jedoch erhalten. AWS
Die `retain` Richtlinie ist nützlich für Produktionsdatenbanken, die die Kubernetes-Ressource überdauern sollen, für gemeinsam genutzte Ressourcen, die von mehreren Anwendungen genutzt werden, für Ressourcen mit wichtigen Daten, die nicht versehentlich gelöscht werden sollten, oder für temporäres ACK-Management, bei dem Sie eine Ressource übernehmen, konfigurieren und sie dann wieder für die manuelle Verwaltung freigeben.
Weitere Informationen zur ACK-Löschrichtlinie finden Sie unter [ACK-Löschrichtlinie](https://aws-controllers-k8s.github.io/community/docs/user-docs/deletion-policy/).
## Einführung von Ressourcen
Durch die Einführung können Sie vorhandene AWS Ressourcen unter das ACK-Management stellen, ohne sie neu erstellen zu müssen.
Wann sollte Adoption verwendet werden:
+ Migration der vorhandenen Infrastruktur zum ACK-Management
+ Wiederherstellung verwaister AWS Ressourcen bei versehentlichem Löschen von Ressourcen in Kubernetes
+ Importieren von Ressourcen, die mit anderen Tools erstellt wurden (CloudFormation, Terraform)
So funktioniert Adoption:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: existing-bucket
annotations:
services.k8s.aws/adoption-policy: "adopt-or-create"
spec:
name: my-existing-bucket-name
```
Wenn Sie diese Ressource erstellen:
1. ACK prüft, ob ein Bucket mit diesem Namen vorhanden ist AWS
1. Wenn es gefunden wird, übernimmt ACK es (keine API-Aufrufe zum Erstellen)
1. ACK liest die aktuelle Konfiguration von AWS
1. ACK aktualisiert den Kubernetes-Status, um den aktuellen Status widerzuspiegeln
1. Zukünftige Updates stimmen die Ressource normal ab
Nach der Übernahme werden Ressourcen wie jede andere ACK-Ressource verwaltet. Wenn Sie die Kubernetes-Ressource löschen, wird die Ressource gelöscht, sofern Sie nicht die AWS Löschrichtlinie verwenden. `retain`
Bei der Übernahme von Ressourcen muss die AWS Ressource bereits vorhanden sein und ACK benötigt Leseberechtigungen, um sie zu finden. Die `adopt-or-create` Richtlinie übernimmt die Ressource, falls sie existiert, oder erstellt sie, wenn sie nicht existiert. Dies ist nützlich, wenn Sie einen deklarativen Workflow benötigen, der unabhängig davon funktioniert, ob die Ressource existiert oder nicht.
Weitere Informationen zur Einführung von ACK-Ressourcen finden Sie unter Einführung von [ACK-Ressourcen](https://aws-controllers-k8s.github.io/community/docs/user-docs/adopted-resource/).
## Konto- und regionsübergreifende Ressourcen
ACK kann Ressourcen in verschiedenen AWS Konten und Regionen von einem einzigen Cluster aus verwalten.
**Regionsübergreifende Anmerkungen zu Ressourcen**
Sie können die Region einer AWS Ressource mithilfe einer Anmerkung angeben:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: eu-bucket
annotations:
services.k8s.aws/region: eu-west-1
spec:
name: my-eu-bucket
```
Sie können auch die Region aller AWS Ressourcen angeben, die in einem bestimmten Namespace erstellt wurden:
**Namespace-Anmerkungen**
Legen Sie eine Standardregion für alle Ressourcen in einem Namespace fest:
```
apiVersion: v1
kind: Namespace
metadata:
name: production
annotations:
services.k8s.aws/default-region: us-west-2
```
In diesem Namespace erstellte Ressourcen verwenden diese Region, sofern sie nicht durch eine Anmerkung auf Ressourcenebene überschrieben wird.
**Kontoübergreifend**
Verwenden Sie IAM-Rollenselektoren, um bestimmte IAM-Rollen Namespaces zuzuordnen:
```
apiVersion: services.k8s.aws/v1alpha1
kind: IAMRoleSelector
metadata:
name: target-account-config
spec:
arn: arn:aws:iam::444455556666:role/ACKTargetAccountRole
namespaceSelector:
names:
- production
```
Ressourcen, die im zugewiesenen Namespace erstellt wurden, verwenden automatisch die angegebene Rolle.
Weitere Informationen zu IAM-Rollenselektoren finden Sie unter Accountübergreifendes [ACK-Ressourcenmanagement](https://aws-controllers-k8s.github.io/docs/guides/cross-account). Einzelheiten zur kontoübergreifenden Konfiguration finden Sie unter. [ACK-Berechtigungen konfigurieren](ack-permissions.md)
## Fehlerbehandlung und Verhalten bei Wiederholungsversuchen
ACK behandelt automatisch vorübergehende Fehler und wiederholt fehlgeschlagene Operationen.
Strategie erneut versuchen:
+ Vorübergehende Fehler (Ratenbegrenzung, vorübergehende Serviceprobleme, unzureichende Berechtigungen) lösen automatische Wiederholungsversuche aus
+ Exponentieller Backoff verhindert Überforderung AWS APIs
+ Die maximale Anzahl von Wiederholungsversuchen ist je nach Fehlertyp unterschiedlich
+ Dauerhafte Fehler (ungültige Parameter, Konflikte mit Ressourcennamen) führen nicht zu einem erneuten Versuch
Überprüfen Sie den Ressourcenstatus auf Fehlerdetails mit`kubectl describe`:
```
kubectl describe bucket my-bucket
```
Suchen Sie nach Statusbedingungen mit Fehlermeldungen, Ereignissen, die die letzten Abgleichversuche anzeigen, und dem `message` Feld unter Statusbedingungen, in denen Fehler erklärt werden. Zu den häufigsten Fehlern gehören unzureichende IAM-Berechtigungen, Konflikte bei Ressourcennamen AWS, ungültige Konfigurationswerte in der `spec` und Überschreitung von AWS Servicekontingenten.
Informationen zur Behebung häufiger Fehler finden Sie unter[Probleme mit ACK-Funktionen beheben](ack-troubleshooting.md).
## Ressourcenzusammensetzung mit Kro
Verwenden Sie die EKS-Funktion für kro (Kube Resource Orchestrator), um mehrere ACK-Ressourcen zusammenzustellen und miteinander zu verbinden. kro bietet eine deklarative Möglichkeit, Ressourcengruppen zu definieren und Konfigurationen zwischen Ressourcen zu übergeben, um komplexe Infrastrukturmuster einfach zu verwalten.
Ausführliche Beispiele für die Erstellung benutzerdefinierter Ressourcenzusammenstellungen mit ACK-Ressourcen finden Sie unter [Kro-Konzepte](kro-concepts.md)
## Nächste Schritte
+ [ACK-Überlegungen für EKS](ack-considerations.md)- EKS-spezifische Muster und Integrationsstrategien
# ACK-Berechtigungen konfigurieren
ACK benötigt IAM-Berechtigungen, um AWS Ressourcen in Ihrem Namen zu erstellen und zu verwalten. In diesem Thema wird erklärt, wie IAM mit ACK zusammenarbeitet, und es finden Sie Anleitungen zur Konfiguration von Berechtigungen für verschiedene Anwendungsfälle.
## Wie funktioniert IAM mit ACK
ACK verwendet IAM-Rollen, um sich bei Ihren Ressourcen zu authentifizieren AWS und Aktionen für sie auszuführen. Es gibt zwei Möglichkeiten, ACK Berechtigungen zu erteilen:
**Funktionsrolle**: Die IAM-Rolle, die Sie bei der Erstellung der ACK-Fähigkeit angeben. Diese Rolle wird standardmäßig für alle ACK-Operationen verwendet.
**IAM-Rollenselektoren**: Zusätzliche IAM-Rollen, die bestimmten Namespaces oder Ressourcen zugeordnet werden können. Diese Rollen haben Vorrang vor der Capability-Rolle für Ressourcen in ihrem Geltungsbereich.
Wenn ACK eine Ressource erstellen oder verwalten muss, bestimmt es, welche IAM-Rolle verwendet werden soll:
1. Prüfen Sie, ob ein IAMRole Selector dem Namespace der Ressource entspricht
1. Wenn eine Übereinstimmung gefunden wird, gehen Sie von dieser IAM-Rolle aus
1. Verwenden Sie andernfalls die Capability-Rolle
Dieser Ansatz ermöglicht ein flexibles Berechtigungsmanagement, von einfachen Einzelrollen-Setups bis hin zu komplexen Konfigurationen mit mehreren Konten und mehreren Teams.
## Erste Schritte: Einfache Einrichtung von Berechtigungen
Für Entwicklungs-, Test- oder einfache Anwendungsfälle können Sie der Capability Role alle erforderlichen Serviceberechtigungen direkt hinzufügen.
Dieser Ansatz funktioniert gut, wenn:
+ Sie fangen mit ACK an
+ Alle Ressourcen befinden sich auf demselben AWS Konto
+ Ein einziges Team verwaltet alle ACK-Ressourcen
+ Sie vertrauen darauf, dass alle ACK-Benutzer dieselben Berechtigungen haben
## Bewährte Methode für die Produktion: IAM-Rollenselektoren
Verwenden Sie in Produktionsumgebungen IAM-Rollenselektoren, um den Zugriff mit den geringsten Rechten und die Isolierung auf Namespace-Ebene zu implementieren.
Bei der Verwendung von IAM-Rollenselektoren benötigt die Capability Role nur die erforderlichen Berechtigungen, um die dienstspezifischen Rollen zu übernehmen. `sts:AssumeRole` `sts:TagSession` Sie müssen der Capability-Rolle selbst keine AWS Serviceberechtigungen (wie S3 oder RDS) hinzufügen — diese Berechtigungen werden den einzelnen IAM-Rollen erteilt, die die Capability-Rolle annimmt.
**Wählen Sie zwischen Berechtigungsmodellen**:
Verwenden Sie **direkte Berechtigungen** (Hinzufügen von Serviceberechtigungen zur Capability Role), wenn:
+ Sie sind am Anfang und möchten die einfachste Einrichtung
+ Alle Ressourcen befinden sich in demselben Konto wie Ihr Cluster
+ Sie haben administrative, clusterweite Berechtigungsanforderungen
+ Alle Teams können dieselben Berechtigungen gemeinsam nutzen
Verwenden Sie **IAM-Rollenselektoren** in folgenden Fällen:
+ Verwaltung von Ressourcen über mehrere Konten hinweg AWS
+ Verschiedene Teams oder Namespaces benötigen unterschiedliche Berechtigungen
+ Sie benötigen eine differenzierte Zugriffskontrolle pro Namespace
+ Sie möchten sich an die Sicherheitsverfahren mit den geringsten Rechten halten
Sie können mit direkten Berechtigungen beginnen und später zu IAM Role Selectors migrieren, wenn Ihre Anforderungen steigen.
**Warum sollten Sie IAM-Rollenselektoren in der Produktion verwenden:**
+ **Geringste Rechte: Jeder Namespace erhält nur die Berechtigungen**, die er benötigt
+ **Teamisolierung**: Team A kann nicht versehentlich die Berechtigungen von Team B verwenden
+ **Einfachere Prüfung**: Klare Zuordnung, welcher Namespace welche Rolle verwendet
+ **Kontoübergreifende Unterstützung**: Erforderlich für die Verwaltung von Ressourcen in mehreren Konten
+ **Trennung der Anliegen**: Verschiedene Dienste oder Umgebungen verwenden unterschiedliche Rollen
### Grundlegende Einrichtung des IAM-Rollenauswahlsystems
**Schritt 1: Erstellen Sie eine dienstspezifische IAM-Rolle**
Erstellen Sie eine IAM-Rolle mit Berechtigungen für bestimmte Dienste: AWS
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:*"
],
"Resource": "*"
}
]
}
```
Konfigurieren Sie die Vertrauensrichtlinie so, dass sie von der Capability Role übernommen wird:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ACKCapabilityRole"
},
"Action": ["sts:AssumeRole", "sts:TagSession"]
}
]
}
```
**Schritt 2: Erteilen Sie der Capability-Rolle die AssumeRole Berechtigung**
Fügen Sie der Capability-Rolle die Erlaubnis hinzu, die dienstspezifische Rolle anzunehmen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["sts:AssumeRole", "sts:TagSession"],
"Resource": "arn:aws:iam::111122223333:role/ACK-S3-Role"
}
]
}
```
**Schritt 3: Selektor erstellen IAMRole**
Ordnen Sie die IAM-Rolle einem Namespace zu:
```
apiVersion: services.k8s.aws/v1alpha1
kind: IAMRoleSelector
metadata:
name: s3-namespace-config
spec:
arn: arn:aws:iam::111122223333:role/ACK-S3-Role
namespaceSelector:
names:
- s3-resources
```
**Schritt 4: Ressourcen im zugewiesenen Namespace erstellen**
Ressourcen im `s3-resources` Namespace verwenden automatisch die angegebene Rolle:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: my-bucket
namespace: s3-resources
spec:
name: my-production-bucket
```
## Verwaltung mehrerer Konten
Verwenden Sie IAM-Rollenauswahlen, um Ressourcen für mehrere Konten zu verwalten. AWS
**Schritt 1: Erstellen Sie eine kontoübergreifende IAM-Rolle**
Erstellen Sie im Zielkonto (444455556666) eine Rolle, die der Capability-Rolle des Quellkontos vertraut:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ACKCapabilityRole"
},
"Action": ["sts:AssumeRole", "sts:TagSession"]
}
]
}
```
Ordnen Sie dieser Rolle dienstspezifische Berechtigungen zu.
**Schritt 2: Erteilen Sie die Erlaubnis AssumeRole **
Erlauben Sie der Capability Role im Quellkonto (111122223333), die Rolle des Zielkontos anzunehmen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["sts:AssumeRole", "sts:TagSession"],
"Resource": "arn:aws:iam::444455556666:role/ACKTargetAccountRole"
}
]
}
```
**Schritt 3: Selektor erstellen IAMRole**
Ordnen Sie die kontoübergreifende Rolle einem Namespace zu:
```
apiVersion: services.k8s.aws/v1alpha1
kind: IAMRoleSelector
metadata:
name: production-account-config
spec:
arn: arn:aws:iam::444455556666:role/ACKTargetAccountRole
namespaceSelector:
names:
- production
```
**Schritt 4: Ressourcen erstellen**
Ressourcen im `production` Namespace werden im Zielkonto erstellt:
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: my-bucket
namespace: production
spec:
name: my-cross-account-bucket
```
## Sitzungs-Tags
Die EKS-ACK-Fähigkeit legt automatisch Sitzungs-Tags für alle AWS API-Anfragen fest. Diese Tags ermöglichen eine detaillierte Zugriffskontrolle und Prüfung, indem sie die Quelle jeder Anfrage identifizieren.
### Verfügbare Sitzungs-Tags
Die folgenden Sitzungs-Tags sind in jedem AWS API-Aufruf von ACK enthalten:
| Tag-Schlüssel | Description |
| --- | --- |
| `eks:eks-capability-arn` | Der ARN der EKS-Funktion, die die Anfrage stellt |
| `eks:kubernetes-namespace` | Der Kubernetes-Namespace der verwalteten Ressource |
| `eks:kubernetes-api-group` | Die Kubernetes-API-Gruppe der Ressource (zum Beispiel) `s3.services.k8s.aws` |
### Verwenden von Sitzungs-Tags für die Zugriffskontrolle
Sie können diese Sitzungs-Tags in den IAM-Richtlinienbedingungen verwenden, um einzuschränken, welche Ressourcen ACK verwalten kann. Dies bietet eine zusätzliche Sicherheitsebene, die über die auf Namespaces basierenden IAM-Rollenselektoren hinausgeht.
**Beispiel: Nach Namespace einschränken**
Erlauben Sie ACK, S3-Buckets nur zu erstellen, wenn die Anfrage aus dem Namespace stammt: `production`
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:CreateBucket",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/eks:kubernetes-namespace": "production"
}
}
}
]
}
```
**Beispiel: Nach Fähigkeit einschränken**
Nur Aktionen von einer bestimmten ACK-Fähigkeit aus zulassen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/eks:eks-capability-arn": "arn:aws:eks:us-west-2:111122223333:capability/my-cluster/ack/my-ack"
}
}
}
]
}
```
**Anmerkung**
Sitzungs-Tags unterscheiden sich von selbstverwaltetem ACK, bei dem diese Tags nicht standardmäßig festgelegt werden. Dies ermöglicht eine detailliertere Zugriffskontrolle mit der verwalteten Funktion.
## Erweiterte IAM-Rollenauswahlmuster
[Eine erweiterte Konfiguration mit Labelselektoren, ressourcenspezifischer Rollenzuweisung und weiteren Beispielen finden Sie in der ACK IRSA-Dokumentation.](https://aws-controllers-k8s.github.io/community/docs/user-docs/irsa/)
## Nächste Schritte
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [ACK-Konzepte](ack-concepts.md)- Erfahren Sie mehr über Richtlinien für die Einführung und Löschung von Ressourcen
+ [Sicherheitsüberlegungen für EKS-Funktionen](capabilities-security.md)- Machen Sie sich mit bewährten Sicherheitsmethoden für Funktionen vertraut
# ACK-Überlegungen für EKS
In diesem Thema werden wichtige Überlegungen zur Nutzung der EKS-Funktion für ACK behandelt, darunter die IAM-Konfiguration, Muster für mehrere Konten und die Integration mit anderen EKS-Funktionen.
## IAM-Konfigurationsmuster
Die ACK-Fähigkeit verwendet eine IAM-Fähigkeitsrolle für die Authentifizierung. AWS Wählen Sie das richtige IAM-Muster, das Ihren Anforderungen entspricht.
### Einfach: Eine einzige Capability-Rolle
Erteilen Sie der Capability-Rolle direkt alle erforderlichen Berechtigungen für Entwicklung, Tests oder einfache Anwendungsfälle.
**Wann sollte Folgendes verwendet werden**:
+ Erste Schritte mit ACK
+ Bereitstellungen mit einem einzigen Konto
+ Alle Ressourcen werden von einem Team verwaltet
+ Entwicklungs- und Testumgebungen
**Beispiel**: Fügen Sie Ihrer Capability Role S3- und RDS-Berechtigungen mit Bedingungen für die Kennzeichnung von Ressourcen hinzu:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:*"],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": ["us-west-2", "us-east-1"]
}
}
},
{
"Effect": "Allow",
"Action": ["rds:*"],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": ["us-west-2", "us-east-1"]
},
}
}
]
}
```
Dieses Beispiel beschränkt die S3- und RDS-Operationen auf bestimmte Regionen und erfordert, dass RDS-Ressourcen über ein `ManagedBy: ACK` Tag verfügen.
### Produktion: IAM-Rollenselektoren
Verwenden Sie in Produktionsumgebungen IAM-Rollenselektoren, um den Zugriff mit den geringsten Rechten und die Isolierung auf Namespace-Ebene zu implementieren.
**Wann** sollte Folgendes verwendet werden:
+ Produktionsumgebungen
+ Cluster mit mehreren Teams
+ Ressourcenverwaltung für mehrere Konten
+ Sicherheitsanforderungen mit den geringsten Rechten
+ Verschiedene Dienste benötigen unterschiedliche Berechtigungen
**Vorteile**:
+ Jeder Namespace erhält nur die Berechtigungen, die er benötigt
+ Teamisolierung — Team A kann die Berechtigungen von Team B nicht verwenden
+ Einfachere Prüfung und Einhaltung von Vorschriften
+ Erforderlich für kontenübergreifendes Ressourcenmanagement
Eine ausführliche Konfiguration des IAM-Rollenauswahlsystems finden Sie unter. [ACK-Berechtigungen konfigurieren](ack-permissions.md)
## Integration mit anderen EKS-Funktionen
### GitOps mit Argo CD
Verwenden Sie die EKS-Funktion für Argo CD, um ACK-Ressourcen aus Git-Repositorys bereitzustellen und GitOps Workflows für das Infrastrukturmanagement zu ermöglichen.
**Überlegungen**:
+ Speichern Sie ACK-Ressourcen zusammen mit Anwendungsmanifesten für end-to-end GitOps
+ Organisieren Sie auf der Grundlage Ihrer Teamstruktur nach Umgebung, Service oder Ressourcentyp
+ Verwenden Sie die automatische Synchronisation von Argo CD für einen kontinuierlichen Abgleich
+ Aktivieren Sie das Bereinigen, um gelöschte Ressourcen automatisch zu entfernen
+ Ziehen Sie hub-and-spoke Muster für das Infrastrukturmanagement mehrerer Cluster in Betracht
GitOps bietet Prüfpfade, Rollback-Funktionen und deklaratives Infrastrukturmanagement. Weitere Informationen zu Argo CD finden Sie unter. [Arbeiten mit Argo CD](working-with-argocd.md)
### Ressourcenzusammensetzung mit Kro
Verwenden Sie die EKS-Funktion für kro (Kube Resource Orchestrator), um mehrere ACK-Ressourcen in abstrakte und benutzerdefinierte Elemente auf höherer Ebene zusammenzustellen. APIs
**Wann sollte Kro** mit ACK verwendet werden:
+ Erstellen Sie wiederverwendbare Muster für gängige Infrastruktur-Stacks (Datenbank \$1 Backup \$1 Überwachung)
+ Erstellen Sie Self-Service-Plattformen mit vereinfachten Funktionen APIs für Anwendungsteams
+ Ressourcenabhängigkeiten verwalten und Werte zwischen Ressourcen übergeben (S3-Bucket-ARN an Lambda-Funktion)
+ Standardisieren Sie die Infrastrukturkonfigurationen teamübergreifend
+ Reduzieren Sie die Komplexität, indem Sie Implementierungsdetails hinter benutzerdefinierten Ressourcen verstecken
**Beispielmuster**:
+ Anwendungsstapel: S3-Bucket \$1 SQS-Warteschlange \$1 Benachrichtigungskonfiguration
+ Datenbank-Setup: RDS-Instanz \$1 Parametergruppe \$1 Sicherheitsgruppe \$1 Geheimnisse
+ Netzwerk: VPC \$1 Subnetze \$1 Routentabellen \$1 Sicherheitsgruppen
kro kümmert sich um die Reihenfolge der Abhängigkeiten, die Statusweiterleitung und das Lebenszyklusmanagement für zusammengesetzte Ressourcen. Weitere Informationen zu Kro finden Sie unter. [Kro-Konzepte](kro-concepts.md)
## Organisieren Sie Ihre Ressourcen
Organisieren Sie ACK-Ressourcen mithilfe von Kubernetes-Namespaces und AWS Ressourcen-Tags für eine bessere Verwaltung, Zugriffskontrolle und Kostenverfolgung.
### Organisation des Namespaces
Verwenden Sie Kubernetes-Namespaces, um ACK-Ressourcen logisch nach Umgebung (Produktion, Staging, Entwicklung), Team (Plattform, Daten, ML) oder Anwendung zu trennen.
**Vorteile:**
+ RBAC mit Namespace-Gültigkeitsbereich für die Zugriffskontrolle
+ Legen Sie mithilfe von Anmerkungen Standardregionen pro Namespace fest
+ Einfachere Ressourcenverwaltung und Bereinigung
+ Logische Trennung im Einklang mit der Organisationsstruktur
### Ressourcen-Markierung
Die EKS-ACK-Funktion wendet automatisch Standardtags auf alle AWS Ressourcen an, die sie erstellt. Diese Tags unterscheiden sich von selbstverwalteten ACK und bieten eine verbesserte Rückverfolgbarkeit.
Von der **Funktion angewendete Standardtags**:
| Tag-Schlüssel | Description |
| --- | --- |
| `eks:controller-version` | Die Version des ACK-Controllers |
| `eks:kubernetes-namespace` | Der Kubernetes-Namespace der ACK-Ressource |
| `eks:kubernetes-resource-name` | Der Name der Kubernetes-Ressource |
| `eks:kubernetes-api-group` | Die Kubernetes-API-Gruppe (zum Beispiel) `s3.services.k8s.aws` |
| `eks:eks-capability-arn` | Der ARN der EKS ACK-Fähigkeit |
**Anmerkung**
Selbstverwaltetes ACK verwendet verschiedene Standardtags: `services.k8s.aws/controller-version` und`services.k8s.aws/namespace`. Die Tags der Funktion verwenden das `eks:` Präfix aus Gründen der Konsistenz mit anderen EKS-Funktionen.
**Zusätzliche empfohlene Tags**:
Fügen Sie benutzerdefinierte Tags für die Kostenzuweisung, die Nachverfolgung der Eigentumsverhältnisse und für organisatorische Zwecke hinzu:
+ Umgebung (Produktion, Bereitstellung, Entwicklung)
+ Eigentümerschaft des Teams oder der Abteilung
+ Kostenstelle für die Fakturierung
+ Name der Anwendung oder des Dienstes
## Migration von anderen Infrastructure-as-code Tools
Viele Unternehmen halten es für sinnvoll, Kubernetes über ihre Workload-Orchestrierung hinaus zu standardisieren. Durch die Migration des Infrastruktur- und AWS Ressourcenmanagements zu ACK können Sie das Infrastrukturmanagement mithilfe von Kubernetes zusammen mit Ihren Anwendungs-Workloads standardisieren. APIs
**Vorteile der Standardisierung** auf Kubernetes für die Infrastruktur:
+ **Zentrale Informationsquelle**: Verwalten Sie sowohl Anwendungen als auch Infrastruktur in Kubernetes und ermöglichen Sie so eine Praxis end-to-end GitOps
+ **Einheitliches Tooling**: Teams nutzen die Ressourcen und Tools von Kubernetes, anstatt mehrere Tools und Frameworks zu erlernen
+ **Konsistenter Abgleich**: ACK gleicht AWS Ressourcen kontinuierlich ab, wie es Kubernetes für Workloads tut, und erkennt und korrigiert Abweichungen im Vergleich zu unverzichtbaren Tools
+ **Systemeigene Kompositionen: Wenn** Kro und ACK zusammen verwendet werden, können AWS Ressourcen direkt in Anwendungs- und Ressourcenmanifesten referenziert werden, wobei Verbindungszeichenfolgen und zwischen Ressourcen weitergegeben werden ARNs
+ **Vereinfachter Betrieb**: Eine Steuerungsebene für Bereitstellungen, Rollbacks und Beobachtbarkeit im gesamten System
ACK unterstützt die Übernahme vorhandener AWS Ressourcen, ohne sie neu zu erstellen, und ermöglicht so eine Migration ohne Ausfallzeiten von CloudFormation Terraform oder Ressourcen außerhalb des Clusters.
**Übernehmen Sie eine bestehende Ressource:**
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: existing-bucket
annotations:
services.k8s.aws/adoption-policy: "adopt-or-create"
spec:
name: my-existing-bucket-name
```
Nach der Übernahme wird die Ressource von ACK verwaltet und kann über Kubernetes-Manifeste aktualisiert werden. Sie können schrittweise migrieren, Ressourcen nach Bedarf übernehmen und gleichzeitig die vorhandenen IaC-Tools für andere Ressourcen beibehalten.
ACK unterstützt auch schreibgeschützte Ressourcen. Bei Ressourcen, die von anderen Teams oder Tools verwaltet werden und die Sie referenzieren, aber nicht ändern möchten, kombinieren Sie die Übernahme mit der `retain` Löschrichtlinie und gewähren Sie nur IAM-Leseberechtigungen. Auf diese Weise können Anwendungen gemeinsam genutzte Infrastrukturen (VPCs, IAM-Rollen, KMS-Schlüssel) über Kubernetes APIs erkennen, ohne Änderungen riskieren zu müssen.
Weitere Informationen zur Nutzung von Ressourcen finden Sie unter. [ACK-Konzepte](ack-concepts.md)
## Richtlinien zum Löschen
Löschrichtlinien steuern, was mit AWS Ressourcen passiert, wenn Sie die entsprechende Kubernetes-Ressource löschen. Wählen Sie die richtige Richtlinie basierend auf dem Ressourcenlebenszyklus und Ihren betrieblichen Anforderungen.
### Löschen (Standard)
Die AWS Ressource wird gelöscht, wenn Sie die Kubernetes-Ressource löschen. Dadurch wird die Konsistenz zwischen Ihrem Cluster aufrechterhalten und sichergestellt AWS, dass sich keine Ressourcen ansammeln.
**Wann sollte Delete verwendet** werden:
+ Entwicklungs- und Testumgebungen, in denen Bereinigung wichtig ist
+ Kurzlebige Ressourcen, die an den Anwendungslebenszyklus gebunden sind (Testdatenbanken, temporäre Buckets)
+ Ressourcen, die die Anwendung nicht überdauern sollten (SQS-Warteschlangen, Cluster) ElastiCache
+ Kostenoptimierung — automatische Bereinigung ungenutzter Ressourcen
+ Umgebungen, die mit verwaltet werden GitOps , in denen das Entfernen von Ressourcen aus Git die Infrastruktur löschen sollte
Die standardmäßige Löschrichtlinie entspricht dem deklarativen Modell von Kubernetes: Was sich im Cluster befindet, entspricht dem, was sich darin befindet. AWS
### Beibehalten
Die AWS Ressource wird beibehalten, wenn Sie die Kubernetes-Ressource löschen. Dies schützt wichtige Daten und ermöglicht es Ressourcen, ihre Kubernetes-Repräsentation zu überleben.
**Wann sollte Retain verwendet werden**:
+ Produktionsdatenbanken mit kritischen Daten, die Clusteränderungen überstehen müssen
+ Langfristige Speicherbereiche mit Compliance- oder Prüfanforderungen
+ Gemeinsam genutzte Ressourcen, die von mehreren Anwendungen oder Teams genutzt werden
+ Ressourcen werden auf verschiedene Verwaltungstools migriert
+ Notfallwiederherstellungsszenarien, in denen Sie die Infrastruktur erhalten möchten
+ Ressourcen mit komplexen Abhängigkeiten, die eine sorgfältige Außerbetriebnahme erfordern
```
apiVersion: rds.services.k8s.aws/v1alpha1
kind: DBInstance
metadata:
name: production-db
annotations:
services.k8s.aws/deletion-policy: "retain"
spec:
dbInstanceIdentifier: prod-db
# ... configuration
```
**Wichtig**
Zurückbehaltene Ressourcen sind weiterhin mit AWS Kosten verbunden und müssen manuell gelöscht werden, AWS wenn sie nicht mehr benötigt werden. Verwenden Sie das Ressourcen-Tagging, um die zurückbehaltenen Ressourcen für die Bereinigung nachzuverfolgen.
Weitere Informationen zu Löschrichtlinien finden Sie unter. [ACK-Konzepte](ack-concepts.md)
## Upstream-Dokumentation
Ausführliche Informationen zur Verwendung von ACK finden Sie unter
+ [ACK-Nutzungshandbuch](https://aws-controllers-k8s.github.io/community/docs/user-docs/usage/) — Ressourcen erstellen und verwalten
+ [ACK-API-Referenz](https://aws-controllers-k8s.github.io/community/reference/) — Vollständige API-Dokumentation für alle Dienste
+ [ACK-Dokumentation](https://aws-controllers-k8s.github.io/community/docs/) — Umfassende Benutzerdokumentation
## Nächste Schritte
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM-Berechtigungen und Muster für mehrere Konten
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [Probleme mit ACK-Funktionen beheben](ack-troubleshooting.md)- Beheben Sie ACK-Probleme
+ [Arbeiten mit Argo CD](working-with-argocd.md)- Stellen Sie ACK-Ressourcen bereit mit GitOps
+ [Kro-Konzepte](kro-concepts.md)- Stellen Sie ACK-Ressourcen zu Abstraktionen auf höherer Ebene zusammen
# Probleme mit ACK-Funktionen beheben
Dieses Thema enthält Anleitungen zur Fehlerbehebung für die EKS-Funktion für ACK, einschließlich Funktionsprüfungen, Überprüfung des Ressourcenstatus und Probleme mit IAM-Berechtigungen.
**Anmerkung**
Die EKS-Funktionen werden vollständig verwaltet und außerhalb Ihres Clusters ausgeführt. Sie haben keinen Zugriff auf Controller-Logs oder Controller-Namespaces. Die Fehlerbehebung konzentriert sich auf den Funktionsstatus, den Ressourcenstatus und die IAM-Konfiguration.
## Die Fähigkeit ist AKTIV, aber es werden keine Ressourcen erstellt
Wenn Ihre ACK-Fähigkeit `ACTIVE` den Status anzeigt, aber keine Ressourcen erstellt werden AWS, überprüfen Sie den Funktionsstatus, den Ressourcenstatus und die IAM-Berechtigungen.
**Überprüfen Sie den Zustand der Fähigkeit**:
Sie können Funktionszustands- und Statusprobleme in der EKS-Konsole oder über die AWS CLI anzeigen.
**Konsole**:
1. Öffnen Sie die Amazon EKS-Konsole unter https://console.aws.amazon.com/eks/ home\$1/clusters.
1. Wählen Sie Ihren Clusternamen aus.
1. Wählen Sie den Registerkarte **Beobachtbarkeit**.
1. Wählen Sie **Cluster überwachen** aus.
1. Wählen Sie die Registerkarte **Funktionen**, um den Zustand und den Status aller Funktionen anzuzeigen.
** AWS CLI**:
```
# View capability status and health
aws eks describe-capability \
--region region-code \
--cluster-name my-cluster \
--capability-name my-ack
# Look for issues in the health section
```
**Häufige Ursachen:**
+ **IAM-Berechtigungen fehlen**: Der Capability-Rolle fehlen die Berechtigungen für den Dienst AWS
+ **Falscher Namespace**: Ressourcen, die im Namespace ohne den richtigen Selektor erstellt wurden IAMRole
+ **Ungültige Ressourcenspezifikation**: Überprüfen Sie die Bedingungen für den Ressourcenstatus auf Validierungsfehler
+ **API-Drosselung**: AWS API-Ratenlimits wurden erreicht
+ **Zulassungs-Webhooks: Zulassungs-Webhooks**, die den Controller daran hindern, den Ressourcenstatus zu patchen
**Überprüfen Sie den Ressourcenstatus**:
```
# Describe the resource to see conditions and events
kubectl describe bucket my-bucket -n default
# Look for status conditions
kubectl get bucket my-bucket -n default -o jsonpath='{.status.conditions}'
# View resource events
kubectl get events --field-selector involvedObject.name=my-bucket -n default
```
**Überprüfen Sie die IAM-Berechtigungen**:
```
# View the Capability Role's policies
aws iam list-attached-role-policies --role-name my-ack-capability-role
aws iam list-role-policies --role-name my-ack-capability-role
# Get specific policy details
aws iam get-role-policy --role-name my-ack-capability-role --policy-name policy-name
```
## Ressourcen, die in Kubernetes erstellt wurden AWS , aber nicht in Kubernetes angezeigt werden
ACK verfolgt nur Ressourcen, die es über Kubernetes-Manifeste erstellt. Verwenden Sie die Adoption-Funktion, um vorhandene AWS Ressourcen mit ACK zu verwalten.
```
apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
name: existing-bucket
annotations:
services.k8s.aws/adoption-policy: "adopt-or-create"
spec:
name: my-existing-bucket-name
```
Weitere Informationen zur Nutzung von Ressourcen finden Sie unter[ACK-Konzepte](ack-concepts.md).
## Kontoübergreifende Ressourcen werden nicht erstellt
Wenn bei der Verwendung von IAM-Rollenselektoren keine Ressourcen in einem AWS Zielkonto erstellt werden, überprüfen Sie die Vertrauensstellung und IAMRole die Auswahlkonfiguration.
**Überprüfen Sie die Vertrauensbeziehung**:
```
# Check the trust policy in the target account role
aws iam get-role --role-name cross-account-ack-role --query 'Role.AssumeRolePolicyDocument'
```
Die Vertrauensrichtlinie muss es der Capability Role des Quellkontos ermöglichen, diese Rolle zu übernehmen.
**Bestätigen Sie die IAMRole Selector-Konfiguration**:
```
# List IAMRoleSelectors (cluster-scoped)
kubectl get iamroleselector
# Describe specific selector
kubectl describe iamroleselector my-selector
```
**Überprüfen Sie die Namespace-Ausrichtung:**
IAMRoleSelektoren sind Ressourcen im Clusterbereich, die jedoch auf bestimmte Namespaces abzielen. Stellen Sie sicher, dass sich Ihre ACK-Ressourcen in einem Namespace befinden, der dem Namespace-Selektor des Selectors entspricht: IAMRole
```
# Check resource namespace
kubectl get bucket my-cross-account-bucket -n production
# List all IAMRoleSelectors (cluster-scoped)
kubectl get iamroleselector
# Check which namespace the selector targets
kubectl get iamroleselector my-selector -o jsonpath='{.spec.namespaceSelector}'
```
**Ausgewählte Bedingung überprüfen: IAMRole**
Stellen Sie sicher, dass der IAMRole Selector erfolgreich Ihrer Ressource zugeordnet wurde, indem Sie die folgende `ACK.IAMRoleSelected` Bedingung überprüfen:
```
# Check if IAMRoleSelector was matched
kubectl get bucket my-cross-account-bucket -n production -o jsonpath='{.status.conditions[?(@.type=="ACK.IAMRoleSelected")]}'
```
Wenn die Bedingung zutrifft `False` oder fehlt, stimmt der IAMRole Namespace-Selektor des Selectors nicht mit dem Namespace der Ressource überein. Stellen Sie sicher, dass die des Selektors mit den `namespaceSelector` Namespace-Labels Ihrer Ressource übereinstimmen.
**Überprüfen Sie die Berechtigungen für Capability Role**:
Die Anforderungen `sts:AssumeRole` und `sts:TagSession` Berechtigungen der Capability Role für die Rolle des Zielkontos:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["sts:AssumeRole", "sts:TagSession"],
"Resource": "arn:aws:iam::[.replaceable]`444455556666`:role/[.replaceable]`cross-account-ack-role`"
}
]
}
```
Eine ausführliche kontenübergreifende Konfiguration finden Sie unter[ACK-Berechtigungen konfigurieren](ack-permissions.md).
## Nächste Schritte
+ [ACK-Überlegungen für EKS](ack-considerations.md)— Überlegungen zu ACK und bewährte Methoden
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)— Konfigurieren Sie IAM-Berechtigungen und Muster für mehrere Konten
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [Problembehebung bei EKS-Funktionen](capabilities-troubleshooting.md)- Allgemeine Hinweise zur Problembehebung
# Vergleich der EKS-Funktionen für ACK mit selbstverwaltetem ACK
Die EKS-Funktion für ACK bietet dieselbe Funktionalität wie selbstverwaltete ACK-Controller, bietet jedoch erhebliche betriebliche Vorteile. Einen allgemeinen Vergleich zwischen EKS-Funktionen und selbstverwalteten Lösungen finden Sie unter. [Überlegungen zu den EKS-Fähigkeiten](capabilities-considerations.md) Dieses Thema konzentriert sich auf ACK-spezifische Unterschiede.
## Unterschiede zu Upstream-ACK
Die EKS-Funktion für ACK basiert auf vorgelagerten ACK-Controllern, unterscheidet sich jedoch in der IAM-Integration.
**IAM-Fähigkeitsrolle**: Die Funktion verwendet eine dedizierte IAM-Rolle mit einer Vertrauensrichtlinie, die den `capabilities.eks.amazonaws.com` Dienstprinzipal und nicht IRSA (IAM-Rollen für Dienstkonten) zulässt. Sie können IAM-Richtlinien direkt an die Capability Role anhängen, ohne Kubernetes-Dienstkonten erstellen oder mit Anmerkungen versehen oder OIDC-Anbieter konfigurieren zu müssen. Eine bewährte Methode für Anwendungsfälle in der Produktion ist die Konfiguration von Serviceberechtigungen mithilfe von. `IAMRoleSelector` Weitere Details finden Sie unter [ACK-Berechtigungen konfigurieren](ack-permissions.md).
**Sitzungs-Tags**: Die verwaltete Funktion legt automatisch Sitzungs-Tags für alle AWS API-Anfragen fest und ermöglicht so eine differenzierte Zugriffskontrolle und Prüfung. Zu den Tags gehören `eks:eks-capability-arn``eks:kubernetes-namespace`, und. `eks:kubernetes-api-group` Dies unterscheidet sich von selbstverwaltetem ACK, bei dem diese Tags nicht standardmäßig festgelegt werden. Einzelheiten [ACK-Berechtigungen konfigurieren](ack-permissions.md) zur Verwendung von Sitzungs-Tags in IAM-Richtlinien finden Sie unter.
**Ressourcen-Tags**: Diese Funktion wendet andere Standardtags auf AWS Ressourcen an als selbstverwaltetes ACK. Die Funktion verwendet Tags mit `eks:` Präfixen (z. B.`eks:kubernetes-namespace`,`eks:eks-capability-arn`) anstelle der Tags, die von selbstverwaltetem `services.k8s.aws/` ACK verwendet werden. Die [ACK-Überlegungen für EKS](ack-considerations.md) vollständige Liste der Standard-Ressourcen-Tags finden Sie unter.
**Ressourcenkompatibilität**: Benutzerdefinierte ACK-Ressourcen funktionieren genauso wie Upstream-ACK, ohne dass Ihre ACK-Ressourcen-YAML-Dateien geändert werden. Die Funktion verwendet dasselbe Kubernetes APIs und CRDs daher `kubectl` funktionieren Tools wie auf die gleiche Weise. Alle GA-Controller und Ressourcen aus dem Upstream-ACK werden unterstützt.
Die vollständige ACK-Dokumentation und dienstspezifische Anleitungen finden Sie in der [ACK-Dokumentation](https://aws-controllers-k8s.github.io/community/).
## Migrationspfad
Sie können ohne Ausfallzeiten vom selbstverwalteten ACK zur verwalteten Funktion migrieren:
1. Aktualisieren Sie Ihren selbstverwalteten ACK-Controller so, dass er ihn `kube-system` für Leasingverträge zur Wahl von Führungskräften verwenden kann, zum Beispiel:
```
helm upgrade --install ack-s3-controller \
oci://public.ecr.aws/aws-controllers-k8s/s3-chart \
--namespace ack-system \
--set leaderElection.namespace=kube-system
```
Dadurch wird der Leasingvertrag des Controllers auf diesen `kube-system` übertragen, sodass sich die verwaltete Kapazität darauf abstimmen kann.
1. Erstellen Sie die ACK-Fähigkeit auf Ihrem Cluster (siehe[Erstellen Sie eine ACK-Fähigkeit](create-ack-capability.md))
1. Die verwaltete Funktion erkennt vorhandene, von ACK verwaltete AWS Ressourcen und übernimmt den Abgleich
1. Skalieren Sie selbstverwaltete Controller-Bereitstellungen schrittweise oder entfernen Sie sie:
```
helm uninstall ack-s3-controller --namespace ack-system
```
Dieser Ansatz ermöglicht eine sichere Koexistenz beider Controller während der Migration. Die verwaltete Funktion übernimmt automatisch Ressourcen, die zuvor von selbstverwalteten Controllern verwaltet wurden, und gewährleistet so einen kontinuierlichen Abgleich ohne Konflikte.
## Nächste Schritte
+ [Erstellen Sie eine ACK-Fähigkeit](create-ack-capability.md)- Erstellen Sie eine ACK-Fähigkeitsressource
+ [ACK-Konzepte](ack-concepts.md)- Verstehen Sie die ACK-Konzepte und den Ressourcenlebenszyklus
+ [ACK-Berechtigungen konfigurieren](ack-permissions.md)- Konfigurieren Sie IAM und Berechtigungen
# 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::, , ,