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