**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.
# IAM-Benutzern mit EKS-Zugriffseinträgen Zugriff auf Kubernetes gewähren
Dieser Abschnitt zeigt Ihnen, wie Sie den IAM-Prinzipalzugriff auf Kubernetes-Cluster in Amazon Elastic Kubernetes Service (EKS) mithilfe von Zugriffseinträgen und Richtlinien verwalten. Sie finden detaillierte Informationen zum Ändern von Authentifizierungsmodi, zur Migration von veralteten `aws-auth`-ConfigMap-Einträgen, zum Erstellen, Aktualisieren und Löschen von Zugriffseinträgen, zum Verknüpfen von Richtlinien mit Einträgen, zum Überprüfen vordefinierter Richtlinienberechtigungen sowie zu wichtigen Voraussetzungen und Überlegungen für eine sichere Zugriffsverwaltung.
## Übersicht
EKS-Zugriffseinträge sind die optimale Methode, um Benutzern Zugriff auf die Kubernetes-API zu gewähren. Beispielsweise können Sie Zugriffseinträge verwenden, um Entwicklern Zugriff auf die Verwendung von kubectl zu gewähren. Grundsätzlich ordnet ein EKS-Zugriffseintrag eine Reihe von Kubernetes-Berechtigungen einer IAM-Identität zu, beispielsweise einer IAM-Rolle. Ein Entwickler kann beispielsweise eine IAM-Rolle übernehmen und diese zur Authentifizierung bei einem EKS-Cluster verwenden.
## Feature
+ **Zentralisierte Authentifizierung und Autorisierung**: Steuert den Zugriff auf Kubernetes-Cluster direkt über Amazon-EKS-APIs, sodass für Benutzerberechtigungen kein Wechsel zwischen AWS- und Kubernetes-APIs erforderlich ist.
+ **Differenzierte Berechtigungsverwaltung**: Verwendet Zugriffseinträge und Richtlinien, um differenzierte Berechtigungen für AWS-IAM-Prinzipale zu definieren, einschließlich der Änderung oder Aufhebung des Cluster-Admin-Zugriffs durch den Ersteller.
+ **IaC-Tool-Integration**: Unterstützt Infrastructure-as-Code-Tools wie AWS CloudFormation, Terraform und AWS CDK, um Zugriffskonfigurationen während der Cluster-Erstellung zu definieren.
+ **Wiederherstellung nach Fehlkonfiguration**: Ermöglicht die Wiederherstellung des Cluster-Zugriffs über die Amazon-EKS-API ohne direkten Zugriff auf die Kubernetes-API.
+ **Reduzierte Gemeinkosten und verbesserte Sicherheit**: Zentralisiert den Betrieb, um die Gemeinkosten zu senken, und nutzt gleichzeitig AWS-IAM-Features wie CloudTrail-Auditprotokollierung und Multi-Faktor-Authentifizierung.
## So fügen Sie Berechtigungen hinzu
Sie können Kubernetes-Berechtigungen für den Zugriff auf Einträge auf zwei Arten anfügen:
+ Verwenden Sie eine Zugriffsrichtlinie. Zugriffsrichtlinien sind vordefinierte Kubernetes-Berechtigungsvorlagen, die von AWS verwaltet werden. Weitere Informationen finden Sie unter [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md).
+ Verweisen Sie auf eine Kubernetes-Gruppe. Wenn Sie eine IAM-Identität einer Kubernetes-Gruppe zuordnen, können Sie Kubernetes-Ressourcen erstellen, die der Gruppe Berechtigungen gewähren. Weitere Informationen finden Sie unter [Using RBAC Authorization](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.
## Überlegungen
Beachten Sie bei der Aktivierung von EKS-Zugriffseinträgen in vorhandenen Clustern Folgendes:
+ **Verhalten älterer Cluster**: Bei Clustern, die vor der Einführung von Zugriffseinträgen erstellt wurden (d. h. Clustern mit einer Plattformversion, die älter ist als in den [Anforderungen an die Plattformversion angegeben](https://docs.aws.amazon.com/eks/latest/userguide/platform-versions.html)), erstellt EKS automatisch einen Zugriffseintrag, der die bereits vorhandenen Berechtigungen widerspiegelt. Dieser Eintrag enthält die IAM-Identität, mit welcher der Cluster ursprünglich erstellt wurde, sowie die Verwaltungsberechtigungen, die dieser Identität bei der Cluster-Erstellung gewährt wurden.
+ **Umgang mit der veralteten `aws-auth`-ConfigMap**: Wenn Ihr Cluster für die Zugriffsverwaltung auf die veraltete `aws-auth`-ConfigMap angewiesen ist, wird bei der Aktivierung von Zugriffseinträgen automatisch nur der Zugriffseintrag für den ursprünglichen Cluster-Ersteller erstellt. Zusätzliche Rollen oder Berechtigungen, die der ConfigMap hinzugefügt werden (z. B. benutzerdefinierte IAM-Rollen für Entwickler oder Services), werden nicht automatisch migriert. Um dies zu beheben, erstellen Sie manuell die entsprechenden Zugriffseinträge.
## Erste Schritte
1. Legen Sie die IAM-Identitäts- und Zugriffsrichtlinie fest, die Sie verwenden möchten.
+ [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md)
1. Aktivieren Sie EKS-Zugriffseinträge in Ihrem Cluster. Bestätigen Sie, dass Sie über eine unterstützte Plattformversion verfügen.
+ [Ändern des Authentifizierungsmodus, um Zugriffseinträge zu verwenden](setting-up-access-entries.md)
1. Erstellen Sie einen Zugriffseintrag, der eine IAM-Identität einer Kubernetes-Berechtigung zuordnet.
+ [Zugriffseinträge erstellen](creating-access-entries.md)
1. Authentifizieren Sie sich beim Cluster mit der IAM-Identität.
+ [AWS-CLI einrichten](install-awscli.md)
+ [`kubectl` und `eksctl` einrichten](install-kubectl.md)
# Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen
Sie können *Zugriffseinträgen* vom *Typ* `STANDARD` eine oder mehrere Zugriffsrichtlinien zuweisen. Amazon EKS erteilt den anderen Arten von Zugriffseinträgen automatisch die erforderlichen Berechtigungen, damit sie in Ihrem Cluster ordnungsgemäß funktionieren. Die Amazon-EKS-Zugriffsrichtlinien beinhalten Kubernetes-Berechtigungen, keine IAM-Berechtigungen. Machen Sie sich mit den Kubernetes-Berechtigungen vertraut, die in den einzelnen Zugriffsrichtlinien-Optionen enthalten sind, bevor Sie einem Zugriffseintrag eine Zugriffsrichtlinie zuweisen. Weitere Informationen finden Sie unter [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md). Wenn keine der Zugriffsrichtlinien Ihre Anforderungen erfüllt, ordnen Sie einem Zugriffseintrag keine Zugriffsrichtlinie zu. Geben Sie stattdessen mindestens einen *Gruppennamen* für den Zugriffseintrag an und erstellen und verwalten Sie Kubernetes-Objekte für die rollenbasierte Zugriffskontrolle. Weitere Informationen finden Sie unter [Zugriffseinträge erstellen](creating-access-entries.md).
+ Ein vorhandener Zugriffseintrag. Informationen zum Erstellen finden Sie unter [Zugriffseinträge erstellen](creating-access-entries.md).
+ Eine Rolle oder ein entsprechender Benutzer für AWS Identity and Access Management mit folgenden Berechtigungen: `ListAccessEntries`, `DescribeAccessEntry`, `UpdateAccessEntry`, `ListAccessPolicies`, `AssociateAccessPolicy` und `DisassociateAccessPolicy`. Weitere Informationen finden Sie unter [Von Amazon Elastic Kubernetes Service definierte Aktionen](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions) in der *Service-Autorisierungsreferenz*.
Berücksichtigen Sie die folgenden Anforderungen, bevor Sie Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen:
+ Sie können jedem Zugriffseintrag mehrere Zugriffsrichtlinien zuordnen, aber Sie können jede Richtlinie nur einmal einem Zugriffseintrag zuordnen. Wenn Sie mehrere Zugriffsrichtlinien zuordnen, verfügt der IAM-Prinzipal des Zugriffseintrags über alle Berechtigungen aus allen zugeordneten Zugriffsrichtlinien.
+ Sie können eine Zugriffsrichtlinie auf alle Ressourcen in einem Cluster ausrichten oder den Namen eines oder mehrerer Kubernetes-Namespaces angeben. Sie können Platzhalterzeichen für einen Namespace-Namen verwenden. Wenn Sie beispielsweise eine Zugriffsrichtlinie auf alle Namespaces ausrichten möchten, die mit `dev-` beginnen, können Sie `dev-*` als Namespace-Namen angeben. Stellen Sie sicher, dass die Namespaces in Ihrem Cluster vorhanden sind und dass Ihre Schreibweise dem tatsächlichen Namespace-Namen im Cluster entspricht. Amazon EKS überprüft weder die Schreibweise noch das Vorhandensein der Namespaces in Ihrem Cluster.
+ Der *Zugriffsbereich* für eine Zugriffsrichtlinie kann geändert werden, nachdem sie einem Zugriffseintrag zugeordnet wurde. Wenn Sie die Zugriffsrichtlinie auf Kubernetes-Namespaces beschränkt haben, können Sie bei Bedarf Namespaces für die Zuordnung hinzufügen und entfernen.
+ Wenn Sie eine Zugriffsrichtlinie einem Zugriffseintrag zuordnen, für den auch *Gruppennamen* angegeben sind, verfügt der IAM-Prinzipal über alle Berechtigungen in allen zugehörigen Zugriffsrichtlinien. Außerdem verfügt er über alle Berechtigungen aus jedem `Role`-Objekt vom Typ `ClusterRole` oder `Role`, das in einem beliebigen Kubernetes-Objekt vom Typ oder `RoleBinding` zum Angeben der Gruppennamen angegeben ist.
+ Wenn Sie den Befehl `kubectl auth can-i --list` ausführen, werden keine Kubernetes-Berechtigungen angezeigt, die durch Zugriffsrichtlinien zugewiesen wurden, die einem Zugriffseintrag für den IAM-Prinzipal zugeordnet sind, den Sie beim Ausführen des Befehls verwenden. Der Befehl zeigt nur Kubernetes-Berechtigungen an, wenn Sie sie in Kubernetes-Objekten vom Typ `Role` oder `ClusterRole` gewährt haben, die Sie an die Gruppennamen oder an den Benutzernamen gebunden haben, die bzw. den Sie für einen Zugriffseintrag angegeben haben.
+ Wenn Sie bei der Interaktion mit Kubernetes-Objekten in Ihrem Cluster die Identität eines Kubernetes-Benutzers oder einer Kubernetes-Gruppe annehmen, beispielsweise indem Sie den Befehl `kubectl` mit `--as username ` oder `--as-group group-name ` verwenden, erzwingen Sie die Verwendung der Kubernetes RBAC-Autorisierung. Daher werden dem IAM-Prinzipal keine Berechtigungen durch eine Zugriffsrichtlinie zugewiesen, die dem Zugriffseintrag zugeordnet ist. Die einzigen Kubernetes-Berechtigungen, über die der Benutzer oder die Gruppe verfügt, dessen bzw. deren Identität der IAM-Prinzipal angenommen hat, sind die Kubernetes-Berechtigungen, die Sie in Kubernetes-Objekten vom Typ `Role` oder `ClusterRole` gewährt haben, die von Ihnen an die Gruppennamen oder an den Benutzernamen gebunden wurden. Damit Ihr IAM-Prinzipal über die Berechtigungen in den zugehörigen Zugriffsrichtlinien verfügt, dürfen Sie sich nicht als Kubernetes-Benutzer oder -Gruppe ausgeben. Der IAM-Prinzipal verfügt auch weiterhin über alle Berechtigungen, die Sie ihm in den Kubernetes-Objekten vom Typ `Role` oder `ClusterRole` gewährt haben, die Sie an die Gruppennamen oder an den Benutzernamen gebunden haben, die bzw. den Sie für den Zugriffseintrag angegeben haben. Weitere Informationen finden Sie unter [Benutzeridentitätswechsel](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#user-impersonation) in der Kubernetes-Dokumentation.
Sie können die AWS-Managementkonsole oder die AWS CLI verwenden, um eine Zugriffsrichtlinie einem Zugriffseintrag zuzuordnen.
## AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie den Namen des Clusters aus, der über einen Zugriffseintrag verfügt, dem Sie eine Zugriffsrichtlinien zuordnen möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Wenn es sich um einen Zugriffseintrag vom Typ **Standard** handelt, können Sie **Zugriffsrichtlinien** von Amazon EKS zuordnen oder deren Zuordnung aufheben. Bei Zugriffseinträgen eines anderen Typs (also nicht **Standard**) steht diese Option nicht zur Verfügung.
1. Wählen Sie **Zugriffsrichtlinie zuordnen** aus.
1. Wählen Sie unter **Richtlinienname** die Richtlinie mit den Berechtigungen aus, über die der IAM-Prinzipal verfügen soll. Informationen zu den Berechtigungen, die in der jeweiligen Richtlinie enthalten sind, finden Sie unter [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md).
1. Wählen Sie unter **Zugriffsbereich** einen Zugriffsbereich aus. Bei Verwendung der Option **Cluster** werden die Berechtigungen in der Zugriffsrichtlinie dem IAM-Prinzipal für Ressourcen in allen Kubernetes-Namespaces gewährt. Bei Verwendung der Option **Kubernetes-Namespace** können Sie anschließend **Neuen Namespace hinzufügen** auswählen. In dem daraufhin angezeigten Feld **Namespace** können Sie den Namen eines Kubernetes-Namespace in Ihrem Cluster eingeben. Wenn die Berechtigungen für den IAM-Prinzipal in mehreren Namespaces gelten sollen, können Sie mehrere Namespaces eingeben.
1. Wählen Sie **Zugriffsrichtlinie hinzufügen** aus.
## AWS-CLI
1. Version `2.12.3` oder höher oder die Version `1.27.160` oder höher der AWS-Befehlszeilenschnittstelle (AWS-CLI), die auf Ihrem Gerät oder in AWS CloudShell installiert und konfiguriert sein muss. Um Ihre aktuelle Version zu überprüfen, verwenden Sie `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Paket-Manager wie `yum`, `apt-get` oder Homebrew für macOS sind oft mehrere Versionen hinter der neuesten Version der AWS CLI. Um die neueste Version zu installieren, lesen Sie [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) und [Schnellkonfiguration mit aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle*. Die in AWS CloudShell installierte AWS-CLI-Version kann auch mehrere Versionen hinter der neuesten Version liegen. Informationen zum Aktualisieren finden Sie unter [Installieren der AWS CLI in Ihrem Stammverzeichnis](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) im * AWS-CloudShell-Benutzerhandbuch*.
1. Sehen Sie sich die verfügbaren Zugriffsrichtlinien an.
```
aws eks list-access-policies --output table
```
Eine Beispielausgabe sieht wie folgt aus.
```
---------------------------------------------------------------------------------------------------------
| ListAccessPolicies |
+-------------------------------------------------------------------------------------------------------+
|| accessPolicies ||
|+---------------------------------------------------------------------+-------------------------------+|
|| arn | name ||
|+---------------------------------------------------------------------+-------------------------------+|
|| {arn-aws}eks::aws:cluster-access-policy/AmazonEKSAdminPolicy | AmazonEKSAdminPolicy ||
|| {arn-aws}eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy | AmazonEKSClusterAdminPolicy ||
|| {arn-aws}eks::aws:cluster-access-policy/AmazonEKSEditPolicy | AmazonEKSEditPolicy ||
|| {arn-aws}eks::aws:cluster-access-policy/AmazonEKSViewPolicy | AmazonEKSViewPolicy ||
|+---------------------------------------------------------------------+-------------------------------+|
```
Informationen zu den Berechtigungen, die in der jeweiligen Richtlinie enthalten sind, finden Sie unter [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md).
1. Sehen Sie sich Ihre vorhandenen Zugriffseinträge an. Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters.
```
aws eks list-access-entries --cluster-name my-cluster
```
Eine Beispielausgabe sieht wie folgt aus.
```
{
"accessEntries": [
"arn:aws:iam::111122223333:role/my-role",
"arn:aws:iam::111122223333:user/my-user"
]
}
```
1. Ordnen Sie eine Zugriffsrichtlinie einem Zugriffseintrag zu. Im folgenden Beispiel wird die Zugriffsrichtlinie `AmazonEKSViewPolicy` einem Zugriffseintrag zugeordnet. Wenn die IAM-Rolle *my-role* versucht, auf Kubernetes-Objekte im Cluster zuzugreifen, autorisiert Amazon EKS die Rolle nur dazu, die Berechtigungen in der Richtlinie für den Zugriff auf Kubernetes-Objekte in den Kubernetes-Namespaces *my-namespace1* und *my-namespace2* zu verwenden. Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters, *111122223333* durch Ihre AWS-Konto-ID und *my-role* durch den Namen der IAM-Rolle, für die Amazon EKS den Zugriff auf Kubernetes-Cluster-Objekte autorisieren soll.
```
aws eks associate-access-policy --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/my-role \
--access-scope type=namespace,namespaces=my-namespace1,my-namespace2 --policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSViewPolicy
```
Wenn die Berechtigungen für den IAM-Prinzipal clusterweit gelten sollen, ersetzen Sie `type=namespace,namespaces=my-namespace1,my-namespace2 ` durch `type=cluster`. Wenn Sie dem Zugriffseintrag mehrere Zugriffsrichtlinien zuordnen möchten, führen Sie den Befehl mehrmals aus und verwenden Sie dabei jeweils eine individuelle Zugriffsrichtlinie. Jede zugeordnete Zugriffsrichtlinie hat ihren eigenen Geltungsbereich.
**Anmerkung**
Wenn Sie später den Geltungsbereich einer zugehörigen Zugriffsrichtlinie ändern möchten, können Sie den vorherigen Befehl erneut ausführen und dabei den neuen Bereich angeben. Wenn Sie also beispielsweise *my-namespace2* entfernen möchten, führen Sie den Befehl erneut aus und verwenden Sie dabei nur `type=namespace,namespaces=my-namespace1 `. Wenn Sie den Bereich von `namespace` in `cluster` ändern möchten, führen Sie den Befehl erneut aus und verwenden Sie dabei `type=cluster`, um `type=namespace,namespaces=my-namespace1,my-namespace2 ` zu entfernen.
1. Ermitteln Sie, welche Zugriffsrichtlinien einem Zugriffseintrag zugeordnet sind.
```
aws eks list-associated-access-policies --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/my-role
```
Eine Beispielausgabe sieht wie folgt aus.
```
{
"clusterName": "my-cluster",
"principalArn": "arn:aws:iam::111122223333",
"associatedAccessPolicies": [
{
"policyArn": "arn:aws:eks::aws:cluster-access-policy/AmazonEKSViewPolicy",
"accessScope": {
"type": "cluster",
"namespaces": []
},
"associatedAt": "2023-04-17T15:25:21.675000-04:00",
"modifiedAt": "2023-04-17T15:25:21.675000-04:00"
},
{
"policyArn": "arn:aws:eks::aws:cluster-access-policy/AmazonEKSAdminPolicy",
"accessScope": {
"type": "namespace",
"namespaces": [
"my-namespace1",
"my-namespace2"
]
},
"associatedAt": "2023-04-17T15:02:06.511000-04:00",
"modifiedAt": "2023-04-17T15:02:06.511000-04:00"
}
]
}
```
Im vorherigen Beispiel verfügt der IAM-Prinzipal für diesen Zugriffseintrag über Leseberechtigungen für alle Namespaces im Cluster und über Administratorberechtigungen für zwei Kubernetes-Namespaces.
1. Heben Sie die Zuordnung zwischen einer Zugriffsrichtlinie und einem Zugriffseintrag auf. In diesem Beispiel wird die Zuordnung zwischen der Richtlinie `AmazonEKSAdminPolicy` und einem Zugriffseintrag aufgehoben. Die in der Zugriffsrichtlinie `AmazonEKSViewPolicy` enthaltenen Berechtigungen für Objekte in den Namespaces *my-namespace1* und *my-namespace2* bleiben für den IAM-Prinzipal allerdings erhalten, da die Zuordnung zwischen dieser Zugriffsrichtlinie und dem Zugriffseintrag nicht aufgehoben wird.
```
aws eks disassociate-access-policy --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/my-role \
--policy-arn arn:aws:eks::aws:cluster-access-policy/AmazonEKSAdminPolicy
```
Eine Liste der verfügbaren Zugriffsrichtlinien finden Sie unter [Berechtigungen von Zugriffsrichtlinien überprüfen](access-policy-permissions.md).
# Migrieren vorhandener `aws-auth ConfigMap`-Einträge zu Zugriffseinträgen
Wenn Sie Einträge zu `aws-auth` `ConfigMap` für Ihren Cluster hinzugefügt haben, empfiehlt es sich, Zugriffseinträge für die vorhandenen Einträge in `aws-auth` `ConfigMap` zu erstellen. Nach der Erstellung der Zugriffseinträge können Sie die Einträge aus `ConfigMap` entfernen. Einträgen in `aws-auth` `ConfigMap` können keine [Zugriffsrichtlinien](access-policies.md) zugeordnet werden. Wenn Sie Ihren IAM-Prinzipalen Zugriffsrichtlinien zuordnen möchten, müssen Sie Zugriffseinträge erstellen.
**Wichtig**
Wenn sich ein Cluster im `API_AND_CONFIGMAP`-Authentifizierungsmodus befindet und sowohl in den `aws-auth` `ConfigMap`- als auch in den Zugriffseinträgen eine Zuordnung für dieselbe IAM-Rolle vorhanden ist, verwendet die Rolle die Zuordnung des Zugriffseintrags zur Authentifizierung. Zugriffseinträge haben Vorrang vor `ConfigMap`-Einträgen für denselben IAM-Prinzipal.
Bevor Sie vorhandene `aws-auth` `ConfigMap`-Einträge entfernen, die von Amazon EKS für eine [verwaltete Knotengruppe](managed-node-groups.md) oder ein [Fargate-Profil](fargate-profile.md) in Ihrem Cluster erstellt wurden, überprüfen Sie, ob die richtigen Zugriffseinträge für diese spezifischen Ressourcen in Ihrem Amazon-EKS-Cluster vorhanden sind. Wenn Sie Einträge entfernen, die Amazon EKS in `ConfigMap` erstellt hat, ohne die entsprechenden Zugriffseinträge zu haben, funktioniert Ihr Cluster nicht ordnungsgemäß.
## Voraussetzungen
+ Vertrautheit mit Zugriffseinträgen und Zugriffsrichtlinien. Weitere Informationen erhalten Sie unter [IAM-Benutzern mit EKS-Zugriffseinträgen Zugriff auf Kubernetes gewähren](access-entries.md) und [Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen](access-policies.md).
+ Ein vorhandener Cluster mit einer Plattformversion, die den in den Voraussetzungen des [IAM-Benutzern mit EKS-Zugriffseinträgen Zugriff auf Kubernetes gewähren](access-entries.md)-Themas aufgeführten Versionen entspricht oder höher ist.
+ Version `0.215.0` oder höher des `eksctl`-Befehlszeilen-Tools, das auf Ihrem Computer oder in der AWS CloudShell installiert ist. Informationen zum Installieren und Aktualisieren von `eksctl` finden Sie in der Dokumentation zu `eksctl` unter [Installation](https://eksctl.io/installation).
+ Kubernetes-Berechtigungen zum Ändern von `aws-auth` `ConfigMap` im `kube-system`-Namespace.
+ Eine AWS Identity and Access Management Zugriffsverwaltungsrolle oder ein Benutzer mit den folgenden Berechtigungen: `CreateAccessEntry` und`ListAccessEntries`. Weitere Informationen finden Sie in der Service-Authorization-Referenz unter [Von Amazon Elastic Kubernetes Service definierte Aktionen](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions).
## `eksctl`
1. Sehen Sie sich die vorhandenen Einträge in `aws-auth ConfigMap` an. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters.
```
eksctl get iamidentitymapping --cluster my-cluster
```
Eine Beispielausgabe sieht wie folgt aus.
```
ARN USERNAME GROUPS ACCOUNT
arn:aws: iam::111122223333:role/EKS-my-cluster-Admins Admins system:masters
arn:aws: iam::111122223333:role/EKS-my-cluster-my-namespace-Viewers my-namespace-Viewers Viewers
arn:aws: iam::111122223333:role/EKS-my-cluster-self-managed-ng-1 system:node:{{EC2PrivateDNSName}} system:bootstrappers,system:nodes
arn:aws: iam::111122223333:user/my-user my-user
arn:aws: iam::111122223333:role/EKS-my-cluster-fargateprofile1 system:node:{{SessionName}} system:bootstrappers,system:nodes,system:node-proxier
arn:aws: iam::111122223333:role/EKS-my-cluster-managed-ng system:node:{{EC2PrivateDNSName}} system:bootstrappers,system:nodes
```
1. [Zugriffseinträge erstellen](creating-access-entries.md) für alle von Ihnen erstellten `ConfigMap`-Einträge aus der vorherigen Ausgabe. Achten Sie beim Erstellen der Zugriffseinträge darauf, für `ARN`, `USERNAME`, `GROUPS` und `ACCOUNT` die gleichen Werte anzugeben, die in der Ausgabe zurückgegeben wurden. Im Falle der Beispielausgabe würden Sie Zugriffseinträge für alle Einträge außer den letzten beiden Einträgen erstellen, da diese von Amazon EKS für ein Fargate-Profil bzw. für eine verwaltete Knotengruppe erstellt wurden.
1. Löschen Sie die Einträge aus `ConfigMap` für alle von Ihnen erstellten Zugriffseinträge. Wenn Sie den Eintrag nicht aus `ConfigMap` löschen, wird der `ConfigMap`-Eintrag durch die Einstellungen für den Zugriffseintrag für den IAM-Prinzipal-ARN außer Kraft gesetzt. *111122223333*Ersetzen Sie es durch Ihre AWS Konto-ID und *EKS-my-cluster-my-namespace-Viewers* durch den Namen der Rolle im Eintrag in Ihrem`ConfigMap`. Wenn der Eintrag, den Sie entfernen möchten, für einen IAM-Benutzer und nicht für eine IAM-Rolle bestimmt ist, `role` ersetzen Sie ihn durch `user` und *EKS-my-cluster-my-namespace-Viewers* durch den Benutzernamen.
```
eksctl delete iamidentitymapping --arn arn:aws: iam::111122223333:role/EKS-my-cluster-my-namespace-Viewers --cluster my-cluster
```
# Berechtigungen von Zugriffsrichtlinien überprüfen
Zugriffsrichtlinien beinhalten `rules`, die Kubernetes `verbs` (Berechtigungen) und `resources` enthalten. Zugriffsrichtlinien beinhalten keine IAM-Berechtigungen oder -Ressourcen. Ähnlich wie bei Kubernetes `Role` und `ClusterRole`-Objekten beinhalten Zugriffsrichtlinien nur `allow` `rules`. Der Inhalt einer Zugriffsrichtlinie kann nicht geändert werden. Sie können keine eigenen Zugriffsrichtlinien erstellen. Wenn die Berechtigungen in den Zugriffsrichtlinien Ihre Anforderungen nicht erfüllen, können Sie Kubernetes-RBAC-Objekte erstellen und *Gruppennamen* für Ihre Zugriffseinträge angeben. Weitere Informationen finden Sie unter [Zugriffseinträge erstellen](creating-access-entries.md). Die in den Zugriffsrichtlinien enthaltenen Berechtigungen ähneln den Berechtigungen in den benutzerorientierten Cluster-Rollen von Kubernetes. Weitere Informationen finden Sie unter[Benutzerorientierte Rollen](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles) in der Kubernetes-Dokumentation.
## Alle Richtlinien auflisten
Verwenden Sie eine der auf dieser Seite aufgeführten Zugriffsrichtlinien oder rufen Sie mit der AWS CLI eine Liste aller verfügbaren Zugriffsrichtlinien ab:
```
aws eks list-access-policies
```
Die erwartete Ausgabe sollte wie folgt aussehen (der Kürze halber abgekürzt):
```
{
"accessPolicies": [
{
"name": "AmazonAIOpsAssistantPolicy",
"arn": "arn:aws:eks::aws:cluster-access-policy/AmazonAIOpsAssistantPolicy"
},
{
"name": "AmazonARCRegionSwitchScalingPolicy",
"arn": "arn:aws:eks::aws:cluster-access-policy/AmazonARCRegionSwitchScalingPolicy"
},
{
"name": "AmazonEKSAdminPolicy",
"arn": "arn:aws:eks::aws:cluster-access-policy/AmazonEKSAdminPolicy"
},
{
"name": "AmazonEKSAdminViewPolicy",
"arn": "arn:aws:eks::aws:cluster-access-policy/AmazonEKSAdminViewPolicy"
},
{
"name": "AmazonEKSAutoNodePolicy",
"arn": "arn:aws:eks::aws:cluster-access-policy/AmazonEKSAutoNodePolicy"
}
// Additional policies omitted
]
}
```
## EKSAdminAmazon-Richtlinie
Diese Zugriffsrichtlinie umfasst Berechtigungen, die einem IAM-Prinzipal die meisten Berechtigungen für Ressourcen erteilen. Wenn dies einem Zugriffseintrag zugeordnet ist, umfasst sein Zugriffsbereich normalerweise einen oder mehrere Kubernetes-Namespaces. Wenn ein IAM-Prinzipal über Administratorzugriff auf alle Ressourcen in Ihrem Cluster verfügen soll, ordnen Sie die Zugriffsrichtlinie [Amazon EKSCluster AdminPolicy](#access-policy-permissions-amazoneksclusteradminpolicy) stattdessen Ihrem Zugriffseintrag zu.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSAdminPolicy`
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `apps` | `daemonsets`, `deployments`, `deployments/rollback`, `deployments/scale`, `replicasets`, `replicasets/scale`, `statefulsets`, `statefulsets/scale` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `apps` | `controllerrevisions`, `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `replicasets`, `replicasets/scale`, `replicasets/status`, `statefulsets`, `statefulsets/scale`, `statefulsets/status` | `get`, `list`, `watch` |
| `authorization.k8s.io` | `localsubjectaccessreviews` | `create` |
| `autoscaling` | `horizontalpodautoscalers` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `autoscaling` | `horizontalpodautoscalers`, `horizontalpodautoscalers/status` | `get`, `list`, `watch` |
| `batch` | `cronjobs`, `jobs` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `batch` | `cronjobs`, `cronjobs/status`, `jobs`, `jobs/status` | `get`, `list`, `watch` |
| `discovery.k8s.io` | `endpointslices` | `get`, `list`, `watch` |
| `extensions` | `daemonsets`, `deployments`, `deployments/rollback`, `deployments/scale`, `ingresses`, `networkpolicies`, `replicasets`, `replicasets/scale`, `replicationcontrollers/scale` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `extensions` | `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `ingresses`, `ingresses/status`, `networkpolicies`, `replicasets`, `replicasets/scale`, `replicasets/status`, `replicationcontrollers/scale` | `get`, `list`, `watch` |
| `networking.k8s.io` | `ingresses`, `ingresses/status`, `networkpolicies` | `get`, `list`, `watch` |
| `networking.k8s.io` | `ingresses`, `networkpolicies` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `policy` | `poddisruptionbudgets` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `policy` | `poddisruptionbudgets`, `poddisruptionbudgets/status` | `get`, `list`, `watch` |
| `rbac.authorization.k8s.io` | `rolebindings`, `roles` | `create`, `delete`, `deletecollection`, `get`, `list`, `patch`, `update`, `watch` |
| | `configmaps`, `endpoints`, `persistentvolumeclaims`, `persistentvolumeclaims/status`, `pods`, `replicationcontrollers`, `replicationcontrollers/scale`, `serviceaccounts`, `services`, `services/status` | `get`,`list`, `watch` |
| | `pods/attach`, `pods/exec`, `pods/portforward`, `pods/proxy`, `secrets`, `services/proxy` | `get`, `list`, `watch` |
| | `configmaps`, `events`, `persistentvolumeclaims`, `replicationcontrollers`, `replicationcontrollers/scale`, `secrets`, `serviceaccounts`, `services`, `services/proxy` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| | `pods`, `pods/attach`, `pods/exec`, `pods/portforward`, `pods/proxy` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| | `serviceaccounts` | `impersonate` |
| | `bindings`, `events`, `limitranges`, `namespaces/status`, `pods/log`, `pods/status`, `replicationcontrollers/status`, `resourcequotas`, `resourcequotas/status` | `get`, `list`, `watch` |
| | `namespaces` | `get`,`list`, `watch` |
## Amazon EKSCluster AdminPolicy
Diese Zugriffsrichtlinie umfasst Berechtigungen, die einem IAM-Prinzipaladministrator Zugriff auf einen Cluster gewähren. Wenn dies einem Zugriffseintrag zugeordnet ist, umfasst der Zugriffsbereich in der Regel keinen Kubernetes-Namespace, sondern den Cluster. Wenn Sie möchten, dass ein IAM-Prinzipal einen eingeschränkteren Verwaltungsbereich hat, sollten Sie stattdessen die [EKSAdminAmazon-Richtlinie](#access-policy-permissions-amazoneksadminpolicy)-Zugriffsrichtlinie mit Ihrem Zugriffseintrag verknüpfen.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy`
| Kubernetes-API-Gruppen | Kubernetes, keine Ressource URLs | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- | --- |
| `*` | | `*` | `*` |
| | `*` | | `*` |
## Amazon EKSAdmin ViewPolicy
Diese Zugriffsrichtlinie umfasst Berechtigungen, die einem IAM-Prinzipal Zugriff auf list/view alle Ressourcen in einem Cluster gewähren. Beachten Sie, dass dies [Kubernetes-Geheimnisse](https://kubernetes.io/docs/concepts/configuration/secret/) umfasst.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSAdminViewPolicy`
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `*` | `*` | `get`, `list`, `watch` |
## EKSEditAmazon-Richtlinie
Diese Zugriffsrichtlinie umfasst Berechtigungen, mit denen ein IAM-Prinzipal die meisten Kubernetes-Ressourcen bearbeiten kann.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSEditPolicy`
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `apps` | `daemonsets`, `deployments`, `deployments/rollback`, `deployments/scale`, `replicasets`, `replicasets/scale`, `statefulsets`, `statefulsets/scale` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `apps` | `controllerrevisions`, `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `replicasets`, `replicasets/scale`, `replicasets/status`, `statefulsets`, `statefulsets/scale`, `statefulsets/status` | `get`, `list`, `watch` |
| `autoscaling` | `horizontalpodautoscalers`, `horizontalpodautoscalers/status` | `get`, `list`, `watch` |
| `autoscaling` | `horizontalpodautoscalers` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `batch` | `cronjobs`, `jobs` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `batch` | `cronjobs`, `cronjobs/status`, `jobs`, `jobs/status` | `get`, `list`, `watch` |
| `discovery.k8s.io` | `endpointslices` | `get`, `list`, `watch` |
| `extensions` | `daemonsets`, `deployments`, `deployments/rollback`, `deployments/scale`, `ingresses`, `networkpolicies`, `replicasets`, `replicasets/scale`, `replicationcontrollers/scale` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `extensions` | `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `ingresses`, `ingresses/status`, `networkpolicies`, `replicasets`, `replicasets/scale`, `replicasets/status`, `replicationcontrollers/scale` | `get`, `list`, `watch` |
| `networking.k8s.io` | `ingresses`, `networkpolicies` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `networking.k8s.io` | `ingresses`, `ingresses/status`, `networkpolicies` | `get`, `list`, `watch` |
| `policy` | `poddisruptionbudgets` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| `policy` | `poddisruptionbudgets`, `poddisruptionbudgets/status` | `get`, `list`, `watch` |
| | `namespaces` | `get`, `list`, `watch` |
| | `pods/attach`, `pods/exec`, `pods/portforward`, `pods/proxy`, `secrets`, `services/proxy` | `get`, `list`, `watch` |
| | `serviceaccounts` | `impersonate` |
| | `pods`, `pods/attach`, `pods/exec`, `pods/portforward`, `pods/proxy` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| | `configmaps`, `events`, `persistentvolumeclaims`, `replicationcontrollers`, `replicationcontrollers/scale`, `secrets`, `serviceaccounts`, `services`, `services/proxy` | `create`, `delete`, `deletecollection`, `patch`, `update` |
| | `configmaps`, `endpoints`, `persistentvolumeclaims`, `persistentvolumeclaims/status`, `pods`, `replicationcontrollers`, `replicationcontrollers/scale`, `serviceaccounts`, `services`, `services/status` | `get`, `list`, `watch` |
| | `bindings`, `events`, `limitranges`, `namespaces/status`, `pods/log`, `pods/status`, `replicationcontrollers/status`, `resourcequotas`, `resourcequotas/status` | `get`, `list`, `watch` |
## EKSViewAmazon-Richtlinie
Diese Zugriffsrichtlinie umfasst Berechtigungen, mit denen ein IAM-Prinzipal die meisten Kubernetes-Ressourcen anzeigen kann.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSViewPolicy`
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `apps` | `controllerrevisions`, `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `replicasets`, `replicasets/scale`, `replicasets/status`, `statefulsets`, `statefulsets/scale`, `statefulsets/status` | `get`, `list`, `watch` |
| `autoscaling` | `horizontalpodautoscalers`, `horizontalpodautoscalers/status` | `get`, `list`, `watch` |
| `batch` | `cronjobs`, `cronjobs/status`, `jobs`, `jobs/status` | `get`, `list`, `watch` |
| `discovery.k8s.io` | `endpointslices` | `get`, `list`, `watch` |
| `extensions` | `daemonsets`, `daemonsets/status`, `deployments`, `deployments/scale`, `deployments/status`, `ingresses`, `ingresses/status`, `networkpolicies`, `replicasets`, `replicasets/scale`, `replicasets/status`, `replicationcontrollers/scale` | `get`, `list`, `watch` |
| `networking.k8s.io` | `ingresses`, `ingresses/status`, `networkpolicies` | `get`, `list`, `watch` |
| `policy` | `poddisruptionbudgets`, `poddisruptionbudgets/status` | `get`, `list`, `watch` |
| | `configmaps`, `endpoints`, `persistentvolumeclaims`, `persistentvolumeclaims/status`, `pods`, `replicationcontrollers`, `replicationcontrollers/scale`, `serviceaccounts`, `services`, `services/status` | `get`, `list`, `watch` |
| | `bindings`, `events`, `limitranges`, `namespaces/status`, `pods/log`, `pods/status`, `replicationcontrollers/status`, `resourcequotas`, `esourcequotas/status` | `get`, `list`, `watch` |
| | `namespaces` | `get`, `list`, `watch` |
## Amazon EKSSecret ReaderPolicy
Diese Zugriffsrichtlinie beinhaltet Berechtigungen, die es einem IAM-Prinzipal ermöglichen, [Kubernetes](https://kubernetes.io/docs/concepts/configuration/secret/) Secrets zu lesen.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSSecretReaderPolicy`
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| | `secrets` | `get`, `list`, `watch` |
## Amazon EKSAuto NodePolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSAutoNodePolicy`
Diese Richtlinie umfasst die folgenden Berechtigungen, mit denen Amazon-EKS-Komponenten die folgenden Aufgaben ausführen können:
+ `kube-proxy` – Überwachen Sie Netzwerkendpunkte und -services und verwalten Sie zugehörige Ereignisse. Dies ermöglicht eine Cluster-weite Netzwerk-Proxy-Funktionalität.
+ `ipamd`— Verwaltung von AWS VPC-Netzwerkressourcen und Container-Netzwerkschnittstellen (CNI). Dadurch kann der IP-Adressverwaltungs-Daemon die Pod-Vernetzung verwalten.
+ `coredns` – Greifen Sie auf Ressourcen zur Serviceerkennung wie Endpunkte und Services zu. Dies ermöglicht die DNS-Auflösung innerhalb des Clusters.
+ `ebs-csi-driver` – Arbeiten Sie mit speicherbezogenen Ressourcen für Amazon-EBS-Volumes. Dies ermöglicht die dynamische Bereitstellung und Anbindung von persistenten Volumes.
+ `neuron`— Überwachen Sie Knoten und Pods für AWS Neuron-Geräte. Dies ermöglicht die Verwaltung von AWS Inferentia- und Trainium-Beschleunigern.
+ `node-monitoring-agent` – Zugriff auf Knotendiagnosen und Ereignisse. Dies ermöglicht die Überwachung des Cluster-Zustands und die Erfassung von Diagnosedaten.
Jede Komponente verwendet ein dediziertes Servicekonto und ist auf die für ihre spezifische Funktion erforderlichen Berechtigungen beschränkt.
Wenn Sie eine Node-IAM-Rolle in einem manuell angeben NodeClass, müssen Sie einen Zugriffseintrag erstellen, der die neue Node-IAM-Rolle dieser Zugriffsrichtlinie zuordnet.
## Amazon EKSBlock StoragePolicy
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSBlockStoragePolicy`
Diese Richtlinie umfasst Berechtigungen, mit denen Amazon EKS die Leader-Wahl und die Koordinierung von Ressourcen für Speichervorgänge verwalten kann:
+ `coordination.k8s.io` – Erstellen und verwalten Sie Lease-Objekte für die Leader-Wahl. Dadurch können EKS-Speicherkomponenten ihre Aktivitäten über einen Mechanismus für die Leader-Wahl Cluster-weit koordinieren.
Die Richtlinie gilt für bestimmte Lease-Ressourcen, die von den EKS-Speicherkomponenten verwendet werden, um Konflikte beim Zugriff auf andere Koordinierungsressourcen im Cluster zu vermeiden.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Blockspeicherfunktion ordnungsgemäß funktioniert.
## Amazon EKSLoad BalancingPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSLoadBalancingPolicy`
Diese Richtlinie umfasst Berechtigungen, mit denen Amazon EKS Ressourcen für die Leader-Wahl zum Load Balancing verwalten kann:
+ `coordination.k8s.io` – Erstellen und verwalten Sie Lease-Objekte für die Leader-Wahl. Dadurch können die EKS-Komponenten für das Load Balancing durch die Leader-Wahl Aktivitäten über mehrere Replikate hinweg koordinieren.
Die Richtlinie ist speziell auf das Load Balancing von Lease-Ressourcen ausgerichtet, um eine ordnungsgemäße Koordination sicherzustellen und gleichzeitig den Zugriff auf andere Leasing-Ressourcen im Cluster zu verhindern.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Netzwerkfunktion ordnungsgemäß funktioniert.
## EKSNetworkingAmazon-Richtlinie
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSNetworkingPolicy`
Diese Richtlinie umfasst Berechtigungen, mit denen Amazon EKS Ressourcen für die Leader-Wahl für die Vernetzung verwalten kann:
+ `coordination.k8s.io` – Erstellen und verwalten Sie Lease-Objekte für die Leader-Wahl. Dadurch können EKS-Netzwerkkomponenten die Aktivitäten zur IP-Adresszuweisung durch die Leader-Wahl koordinieren.
Die Richtlinie ist speziell auf die Vernetzung von Lease-Ressourcen ausgerichtet, um eine ordnungsgemäße Koordination zu gewährleisten und gleichzeitig den Zugriff auf andere Lease-Ressourcen im Cluster zu verhindern.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Netzwerkfunktion ordnungsgemäß funktioniert.
## EKSComputeAmazon-Richtlinie
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSComputePolicy`
Diese Richtlinie umfasst Berechtigungen, mit denen Amazon EKS Ressourcen für die Leader-Wahl für Rechenoperationen verwalten kann:
+ `coordination.k8s.io` – Erstellen und verwalten Sie Lease-Objekte für die Leader-Wahl. Dadurch können EKS-Rechenkomponenten die Skalierungsaktivitäten der Knoten durch die Leader-Wahl koordinieren.
Die Richtlinie ist speziell auf die Berechnung von Verwaltungs-Lease-Ressourcen ausgerichtet und ermöglicht gleichzeitig den grundlegenden Lesezugriff (`get`, `watch`) auf alle Lease-Ressourcen im Cluster.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Netzwerkfunktion ordnungsgemäß funktioniert.
## Amazon EKSBlock StorageClusterPolicy
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSBlockStorageClusterPolicy`
Diese Richtlinie gewährt die erforderlichen Berechtigungen für die Blockspeicherfunktion von Amazon EKS Auto Mode. Sie ermöglicht eine effiziente Verwaltung der Blockspeicherressourcen innerhalb von Amazon-EKS-Clustern. Die Richtlinie umfasst folgende Berechtigungen:
CSI-Treiberverwaltung:
+ Erstellen, Lesen, Aktualisieren und Löschen von CSI-Treibern, insbesondere für Blockspeicher.
Volume-Verwaltung:
+ Auflisten, Beobachten, Erstellen, Aktualisieren, Patchen und Löschen persistenter Volumes.
+ Auflisten, Überwachen und Aktualisieren von persistenten Volume-Ansprüchen.
+ Patchen Sie des Status von persistenten Volume-Ansprüchen.
Interaktion zwischen Knoten und Pods:
+ Lesen Sie Informationen zu Knoten und Pods.
+ Speichern Sie Ereignisse im Zusammenhang mit Speichervorgängen.
Speicherklassen und Attribute:
+ Lesen Sie Speicherklassen und CSI-Knoten.
+ Lesen Sie die Volume-Attributklassen.
Anhänge von Volumes:
+ Auflisten, Überwachen und Ändern von Volume-Anhängen und deren Status.
Snapshot-Vorgänge:
+ Verwalten Sie Volumen-Snapshots, Snapshot-Inhalte und Snapshot-Klassen.
+ Verwalten Sie Vorgänge für Volume-Gruppen-Snapshots und zugehörige Ressourcen.
Diese Richtlinie wurde entwickelt, um eine umfassende Verwaltung von Blockspeichern innerhalb von Amazon-EKS-Clustern zu unterstützen, die im Automatikmodus ausgeführt werden. Sie umfasst Berechtigungen für verschiedene Vorgänge, darunter die Bereitstellung, das Anfügen, die Größenänderung und die Erstellung von Snapshots von Blockspeicher-Volumes.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Blockspeicherfunktion ordnungsgemäß funktioniert.
## Amazon EKSCompute ClusterPolicy
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSComputeClusterPolicy`
Diese Richtlinie gewährt die erforderlichen Berechtigungen für die Rechenmanagement-Funktionen von Amazon EKS Auto Mode. Sie ermöglicht eine effiziente Orchestrierung und Skalierung von Rechenressourcen innerhalb von Amazon-EKS-Clustern Die Richtlinie umfasst folgende Berechtigungen:
Knotenverwaltung:
+ Den Status von und erstellen, lesen, aktualisieren, löschen und verwalten. NodePools NodeClaims
+ Verwalten NodeClasses, einschließlich Erstellung, Änderung und Löschung.
Terminplanung und Ressourcenmanagement:
+ Leserechte für Pods, Knoten, persistente Volumes, persistente Volume-Ansprüche, Replikationscontroller und Namespaces.
+ Lesezugriff auf Speicherklassen, CSI-Knoten und Volume-Anhänge.
+ Auflistung und Überwachung von Bereitstellungen, Daemon-Sets, Replica-Sets und Stateful-Sets.
+ Lesen Sie die Budgets für Pod-Unterbrechungen.
Ereignisbehandlung:
+ Erstellen, Lesen und Verwalten von Cluster-Ereignissen.
Entzug der Berechtigungen für Knoten und Pod-Bereinigung:
+ Aktualisieren, patchen und löschen Sie Knoten.
+ Erstellen Sie Pod-Bereinigungen und löschen Sie Pods bei Bedarf.
Verwaltung benutzerdefinierter Ressourcendefinitionen (CRD):
+ Neues erstellen CRDs.
+ Spezifische Funktionen CRDs im Zusammenhang mit der Knotenverwaltung verwalten (NodeClasses NodePools NodeClaims,, und NodeDiagnostics).
Diese Richtlinie wurde entwickelt, um eine umfassende Datenverarbeitungsverwaltung innerhalb von Amazon-EKS-Clustern zu unterstützen, die im Automatikmodus ausgeführt werden. Es vereint Berechtigungen für verschiedene Vorgänge, darunter die Bereitstellung von Knoten, die Planung, die Skalierung und die Ressourcenoptimierung.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Datenverarbeitungsverwaltungsfunktion ordnungsgemäß funktioniert.
## Amazon EKSLoad BalancingClusterPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSLoadBalancingClusterPolicy`
Diese Richtlinie gewährt die erforderlichen Berechtigungen für die Load-Balancing-Funktion von Amazon EKS Auto Mode. Es ermöglicht die effiziente Verwaltung und Konfiguration von Load-Balancing-Ressourcen innerhalb von Amazon-EKS-Clustern. Die Richtlinie umfasst folgende Berechtigungen:
Ereignis- und Ressourcenmanagement:
+ Erstellen und Patchen von Ereignissen.
+ Lesezugriff auf Pods, Knoten, Endpunkte und Namespaces.
+ Aktualisieren des Pod-Status.
Service- und Ingress-Management:
+ Vollständige Verwaltung von Services und deren Status.
+ Umfassende Kontrolle über Ingresses und deren Status.
+ Lesezugriff auf Endpunkt-Slices und Ingress-Klassen.
Zielgruppenbindungen:
+ Erstellen und Ändern von Zielgruppenbindungen und deren Status.
+ Lesezugriff auf Ingress-Klassenparameter.
Verwaltung benutzerdefinierter Ressourcendefinitionen (CRD):
+ Alles erstellen und lesen CRDs.
+ Spezifische Verwaltung von targetgroupbindings.eks.amazonaws.com und ingressclassparams.eks.amazonaws.com. CRDs
Webhook-Konfiguration:
+ Erstellen und Lesen von sich ändernden und validierenden Webhook-Konfigurationen.
+ Konfiguration verwalten eks-load-balancing-webhook.
Diese Richtlinie wurde entwickelt, um ein umfassendes Lastenausgleichsmanagement innerhalb von Amazon-EKS-Clustern zu unterstützen, die im Automatikmodus ausgeführt werden. Es kombiniert Berechtigungen für verschiedene Operationen, darunter die Bereitstellung von Diensten, das Routing eingehender Zugriffe und die Integration mit AWS Lastenausgleichsdiensten.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Load-Balancing-Funktion ordnungsgemäß funktioniert.
## Amazon EKSNetworking ClusterPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSNetworkingClusterPolicy`
Amazon EKSNetworking ClusterPolicy
Diese Richtlinie gewährt die erforderlichen Berechtigungen für die Netzwerkfunktionen von Amazon EKS Auto Mode. Sie ermöglicht die effiziente Verwaltung und Konfiguration von Netzwerkressourcen innerhalb von Amazon-EKS-Clustern. Die Richtlinie umfasst folgende Berechtigungen:
Knoten- und Pod-Verwaltung:
+ Lesezugriff auf NodeClasses und deren Status.
+ Lesezugriff auf NodeClaims und deren Status.
+ Lesezugriff auf Pods.
CNI-Knotenverwaltung:
+ Berechtigungen für CNINodes und deren Status, einschließlich Erstellen, Lesen, Aktualisieren, Löschen und Patchen.
Verwaltung benutzerdefinierter Ressourcendefinitionen (CRD):
+ Alles CRDs erstellen und lesen.
+ Spezifische Verwaltung (Aktualisieren, Patchen, Löschen) des CRD cninodes.eks.amazonaws.com.
Ereignis-Management:
+ Erstellen und Patchen von Ereignissen.
Diese Richtlinie wurde entwickelt, um ein umfassendes Netzwerkmanagement innerhalb von Amazon-EKS-Clustern zu unterstützen, die im Automatikmodus ausgeführt werden. Sie kombiniert Berechtigungen für verschiedene Vorgänge, einschließlich Knoten-Netzwerkkonfiguration, CNI-Verwaltung (Container Network Interface) und zugehörige benutzerdefinierte Ressourcenverwaltung.
Die Richtlinie ermöglicht es den Netzwerkkomponenten, mit knotenbezogenen Ressourcen zu interagieren, CNI-spezifische Knotenkonfigurationen zu verwalten und benutzerdefinierte Ressourcen zu verarbeiten, die für den Netzwerkbetrieb im Cluster von entscheidender Bedeutung sind.
Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Cluster-IAM-Rolle, wenn der Automatikmodus aktiviert ist. Dadurch wird sichergestellt, dass die erforderlichen Berechtigungen vorhanden sind, damit die Netzwerkfunktion ordnungsgemäß funktioniert.
## EKSHybridAmazon-Richtlinie
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
Diese Zugriffsrichtlinie umfasst Berechtigungen, die EKS Zugriff auf die Knoten eines Clusters gewähren. Wenn dies einem Zugriffseintrag zugeordnet ist, umfasst der Zugriffsbereich in der Regel keinen Kubernetes-Namespace, sondern den Cluster. Diese Richtlinie wird von Amazon-EKS-Hybridknoten verwendet.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSHybridPolicy`
| Kubernetes-API-Gruppen | Kubernetes, keine Ressource URLs | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- | --- |
| `*` | | `nodes` | `list` |
## Amazon EKSCluster InsightsPolicy
**Anmerkung**
Diese Richtlinie ist nur für AWS dienstbezogene Rollen vorgesehen und kann nicht für vom Kunden verwaltete Rollen verwendet werden.
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSClusterInsightsPolicy`
Diese Richtlinie gewährt Lesezugriffsberechtigungen für Erkenntnisfunktionalität von Amazon-EKS-Cluster Die Richtlinie umfasst folgende Berechtigungen:
Knoten-Zugriff: – Cluster-Knoten auflisten und anzeigen – Knotenstatusinformationen lesen
DaemonSet Zugriff: — Lesezugriff auf die Kube-Proxy-Konfiguration
Diese Richtlinie wird automatisch vom EKS-Service für Cluster-Ereignisse verwaltet. Weitere Informationen finden Sie unter [Vorbereitung auf Kubernetes-Versionsupgrades und Beheben von Fehlkonfigurationen mit Cluster-Einblicken](cluster-insights.md).
## AWSBackupFullAccessPolicyForBackup
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AWSBackupFullAccessPolicyForBackup`
AWSBackupFullAccessPolicyForBackup
Diese Richtlinie gewährt die Berechtigungen, die AWS Backup benötigt, um Backups des EKS-Clusters zu verwalten und zu erstellen. Diese Richtlinie umfasst die folgenden Berechtigungen:
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `*` | `*` | `list`, `get` |
## AWSBackupFullAccessPolicyForRestore
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AWSBackupFullAccessPolicyForRestore`
AWSBackupFullAccessPolicyForRestore
Diese Richtlinie gewährt die Berechtigungen, die AWS Backup benötigt, um Backups des EKS-Clusters zu verwalten und wiederherzustellen. Diese Richtlinie umfasst die folgenden Berechtigungen:
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `*` | `*` | `list`, `get`, `create` |
## Amazon EKSACKPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSACKPolicy`
Diese Richtlinie gewährt die erforderlichen Berechtigungen, damit die Funktionen von AWS Controllers for Kubernetes (ACK) AWS Ressourcen von Kubernetes verwalten können. Die Richtlinie umfasst folgende Berechtigungen:
Benutzerdefiniertes ACK-Ressourcenmanagement:
+ Voller Zugriff auf alle benutzerdefinierten Ressourcen des ACK-Dienstes für mehr als 50 AWS Dienste, darunter S3, RDS, DynamoDB, Lambda, EC2 und mehr.
+ Benutzerdefinierte ACK-Ressourcendefinitionen erstellen, lesen, aktualisieren und löschen.
Namespace-Zugriff:
+ Lesezugriff auf Namespaces für die Ressourcenorganisation.
Wahl des Vorsitzenden:
+ Erstellen und lesen Sie Koordinationsverträge für die Wahl des Vorsitzenden.
+ Aktualisieren und löschen Sie bestimmte ACK Service Controller-Leases.
Ereignis-Management:
+ Ereignisse für ACK-Operationen erstellen und patchen.
Diese Richtlinie wurde entwickelt, um ein umfassendes AWS Ressourcenmanagement über APIs Kubernetes zu unterstützen. Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Capability IAM-Rolle, die Sie bei der Erstellung der ACK-Fähigkeit angeben.
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| | `namespaces` | `get`, `watch`, `list` |
| `services.k8s.aws`, `acm.services.k8s.aws`, `acmpca.services.k8s.aws`, `apigateway.services.k8s.aws`, `apigatewayv2.services.k8s.aws`, `applicationautoscaling.services.k8s.aws`, `athena.services.k8s.aws`, `bedrock.services.k8s.aws`, `bedrockagent.services.k8s.aws`, `bedrockagentcorecontrol.services.k8s.aws`, `cloudfront.services.k8s.aws`, `cloudtrail.services.k8s.aws`, `cloudwatch.services.k8s.aws`, `cloudwatchlogs.services.k8s.aws`, `codeartifact.services.k8s.aws`, `cognitoidentityprovider.services.k8s.aws`, `documentdb.services.k8s.aws`, `dynamodb.services.k8s.aws`, `ec2.services.k8s.aws`, `ecr.services.k8s.aws`, `ecrpublic.services.k8s.aws`, `ecs.services.k8s.aws`, `efs.services.k8s.aws`, `eks.services.k8s.aws`, `elasticache.services.k8s.aws`, `elbv2.services.k8s.aws`, `emrcontainers.services.k8s.aws`, `eventbridge.services.k8s.aws`, `iam.services.k8s.aws`, `kafka.services.k8s.aws`, `keyspaces.services.k8s.aws`, `kinesis.services.k8s.aws`, `kms.services.k8s.aws`, `lambda.services.k8s.aws`, `memorydb.services.k8s.aws`, `mq.services.k8s.aws`, `networkfirewall.services.k8s.aws`, `opensearchservice.services.k8s.aws`, `organizations.services.k8s.aws`, `pipes.services.k8s.aws`, `prometheusservice.services.k8s.aws`, `ram.services.k8s.aws`, `rds.services.k8s.aws`, `recyclebin.services.k8s.aws`, `route53.services.k8s.aws`, `route53resolver.services.k8s.aws`, `s3.services.k8s.aws`, `s3control.services.k8s.aws`, `sagemaker.services.k8s.aws`, `secretsmanager.services.k8s.aws`, `ses.services.k8s.aws`, `sfn.services.k8s.aws`, `sns.services.k8s.aws`, `sqs.services.k8s.aws`, `ssm.services.k8s.aws`, `wafv2.services.k8s.aws` | `*` | `*` |
| `coordination.k8s.io` | `leases` | `create`, `get`, `list`, `watch` |
| `coordination.k8s.io` | `leases`(Nur für bestimmte ACK-Service-Controller-Leases) | `delete`, `update`, `patch` |
| | `events` | `create`, `patch` |
| `apiextensions.k8s.io` | `customresourcedefinitions` | `*` |
## EKSArgoCDClusterAmazon-Richtlinie
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSArgoCDClusterPolicy`
Diese Richtlinie gewährt Berechtigungen auf Clusterebene, die für die Argo-CD-Funktion erforderlich sind, um Ressourcen zu erkennen und Objekte im Clusterbereich zu verwalten. Die Richtlinie umfasst folgende Berechtigungen:
Namespace-Verwaltung:
+ Namespaces für die Namespace-Verwaltung von Anwendungen erstellen, lesen, aktualisieren und löschen.
Verwaltung benutzerdefinierter Ressourcendefinitionen:
+ Argo CD-spezifisch verwalten CRDs (Anwendungen, AppProjects, ApplicationSets).
API-Erkennung:
+ Lesezugriff auf Kubernetes-API-Endpunkte zur Ressourcenerkennung.
Diese Richtlinie wurde entwickelt, um Argo-CD-Operationen auf Clusterebene zu unterstützen, einschließlich Namespace-Verwaltung und CRD-Installation. Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Capability IAM-Rolle, die Sie bei der Erstellung der Argo-CD-Funktion angeben.
| Kubernetes-API-Gruppen | Kubernetes, keine Ressource URLs | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- | --- |
| | | `namespaces` | `create`, `get`, `update`, `patch`, `delete` |
| `apiextensions.k8s.io` | | `customresourcedefinitions` | `create` |
| `apiextensions.k8s.io` | | `customresourcedefinitions`(Nur Argo-CD) CRDs | `get`, `update`, `patch`, `delete` |
| | `/api`, `/api/*`, `/apis`, `/apis/*` | | `get` |
## Amazon EKSArgo CDPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSArgoCDPolicy`
Diese Richtlinie gewährt Berechtigungen auf Namespace-Ebene, die für die Argo-CD-Funktion zur Bereitstellung und Verwaltung von Anwendungen erforderlich sind. Die Richtlinie umfasst folgende Berechtigungen:
Geheime Verwaltung:
+ Voller Zugriff auf Geheimnisse für Git-Anmeldeinformationen und Clustergeheimnisse.
ConfigMap Zugriff:
+ Lesezugriff auf, um Warnungen ConfigMaps zu senden, wenn Kunden versuchen, Argo CD zu verwenden, die nicht unterstützt wird. ConfigMaps
Ereignis-Management:
+ Lesen und erstellen Sie Ereignisse für die Überwachung des Anwendungslebenszyklus.
Argo CD Ressourcenmanagement:
+ Voller Zugriff auf Anwendungen ApplicationSets, und AppProjects.
+ Verwalten Sie die Finalizer und den Status der Argo-CD-Ressourcen.
Diese Richtlinie wurde entwickelt, um Argo-CD-Operationen auf Namespace-Ebene zu unterstützen, einschließlich der Anwendungsbereitstellung und -verwaltung. Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Capability IAM-Rolle, die Sie angeben, wenn die Argo-CD-Funktion erstellt wird, und zwar für den Argo-CD-Namespace.
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| | `secrets` | `*` |
| | `configmaps` | `get`, `list`, `watch` |
| | `events` | `get`, `list`, `watch`, `patch`, `create` |
| `argoproj.io` | `applications`, `applications/finalizers`, `applications/status`, `applicationsets`, `applicationsets/finalizers`, `applicationsets/status`, `appprojects`, `appprojects/finalizers`, `appprojects/status` | `*` |
## Amazon EKSKROPolicy
**ARN** – ` arn:aws: eks::aws:cluster-access-policy/AmazonEKSKROPolicy`
Diese Richtlinie gewährt Berechtigungen, die für die Kro-Funktion (Kube Resource Orchestrator) erforderlich sind, um benutzerdefinierte Kubernetes zu erstellen und zu verwalten. APIs Die Richtlinie umfasst folgende Berechtigungen:
Kro-Ressourcenverwaltung:
+ Voller Zugriff auf alle Kro-Ressourcen, einschließlich ResourceGraphDefinitions benutzerdefinierter Ressourceninstanzen.
Verwaltung benutzerdefinierter Ressourcendefinitionen:
+ APIs Benutzerdefiniert von erstellen, lesen, aktualisieren und löschen CRDs ResourceGraphDefinitions.
Wahl des Vorsitzenden:
+ Erstellen und lesen Sie Koordinationsverträge für die Wahl des Vorsitzenden.
+ Aktualisieren und löschen Sie den Kro-Controller-Lease.
Ereignis-Management:
+ Ereignisse für Kro-Operationen erstellen und patchen.
Diese Richtlinie wurde entwickelt, um eine umfassende Ressourcenzusammenstellung und ein benutzerdefiniertes API-Management über Kro zu unterstützen. Amazon EKS erstellt automatisch einen Zugriffseintrag mit dieser Zugriffsrichtlinie für die Capability IAM-Rolle, die Sie bei der Erstellung der Kro-Fähigkeit angeben.
| Kubernetes-API-Gruppen | Kubernetes-Ressourcen | Kubernetes-Verben (Berechtigungen) |
| --- | --- | --- |
| `kro.run` | `*` | `*` |
| `apiextensions.k8s.io` | `customresourcedefinitions` | `*` |
| `coordination.k8s.io` | `leases` | `create`, `get`, `list`, `watch` |
| `coordination.k8s.io` | `leases`(Nur Kro-Controller-Lease) | `delete`, `update`, `patch` |
| | `events` | `create`, `patch` |
## Aktualisierungen für Zugriffsrichtlinien
Sehen Sie sich an, welche Aktualisierungen für Zugriffsrichtlinien seit ihrer Einführung vorgenommen wurden. Abonnieren Sie den RSS-Feed in [Dokumentverlauf](doc-history.md), um automatische Benachrichtigungen über Änderungen an dieser Seite zu erhalten.
| Änderungen | Beschreibung | Date |
| --- | --- | --- |
| Fügen Sie Richtlinien für EKS-Funktionen hinzu | Veröffentlichen`AmazonEKSACKPolicy`, `AmazonEKSArgoCDClusterPolicy``AmazonEKSArgoCDPolicy`, und `AmazonEKSKROPolicy` für die Verwaltung von EKS-Funktionen | 22. November 2025 |
| Add `AmazonEKSSecretReaderPolicy` | Fügen Sie eine neue Richtlinie für den schreibgeschützten Zugriff auf geheime Daten hinzu | 6. November 2025 |
| Richtlinie für EKS-Cluster-Erkenntnisse hinzufügen | `AmazonEKSClusterInsightsPolicy` veröffentlichen | 2. Dezember 2024 |
| Richtlinien für Amazon EKS Hybrid hinzufügen | `AmazonEKSHybridPolicy` veröffentlichen | 2. Dezember 2024 |
| Richtlinien für Amazon EKS Auto Mode hinzufügen | Diese Zugriffsrichtlinien gewähren der Cluster-IAM-Rolle und der Node-IAM-Rolle die Erlaubnis, Kubernetes aufzurufen. APIs AWS verwendet diese, um Routineaufgaben für Speicher-, Rechen- und Netzwerkressourcen zu automatisieren. | 2. Dezember 2024 |
| Add `AmazonEKSAdminViewPolicy` | Fügen Sie eine neue Richtlinie für erweiterten Zugriff auf Ansichten hinzu, einschließlich Ressourcen wie Geheimnisse. | 23. April 2024 |
| Zugriffsrichtlinien wurden eingeführt. | In Amazon EKS wurden Zugriffsrichtlinien eingeführt. | 29. Mai 2023 |
# Ändern des Authentifizierungsmodus, um Zugriffseinträge zu verwenden
Wenn Sie Zugriffseinträge verwenden möchten, müssen Sie zunächst den Authentifizierungsmodus des Clusters in `API_AND_CONFIG_MAP` oder `API` ändern. Dadurch wird die API für Zugriffseinträge hinzugefügt.
## AWS-Konsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie den Namen des Clusters aus, in dem Sie einen Zugriffseintrag erstellen möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Der **Authentifizierungsmodus** zeigt den aktuellen Authentifizierungsmodus des Clusters. Wenn der Modus EKS-API lautet, können Sie bereits Zugriffseinträge hinzufügen und die restlichen Schritte überspringen.
1. Wählen Sie **Zugriff verwalten** aus.
1. Wählen Sie für den **Cluster-Authentifizierungsmodus** einen Modus mit der EKS-API aus. Beachten Sie, dass der Authentifizierungsmodus nicht mehr in einen Modus geändert werden kann, in dem die EKS-API und die Zugriffseinträge entfernt werden.
1. Wählen Sie **Änderungen speichern ** aus. Amazon EKS beginnt mit der Aktualisierung des Clusters, der Status des Clusters ändert sich in „Wird aktualisiert“ und die Änderung wird auf der Registerkarte **Aktualisierungsverlauf** erfasst.
1. Warten Sie, bis der Status des Clusters wieder zu „Aktiv“ wechselt. Wenn der Cluster aktiv ist, können Sie die Schritte unter [Zugriffseinträge erstellen](creating-access-entries.md) befolgen, um IAM-Prinzipalen Zugriff auf den Cluster zu gewähren.
## AWS-CLI
1. Installieren Sie die AWS-CLI wie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im * Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle* beschrieben.
1. Führen Sie den folgenden Befehl aus. Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters. Wenn Sie die `ConfigMap`-Methode dauerhaft deaktivieren möchten, ersetzen Sie `API_AND_CONFIG_MAP` durch `API`.
Amazon EKS beginnt mit der Aktualisierung des Clusters, der Status des Clusters ändert sich in „WIRD AKTUALISIERT“ und die Änderung wird in der ** aws eks list-updates ** aufgezeichnet.
```
aws eks update-cluster-config --name my-cluster --access-config authenticationMode=API_AND_CONFIG_MAP
```
1. Warten Sie, bis der Status des Clusters wieder zu „Aktiv“ wechselt. Wenn der Cluster aktiv ist, können Sie die Schritte unter [Zugriffseinträge erstellen](creating-access-entries.md) befolgen, um IAM-Prinzipalen Zugriff auf den Cluster zu gewähren.
## Erforderliche Plattformversion
Um *Zugriffseinträge* verwenden zu können, muss der Cluster über eine Plattformversion verfügen, die mit der in der folgenden Tabelle aufgeführten Version identisch oder höher ist, oder über eine Kubernetes-Version, die höher ist als die in der Tabelle aufgeführten Versionen. Wenn Ihre Kubernetes-Version nicht aufgeführt ist, unterstützen alle Plattformversionen Zugriffseinträge.
| Kubernetes-Version | Plattformversion |
| --- | --- |
| Nicht aufgelistet | Alle unterstützt |
| `1.30` | `eks.2` |
| `1.29` | `eks.1` |
| `1.28` | `eks.6` |
Weitere Informationen finden Sie unter [platform-versions](https://docs.aws.amazon.com/eks/latest/userguide/platform-versions.html).
# Zugriffseinträge erstellen
Berücksichtigen Sie Folgendes, bevor Sie Zugriffseinträge erstellen:
+ Ein ordnungsgemäß eingerichteter Authentifizierungsmodus. Siehe [Ändern des Authentifizierungsmodus, um Zugriffseinträge zu verwenden](setting-up-access-entries.md).
+ Ein *Zugriffseintrag* enthält den Amazon-Ressourcennamen (ARN) genau eines vorhandenen IAM-Prinzipals. Ein IAM-Prinzipal kann nicht in mehreren Zugriffseinträgen enthalten sein. Zusätzliche Überlegungen zu dem von Ihnen angegebenen ARN:
+ In den bewährten Methoden für IAM wird empfohlen, für den Zugriff auf Ihren Cluster IAM-*Rollen* mit kurzfristigen Anmeldeinformationen zu verwenden anstatt IAM-*Benutzer* mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie unter [Menschliche Benutzer auffordern, den Verbund mit einem Identitätsanbieter zu verwenden, um mit temporären Anmeldeinformationen auf AWS zuzugreifen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) im *IAM-Benutzerhandbuch*.
+ Ein ARN für eine IAM-Rolle *kann* einen Pfad enthalten. ARNs in `aws-auth` `ConfigMap`-Einträgen können *keinen* Pfad enthalten. Ihr ARN kann beispielsweise ` arn:aws:iam::<111122223333>:role/` oder ` arn:aws:iam::<111122223333>:role/` lauten.
+ Wenn der Typ des Zugriffseintrags nicht `STANDARD` ist (siehe nächste Überlegung zu Typen), muss sich der ARN im gleichen AWS-Region befinden wie Ihr Cluster. Wenn der Typ `STANDARD` ist, kann sich der ARN im gleichen oder in einem anderen AWS-Region befinden wie der Cluster.
+ Nach der Erstellung des Zugriffseintrags kann der IAM-Prinzipal nicht mehr geändert werden.
+ Sollten Sie den IAM-Prinzipal mit diesem ARN löschen, wird der Zugriffseintrag nicht automatisch gelöscht. Es empfiehlt sich, den Zugriffseintrag mit einem ARN für einen gelöschten IAM-Prinzipal zu löschen. Wenn Sie den Zugriffseintrag nicht löschen und den IAM-Prinzipal erneut erstellen, funktioniert der Zugriffseintrag nicht, selbst wenn er dieselbe ARN aufweist. Dies liegt daran, dass, obwohl die ARN für den neu erstellten IAM-Prinzipal dieselbe ist, die `roleID` oder `userID` (Sie können dies mit dem AWS-CLI-Befehl `aws sts get-caller-identity` sehen) für den neu erstellten IAM-Prinzipal anders ist als für den ursprünglichen IAM-Prinzipal. Auch wenn Sie das `roleID` oder `userID` des IAM-Prinzipals für einen Zugriffseintrag nicht sehen, speichert Amazon EKS es mit dem Zugriffseintrag.
+ Jeder Zugriffseintrag hat einen *Typ*. Der Typ des Zugriffseintrags hängt vom Typ der Ressource ab, der er zugeordnet ist, und definiert nicht die Berechtigungen. Wenn Sie keinen Typ angeben, wird er von Amazon EKS automatisch auf `STANDARD` festgelegt
+ `EC2_LINUX` – Für eine IAM-Rolle, die mit selbstverwalteten Linux- oder Bottlerocket-Knoten verwendet wird
+ `EC2_WINDOWS` – Für eine IAM-Rolle, die mit selbstverwalteten Windows-Knoten verwendet wird
+ `FARGATE_LINUX` – Für eine mit AWS Fargate verwendete IAM-Rolle (Fargate)
+ `HYBRID_LINUX` – Für eine IAM-Rolle, die mit Hybridknoten verwendet wird
+ `STANDARD` – Standardtyp, falls keiner angegeben ist
+ `EC2` – Für benutzerdefinierte Knotenklassen im EKS Auto Mode. Weitere Informationen finden Sie unter [Knotenklassen-Zugriffseintrag erstellen](create-node-class.md#auto-node-access-entry).
+ Nach der Erstellung des Zugriffseintrags ist es nicht möglich, den Typ zu ändern.
+ Es ist nicht erforderlich, einen Zugriffseintrag für eine IAM-Rolle zu erstellen, die für eine verwaltete Knotengruppe oder ein Fargate-Profil verwendet wird. EKS erstellt Zugriffseinträge (sofern aktiviert) oder aktualisiert die Konfigurationszuordnung der Authentifizierung (sofern keine Zugriffseinträge verfügbar sind).
+ Wenn der Typ des Zugriffseintrags `STANDARD` lautet, können Sie einen *Benutzernamen* für den Zugriffseintrag angeben. Wenn Sie keinen Wert für den Benutzernamen angeben, legt Amazon EKS einen der folgenden Werte für Sie fest, abhängig vom Typ des Zugriffseintrags und davon, ob es sich bei dem von Ihnen angegebenen IAM-Prinzipal um eine IAM-Rolle oder um einen IAM-Benutzer handelt. Sofern Sie keinen spezifischen Grund für die Angabe eines eigenen Benutzernamens haben, empfehlen wir, keinen anzugeben und ihn automatisch von Amazon EKS generieren zu lassen. Beachten Sie bei Angabe eines eigenen Benutzernamens Folgendes:
+ Er darf nicht mit `system:`, `eks:`, `aws:`, `amazon:` oder `iam:` beginnen.
+ Bei einem Benutzername für eine IAM-Rolle empfiehlt es sich, am Ende des Benutzernamens `{{SessionName}}` oder `{{SessionNameRaw}}` hinzuzufügen. Wenn Sie Ihrem Benutzernamen `{{SessionName}}` oder `{{SessionNameRaw}}` hinzufügen, muss der Benutzername *vor* \$1\$1SessionName\$1\$1 einen Doppelpunkt enthalten. Wenn diese Rolle übernommen wird, wird der Name der AWS-STS-Sitzung, der bei der Übernahme der Rolle angegeben wurde, automatisch an den Cluster übergeben und in den CloudTrail-Protokollen angezeigt. Der Benutzername `john{{SessionName}}` ist beispielsweise nicht zulässig. Er müsste `:john{{SessionName}}` oder `jo:hn{{SessionName}}` lauten. Der Doppelpunkt muss sich nur vor `{{SessionName}}` befinden. Der von Amazon EKS generierte Benutzername in der folgenden Tabelle enthält einen ARN. Da ein ARN Doppelpunkte enthält, erfüllt er diese Anforderung. Der Doppelpunkt ist nicht erforderlich, wenn Sie `{{SessionName}}` nicht in Ihren Benutzernamen einschließen. Beachten Sie, dass in `{{SessionName}}` das Sonderzeichen „@“ im Sitzungsnamen durch „-“ ersetzt wird. `{{SessionNameRaw}}` behält alle Sonderzeichen im Sitzungsnamen bei.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/creating-access-entries.html)
Sie können den Benutzernamen ändern, nachdem der Zugriffseintrag erstellt wurde.
+ Wenn der Typ eines Zugriffseintrags `STANDARD` ist und Sie die Kubernetes-RBAC-Autorisierung verwenden möchten, können Sie dem Zugriffseintrag einen oder mehrere *Gruppennamen* hinzufügen. Gruppennamen können nach der Erstellung eines Zugriffseintrags hinzugefügt und entfernt werden. Damit der IAM-Prinzipal Zugriff auf Kubernetes-Objekte in Ihrem Cluster hat, müssen Sie rollenbasierte Autorisierungsobjekte (RBAC) für Kubernetes erstellen und verwalten. Erstellen Sie Kubernetes `RoleBinding` oder `ClusterRoleBinding`-Objekte in Ihrem Cluster, die den Gruppennamen als `subject` für `kind: Group` angeben. Kubernetes autorisiert den IAM-Prinzipalzugriff auf alle Cluster-Objekte, die Sie in einem Kubernetes `Role`- oder `ClusterRole`-Objekt angegeben haben, das Sie auch in der `roleRef` Ihrer Bindung angegeben haben. Wenn Sie Gruppennamen angeben, empfehlen wir Ihnen, sich mit den rollenbasierten Autorisierungsobjekten (RBAC) von Kubernetes vertraut zu machen. Weitere Informationen finden Sie unter [Using RBAC Authorization](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.
**Wichtig**
Amazon EKS überprüft nicht, ob die in Ihrem Cluster vorhandenen Kubernetes-RBAC-Objekte die von Ihnen angegebenen Gruppennamen enthalten. Wenn Sie beispielsweise einen Zugriffseintrag für eine Gruppe erstellen, die derzeit nicht vorhanden ist, erstellt EKS die Gruppe, anstatt eine Fehlermeldung auszugeben.
Anstelle oder zusätzlich zur Autorisierung des IAM-Prinzips für den Zugriff auf Kubernetes-Objekte in Ihrem Cluster durch Kubernetes können Sie Amazon-EKS-*Zugriffsrichtlinien* einem Zugriffseintrag zuordnen. Amazon EKS autorisiert für IAM-Prinzipale den Zugriff auf Kubernetes-Objekte in Ihrem Cluster mit den in der Zugriffsrichtlinie festgelegten Berechtigungen. Sie können die Berechtigungen einer Zugriffsrichtlinie auf von Ihnen angegebene Kubernetes-Namespaces beschränken. Für die Verwendung von Zugriffsrichtlinien ist keine Verwaltung von Kubernetes RBAC-Objekten erforderlich. Weitere Informationen finden Sie unter [Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen](access-policies.md).
+ Wenn Sie einen Zugriffseintrag mit dem Typ `EC2_LINUX` oder `EC2_Windows` erstellen, muss der IAM-Prinzipal, der den Zugriffseintrag erstellt, über die Berechtigung `iam:PassRole` verfügen. Weitere Informationen finden Sie unter [Erteilen von Berechtigungen, mit denen ein Benutzer eine Rolle an einen AWS-Service übergeben kann](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) im *IAM-Benutzerhandbuch*.
+ Ähnlich wie beim standardmäßigen [IAM-Verhalten](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_general.html#troubleshoot_general_eventual-consistency) sind die Erstellung und Aktualisierung von Zugriffseinträgen letztlich konsistent und es kann mehrere Sekunden dauern, bis sie wirksam werden, nachdem der erste API-Aufruf erfolgreich abgeschlossen wurde. Sie müssen Ihre Anwendungen unter Berücksichtigung dieser potenziellen Verzögerungen konzipieren. Es empfiehlt sich, in die kritischen, hochverfügbaren Code-Pfade Ihrer Anwendung keine Erstellungen oder Aktualisierungen von Zugriffseinträgen einzuschließen. Nehmen Sie -Änderungen stattdessen in einer separaten Initialisierungs- oder Einrichtungsroutine vor, die seltener ausgeführt wird. Vergewissern Sie sich auch, dass die Änderungen weitergegeben wurden, bevor die Produktionsarbeitsabläufe davon abhängen.
+ Zugriffseinträge unterstützen keine [serviceverknüpften Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html). Sie können keine Zugriffseinträge erstellen, bei denen die Haupt-ARN eine serviceverknüpfte Rolle ist. Sie können serviceverknüpfte Rollen anhand ihrer ARN im Format ` arn:aws:iam::*:role/aws-service-role/*` identifizieren.
Sie können einen Zugriffseintrag über die AWS-Managementkonsole oder mithilfe der AWS CLI erstellen.
## AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie den Namen des Clusters aus, in dem Sie einen Zugriffseintrag erstellen möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Wählen Sie **Zugriffseintrag erstellen** aus.
1. Wählen Sie unter **IAM-Prinzipal** eine bereits vorhandene IAM-Rolle oder einen bereits vorhandenen IAM-Benutzer aus. In den bewährten Methoden für IAM wird empfohlen, für den Zugriff auf Ihren Cluster IAM-*Rollen* mit kurzfristigen Anmeldeinformationen zu verwenden anstatt IAM-*Benutzer* mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie unter [Menschliche Benutzer auffordern, den Verbund mit einem Identitätsanbieter zu verwenden, um mit temporären Anmeldeinformationen auf AWS zuzugreifen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) im *IAM-Benutzerhandbuch*.
1. Wählen Sie unter **Typ** die Option **EC2 Linux** oder **EC2 Windows** aus, wenn sich der Zugriffseintrag auf die Knotenrolle bezieht, die für selbstverwaltete Amazon-EC2-Knoten verwendet wird. Übernehmen Sie andernfalls die Standardeinstellung (**Standard**).
1. Wenn Sie unter **Typ** die Option **Standard** ausgewählt haben, können Sie bei Bedarf unter **Benutzername** einen Benutzernamen angeben.
1. Wenn Sie unter **Typ** die Option **Standard** ausgewählt haben und die Kubernetes-RBAC-Autorisierung für den IAM-Prinzipal verwenden möchten, können Sie unter **Gruppen** einen oder mehrere Namen angeben. Wenn Sie keine Gruppennamen angeben und die Amazon-EKS-Autorisierung verwenden möchten, können Sie in einem späteren Schritt (oder nach der Erstellung des Zugriffseintrags) eine Zugriffsrichtlinie zuordnen.
1. (Optional) Weisen Sie dem Zugriffseintrag unter **Tags** Beschriftungen zu. So können Sie beispielsweise ganz einfach nach allen Ressourcen mit dem gleichen Tag suchen.
1. Wählen Sie **Weiter** aus.
1. Wenn Sie auf der Seite **Zugriffsrichtlinie hinzufügen** den Typ **Standard** ausgewählt haben und Amazon EKS dem IAM-Prinzipal Berechtigungen für die Kubernetes-Objekte in Ihrem Cluster gewähren soll, führen Sie die folgenden Schritte aus. Klicken Sie andernfalls auf **Next** (Weiter).
1. Wählen Sie unter **Richtlinienname** eine Zugriffsrichtlinie aus. Sie können die Berechtigungen der Zugriffsrichtlinien nicht anzeigen, sie enthalten jedoch ähnliche Berechtigungen wie die benutzerorientierten `ClusterRole`-Objekte von Kubernetes. Weitere Informationen finden Sie unter[Benutzerorientierte Rollen](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles) in der Kubernetes-Dokumentation.
1. Wählen Sie eine der folgenden Optionen:
+ **Cluster** – Wählen Sie diese Option aus, wenn Amazon EKS den IAM-Prinzipal so autorisieren soll, dass er für alle Kubernetes-Objekte in Ihrem Cluster über die in der Zugriffsrichtlinie festgelegten Berechtigungen verfügt.
+ **Kubernetes-Namespace** – Wählen Sie diese Option aus, wenn Amazon EKS den IAM-Prinzipal so autorisieren soll, dass er für alle Kubernetes-Objekte in einem spezifischen Kubernetes-Namespace Ihres Clusters über die in der Zugriffsrichtlinie festgelegten Berechtigungen verfügt. Geben Sie unter **Namespace** den Namen des Kubernetes-Namespace in Ihrem Cluster ein. Wenn Sie zusätzliche Namespaces hinzufügen möchten, wählen Sie **Neuen Namespace hinzufügen** aus und geben Sie den Namespace-Namen ein.
1. Wenn Sie weitere Richtlinien hinzufügen möchten, wählen Sie **Richtlinie hinzufügen** aus. Sie können für jede Richtlinie unterschiedliche Geltungsbereiche festlegen, aber jede Richtlinie kann nur einmal hinzugefügt werden.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie die Konfiguration für Ihren Zugriffseintrag. Sollten Sie einen Fehler entdecken, wählen Sie **Zurück** aus, um schrittweise zurück zu navigieren und den Fehler zu korrigieren. Ist die Konfiguration korrekt, wählen Sie **Erstellen** aus.
## AWS-CLI
1. Installieren Sie die AWS-CLI wie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle beschrieben.
1. Um einen Zugriffseintrag zu erstellen, können Sie eines der folgenden Beispiele verwenden:
+ Erstellen Sie einen Zugriffseintrag für eine selbstverwaltete Amazon-EC2-Linux-Knotengruppe. Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters, *111122223333* durch Ihre AWS-Konto-ID und *EKS-my-cluster-self-managed-ng-1* durch den Namen Ihrer [Knoten-IAM-Rolle](create-node-role.md). Wenn es sich bei Ihrer Knotengruppe um eine Windows-Knotengruppe handelt, ersetzen Sie *EC2\$1Linux* durch `EC2_Windows`.
```
aws eks create-access-entry --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/EKS-my-cluster-self-managed-ng-1 --type EC2_LINUX
```
Bei Angabe eines anderen Typs als `STANDARD` kann die Option `--kubernetes-groups` nicht verwendet werden. Sie können diesem Zugriffseintrag keine Zugriffsrichtlinie zuordnen, da der Typ nicht den Wert `STANDARD` hat.
+ Erstellen Sie einen Zugriffseintrag, der eine IAM-Rolle zulässt, die nicht für eine selbstverwaltete Amazon-EC2-Knotengruppe verwendet wird, mit der Kubernetes den Zugriff auf Ihren Cluster autorisieren soll. Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters, *111122223333* durch Ihre AWS-Konto-ID und *my-role* durch den Namen Ihrer IAM-Rolle. Ersetzen Sie *Betrachter* durch den Namen einer Gruppe, die Sie in Kubernetes `RoleBinding` oder einem `ClusterRoleBinding`-Objekt in Ihrem Cluster angegeben haben.
```
aws eks create-access-entry --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/my-role --type STANDARD --user Viewers --kubernetes-groups Viewers
```
+ Erstellen Sie einen Zugriffseintrag, der es einem IAM-Benutzer ermöglicht, sich bei Ihrem Cluster zu authentifizieren. Dieses Beispiel soll zeigen, dass es diese Möglichkeit gibt. In den bewährten Methoden für IAM wird empfohlen, für den Zugriff auf Ihren Cluster IAM-*Rollen* mit kurzfristigen Anmeldeinformationen zu verwenden anstatt IAM-*Benutzer* mit langfristigen Anmeldeinformationen. Weitere Informationen finden Sie unter [Menschliche Benutzer auffordern, den Verbund mit einem Identitätsanbieter zu verwenden, um mit temporären Anmeldeinformationen auf AWS zuzugreifen](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) im *IAM-Benutzerhandbuch*.
```
aws eks create-access-entry --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:user/my-user --type STANDARD --username my-user
```
Wenn dieser Benutzer mehr Zugriff auf Ihren Cluster haben soll als ihm durch die Berechtigungen in den Kubernetes-API-Erkennungsrollen gewährt wird, müssen Sie dem Zugriffseintrag eine Zugriffsrichtlinie zuordnen, da die Option `--kubernetes-groups` nicht verwendet wird. Weitere Informationen finden Sie unter [Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen](access-policies.md) und [API-Erkennungsrollen](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#discovery-roles) in der Kubernetes-Dokumentation.
# Zugriffseinträge aktualisieren
Sie können einen Zugriffseintrag über die AWS-Managementkonsole oder mithilfe der AWS-CLI aktualisieren.
## AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie den Namen des Clusters aus, in dem Sie einen Zugriffseintrag erstellen möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Wählen Sie den Zugriffseintrag aus, den Sie aktualisieren möchten.
1. Wählen Sie **Bearbeiten** aus.
1. Unter **Benutzername** können Sie den vorhandenen Wert ändern.
1. Unter **Gruppen** können Sie Gruppennamen entfernen oder neue Gruppennamen hinzufügen. Die Gruppennamen **system:nodes** und **system:bootstrappers** dürfen nicht entfernt werden, sofern vorhanden. Wenn Sie diese Gruppen entfernen, funktioniert Ihr Cluster unter Umständen nicht mehr ordnungsgemäß. Wenn Sie keine Gruppennamen angeben und die Amazon-EKS-Autorisierung verwenden möchten, ordnen Sie in einem späteren Schritt eine [Zugriffsrichtlinie](access-policies.md) zu.
1. Unter **Tags** können Sie dem Zugriffseintrag Beschriftungen zuweisen. So können Sie beispielsweise ganz einfach nach allen Ressourcen mit dem gleichen Tag suchen. Außerdem können Sie vorhandene Tags entfernen.
1. Wählen Sie **Änderungen speichern ** aus.
1. Informationen zum Zuordnen einer Zugriffsrichtlinie zu dem Eintrag finden Sie unter [Zugriffsrichtlinien mit Zugriffseinträgen verknüpfen](access-policies.md).
## AWS-CLI
1. Installieren Sie die AWS-CLI wie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle beschrieben.
1. Um einen Zugriffseintrag zu aktualisieren, ersetzen Sie *my-cluster* durch den Namen Ihres Clusters, *111122223333* durch Ihre AWS-Konto-ID und *EKS-my-cluster-my-namespace-Viewers* durch den Namen einer IAM-Rolle.
```
aws eks update-access-entry --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/EKS-my-cluster-my-namespace-Viewers --kubernetes-groups Viewers
```
Die Option `--kubernetes-groups` kann nur verwendet werden, wenn der Zugriffseintrag den Typ `STANDARD` hat. Auch kann eine Zugriffsrichtlinie nur einem Zugriffseintrag mit dem Typ `STANDARD` zugeordnet werden.
# Zugriffseinträge löschen
Wenn Sie einen Zugriffseintrag versehentlich gelöscht haben, können Sie ihn jederzeit erneut erstellen. Wenn dem zu löschenden Zugriffseintrag Zugriffsrichtlinien zugeordnet sind, werden die Zuordnungen automatisch gelöscht. Es ist nicht erforderlich, die Zuordnung von Zugriffsrichtlinien zu einem Zugriffseintrag vor dem Löschen aufzuheben.
Sie können einen Zugriffseintrag über die AWS-Managementkonsole oder mithilfe der AWS-CLI löschen.
## AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie den Namen des Clusters aus, aus dem Sie einen Zugriffseintrag löschen möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Wählen Sie in der Liste **Zugriffseinträge** den Zugriffseintrag aus, den Sie löschen möchten.
1. Wählen Sie Delete.
1. Wählen Sie im Bestätigungs-Dialogfeld die Option **Delete** (Löschen).
## AWS-CLI
1. Installieren Sie die AWS-CLI wie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) im Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle beschrieben.
1. Um einen Zugriffseintrag zu löschen, ersetzen Sie *my-cluster* durch den Namen Ihres Clusters, *111122223333* durch Ihre AWS-ID und *my-role* durch den Namen der IAM-Rolle, die keinen Zugriff mehr auf Ihren Cluster haben soll.
```
aws eks delete-access-entry --cluster-name my-cluster --principal-arn arn:aws:iam::111122223333:role/my-role
```
# Festlegen eines benutzerdefinierten Benutzernamens für EKS-Zugriffseinträge
Beim Erstellen von Zugriffseinträgen für Amazon EKS können Sie entweder den automatisch generierten Benutzernamen verwenden oder einen benutzerdefinierten Benutzernamen angeben. Auf dieser Seite werden beide Optionen erläutert und Sie werden durch die Einrichtung eines benutzerdefinierten Benutzernamens geführt.
## -Übersicht
Der Benutzername in einem Zugriffseintrag wird verwendet, um den IAM-Prinzipal in Kubernetes-Protokollen und Prüfpfaden zu identifizieren. Standardmäßig generiert Amazon EKS einen Benutzernamen basierend auf der ARN der IAM-Identität. Sie können bei Bedarf jedoch einen benutzerdefinierten Benutzernamen angeben.
## Generierung des Standard-Benutzernamens
Wenn Sie keinen Wert für den Benutzernamen angeben, generiert Amazon EKS automatisch einen Benutzernamen basierend auf der IAM-Identität:
+ **Für IAM-Benutzer**:
+ EKS legt den Kubernetes-Benutzernamen auf die ARN des IAM-Benutzers fest
+ Beispiel:
```
{arn-aws}iam::<111122223333>:user/
```
+ **Für IAM-Rollen**:
+ EKS legt den Kubernetes-Benutzernamen basierend auf der ARN der IAM-Rolle fest
+ Der STS-ARN der Rolle, wenn sie angenommen wird. Amazon EKS fügt am Ende der Rolle `{{SessionName}}` hinzu. Wenn der ARN der von Ihnen angegebenen Rolle einen Pfad enthalten hat, wird dieser von Amazon EKS im generierten Benutzernamen entfernt.
+ Beispiel:
```
{arn-aws}sts::<111122223333>:assumed-role//{{SessionName}}
```
Sofern Sie keinen bestimmten Grund haben, Ihren eigenen Benutzernamen anzugeben, empfehlen wir Ihnen, keinen anzugeben und ihn von Amazon EKS automatisch für Sie generieren zu lassen.
## Festlegen eines benutzerdefinierten Benutzernamens
Beim Erstellen eines Zugriffseintrags können Sie mithilfe des `--username`-Parameters einen benutzerdefinierten Benutzernamen angeben:
```
aws eks create-access-entry --cluster-name --principal-arn --type STANDARD --username
```
### Anforderungen für benutzerdefinierte Benutzernamen
Wenn Sie einen benutzerdefinierten Benutzernamen angeben:
+ Der Benutzername darf nicht mit `system:`, `eks:`, `aws:`, `amazon:` oder `iam:` beginnen.
+ Bei einem Benutzername für eine IAM-Rolle empfiehlt es sich, am Ende des Benutzernamens `{{SessionName}}` oder `{{SessionNameRaw}}` hinzuzufügen.
+ Wenn Sie Ihrem Benutzernamen eines `{{SessionName}}` oder `{{SessionNameRaw}}` hinzufügen, muss der Benutzername einen Doppelpunkt *vor* \$1\$1SessionName\$1\$1 enthalten.
# Erstellen Sie mithilfe einer Zugriffsrichtlinie und der AWS-CLI einen Zugriffseintrag für eine IAM-Rolle oder einen IAM-Benutzer
Erstellen Sie Amazon-EKS-Zugriffseinträge, die von AWS verwaltete EKS-Zugriffsrichtlinien verwenden, um IAM-Identitäten standardisierte Berechtigungen für den Zugriff auf und die Verwaltung von Kubernetes-Clustern zu gewähren.
## Übersicht
Zugriffseinträge in Amazon EKS legen fest, wie IAM-Identitäten (Benutzer und Rollen) auf Ihre Kubernetes-Cluster zugreifen und mit diesen interagieren können. Durch die Erstellung von Zugriffseinträgen mit EKS-Zugriffsrichtlinien können Sie:
+ Bestimmten IAM-Benutzern oder -Rollen die Berechtigung zum Zugriff auf Ihren EKS-Cluster gewähren
+ Berechtigungen mithilfe von AWS-verwalteten EKS-Zugriffsrichtlinien steuern, die standardisierte, vordefinierte Berechtigungssätze bieten
+ Berechtigungen auf bestimmte Namespaces oder clusterweit beschränken
+ Zugriffsverwaltung vereinfachen, ohne die `aws-auth` ConfigMap zu ändern oder Kubernetes-RBAC-Ressourcen zu erstellen
+ AWS-integrierten Ansatz für die Kubernetes-Zugriffskontrolle verwenden, der gängige Anwendungsfälle abdeckt und gleichzeitig bewährte Sicherheitsmethoden einhält
Dieser Ansatz wird für die meisten Anwendungsfälle empfohlen, da er von AWS verwaltete, standardisierte Berechtigungen bietet, ohne dass eine manuelle Kubernetes-RBAC-Konfiguration erforderlich ist. EKS-Zugriffsrichtlinien machen die manuelle Konfiguration von Kubernetes-RBAC-Ressourcen überflüssig und bieten vordefinierte Berechtigungssätze, die gängige Anwendungsfälle abdecken.
## Voraussetzungen
+ Der *Authentifizierungsmodus* Ihres Clusters muss konfiguriert sein, um *Zugriffseinträge* zu ermöglichen. Weitere Informationen finden Sie unter [Ändern des Authentifizierungsmodus, um Zugriffseinträge zu verwenden](setting-up-access-entries.md).
+ Installieren und konfigurieren Sie die AWS CLI wie im Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle unter [Installieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) beschrieben.
## Schritt 1: Zugriffseintrag definieren
1. Suchen Sie die ARN der IAM-Identität, z. B. eines Benutzers oder einer Rolle, der Sie Berechtigungen gewähren möchten.
+ Jede IAM-Identität kann nur einen EKS-Zugriffseintrag haben.
1. Legen Sie fest, ob die Berechtigungen der Amazon-EKS-Zugriffsrichtlinie nur für einen bestimmten Kubernetes-Namespace oder für den gesamten Cluster gelten sollen.
+ Wenn Sie die Berechtigungen auf einen bestimmten Namespace beschränken möchten, notieren Sie sich den Namen des Namespace.
1. Wählen Sie die gewünschte EKS-Zugriffsrichtlinie für die IAM-Identität aus. Diese Richtlinie gewährt Berechtigungen innerhalb des Clusters. Notieren Sie sich die ARN der Richtlinie.
+ Eine Liste der Richtlinien finden Sie unter [Verfügbare Zugriffsrichtlinien](access-policy-permissions.md).
1. Prüfen Sie, ob der automatisch generierte Benutzername für den Zugriffseintrag geeignet ist oder ob Sie einen Benutzernamen manuell angeben müssen.
+ AWS generiert diesen Wert automatisch basierend auf der IAM-Identität. Sie können einen benutzerdefinierten Benutzernamen festlegen. Dieser wird in den Kubernetes-Protokollen angezeigt.
+ Weitere Informationen finden Sie unter [Festlegen eines benutzerdefinierten Benutzernamens für EKS-Zugriffseinträge](set-custom-username.md).
## Schritt 2: Zugriffseintrag erstellen
Nachdem Sie den Zugriffseintrag geplant haben, erstellen Sie ihn mithilfe der AWS-CLI.
Das folgende Beispiel deckt die meisten Anwendungsfälle ab. [Sehen Sie sich die CLI-Referenz für alle Konfigurationsoptionen an](https://docs.aws.amazon.com/cli/latest/reference/eks/create-access-entry.html).
Im nächsten Schritt fügen Sie die Zugriffsrichtlinie hinzu.
```
aws eks create-access-entry --cluster-name --principal-arn --type STANDARD
```
## Schritt 3: Zugriffsrichtlinie zuordnen
Der Befehl unterscheidet sich je nachdem, ob Sie die Richtlinie auf einen bestimmten Kubernetes-Namespace beschränken möchten.
Sie benötigen die ARN der Zugriffsrichtlinie. Überprüfen Sie die [verfügbaren Zugriffsrichtlinien](access-policy-permissions.md).
### Erstellung einer Richtlinie ohne Namespace-Gültigkeitsbereich
```
aws eks associate-access-policy --cluster-name --principal-arn --policy-arn
```
### Mit Namespace-Gültigkeitsbereich erstellen
```
aws eks associate-access-policy --cluster-name --principal-arn \
--access-scope type=namespace,namespaces=my-namespace1,my-namespace2 --policy-arn
```
## Nächste Schritte
+ [Erstellung einer kubeconfig für die Verwendung von kubectl mit einer IAM-Identität](create-kubeconfig.md)
# Erstellung eines Zugriffseintrags mithilfe von Kubernetes-Gruppen über die AWS CLI
Erstellen Sie Amazon-EKS-Zugriffseinträge, die Kubernetes-Gruppen zur Autorisierung verwenden und eine manuelle RBAC-Konfiguration erfordern.
**Anmerkung**
Für die meisten Anwendungsfälle empfehlen wir die Verwendung von EKS-Zugriffsrichtlinien anstelle des auf dieser Seite beschriebenen Ansatzes mit Kubernetes-Gruppen. EKS-Zugriffsrichtlinien bieten eine einfachere, besser in AWS integrierte Möglichkeit zur Zugriffsverwaltung ohne manuelle RBAC-Konfiguration. Verwenden Sie den Kubernetes-Gruppenansatz nur, wenn Sie eine detailliertere Steuerung benötigen, als die EKS-Zugriffsrichtlinien bieten.
## Übersicht
Zugriffseinträge definieren, wie IAM-Identitäten (Benutzer und Rollen) auf Ihre Kubernetes-Cluster zugreifen. Der Kubernetes-Gruppenansatz gewährt IAM-Benutzern oder -Rollen die Berechtigung, über standardmäßige Kubernetes-RBAC-Gruppen auf Ihren EKS-Cluster zuzugreifen. Diese Methode erfordert die Erstellung und Verwaltung von Kubernetes-RBAC-Ressourcen (Roles, RoleBindings, ClusterRoles und ClusterRoleBindings). Sie wird empfohlen, wenn Sie stark angepasste Berechtigungssätze und komplexe Autorisierungsanforderungen benötigen oder konsistente Zugriffskontrollmuster in hybriden Kubernetes-Umgebungen beibehalten möchten.
Dieses Thema behandelt nicht das Erstellen von Zugriffseinträgen für IAM-Identitäten, die für Amazon-EC2-Instances zum Beitritt zu EKS-Clustern verwendet werden.
## Voraussetzungen
+ Der *Authentifizierungsmodus* Ihres Clusters muss konfiguriert sein, um *Zugriffseinträge* zu ermöglichen. Weitere Informationen finden Sie unter [Ändern des Authentifizierungsmodus, um Zugriffseinträge zu verwenden](setting-up-access-entries.md).
+ Installieren und konfigurieren Sie die AWS CLI wie im Benutzerhandbuch zur AWS-Befehlszeilenschnittstelle unter [Installieren](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) beschrieben.
+ Vertrautheit mit Kubernetes RBAC wird empfohlen. Weitere Informationen finden Sie unter [Using RBAC Authorization](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.
## Schritt 1: Zugriffseintrag definieren
1. Suchen Sie die ARN der IAM-Identität, beispielsweise eines Benutzers oder einer Rolle, der bzw. der Sie Berechtigungen gewähren möchten.
+ Jede IAM-Identität kann nur einen EKS-Zugriffseintrag haben.
1. Legen Sie fest, welche Kubernetes-Gruppen Sie dieser IAM-Identität zuordnen möchten.
+ Sie müssen vorhandene Kubernetes-`Role`/`ClusterRole` und `RoleBinding`/`ClusterRoleBinding`-Ressourcen erstellen oder verwenden, die auf diese Gruppen verweisen.
1. Prüfen Sie, ob der automatisch generierte Benutzername für den Zugriffseintrag geeignet ist oder ob Sie einen Benutzernamen manuell angeben müssen.
+ AWS generiert diesen Wert automatisch basierend auf der IAM-Identität. Sie können einen benutzerdefinierten Benutzernamen festlegen. Dieser wird in den Kubernetes-Protokollen angezeigt.
+ Weitere Informationen finden Sie unter [Festlegen eines benutzerdefinierten Benutzernamens für EKS-Zugriffseinträge](set-custom-username.md).
## Schritt 2: Zugriffseintrag mit Kubernetes-Gruppen erstellen
Nachdem Sie den Zugriffseintrag geplant haben, erstellen Sie ihn mithilfe der AWS CLI mit den entsprechenden Kubernetes-Gruppen.
```
aws eks create-access-entry --cluster-name --principal-arn --type STANDARD --kubernetes-groups
```
Ersetzen Sie:
+ `` durch den Namen Ihres EKS-Clusters
+ `` durch die ARN des IAM-Benutzers oder der IAM-Rolle
+ `` durch eine durch Kommas getrennte Liste von Kubernetes-Gruppen (z. B. „system:developers,system:readers“).
[Sehen Sie sich die CLI-Referenz für alle Konfigurationsoptionen an](https://docs.aws.amazon.com/cli/latest/reference/eks/create-access-entry.html).
## Schritt 3: Kubernetes-RBAC konfigurieren
Damit der IAM-Prinzipal Zugriff auf Kubernetes-Objekte in Ihrem Cluster hat, müssen Sie rollenbasierte Zugriffskontrollobjekte (RBAC) für Kubernetes erstellen und verwalten:
1. Erstellen Sie Kubernetes `Role` oder `ClusterRole`-Objekte, welche die Berechtigungen definieren.
1. Erstellen Sie Kubernetes `RoleBinding` oder `ClusterRoleBinding`-Objekte in Ihrem Cluster, die den Gruppennamen als `subject` für `kind: Group` angeben.
Ausführliche Informationen zum Konfigurieren von Gruppen und Berechtigungen in Kubernetes finden Sie unter [Verwendung der RBAC-Autorisierung](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.
## Nächste Schritte
+ [Erstellung einer kubeconfig für die Verwendung von kubectl mit einer IAM-Identität](create-kubeconfig.md)