

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

# Gewähren Sie IAM-Benutzern Zugriff auf Kubernetes mit einem ConfigMap
<a name="auth-configmap"></a>

**Wichtig**  
Der `aws-auth ConfigMap` ist veraltet. Die empfohlene Methode zur Verwaltung des Zugriffs auf Kubernetes finden Sie unter. APIs [IAM-Benutzern mit EKS-Zugriffseinträgen Zugriff auf Kubernetes gewähren](access-entries.md)

Zugriff auf Ihren Cluster mit einem [IAM-Prinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) wird durch [AWS IAM Authenticator für Kubernetes](https://github.com/kubernetes-sigs/aws-iam-authenticator#readme) aktiviert, das in der Amazon-EKS-Steuerebene ausgeführt wird. Der Authenticator erhält seine Konfigurationsinformationen von `aws-auth` `ConfigMap`. Alle `aws-auth` `ConfigMap`-Einstellungen finden Sie unter [Vollständiges Konfigurationsformat](https://github.com/kubernetes-sigs/aws-iam-authenticator#full-configuration-format) auf GitHub.

## Hinzufügen von IAM-Prinzipal zu Ihrem Amazon EKS-Cluster
<a name="aws-auth-users"></a>

Wenn Sie einen Amazon-EKS-Cluster erstellen, werden dem [IAM-Prinzipal](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal), der den Cluster erstellt, automatisch `system:masters`-Berechtigungen in der rollenbasierten Konfiguration für Zugriffskontrolle (RBAC) des Clusters in der Amazon-EKS-Steuerebene gewährt. Dieser Prinzipal wird in keiner sichtbaren Konfiguration angezeigt. Achten Sie daher darauf, welcher Prinzipal den Cluster ursprünglich erstellt hat. Um zusätzlichen IAM-Prinzipalen die Möglichkeit zu geben, mit Ihrem Cluster zu interagieren, bearbeiten Sie den `aws-auth ConfigMap` in Kubernetes und erstellen Sie ein Kubernetes-`rolebinding` oder -`clusterrolebinding` mit dem Namen eines `group`, das Sie im `aws-auth ConfigMap` angeben.

**Anmerkung**  
Weitere Informationen zur Konfiguration der rollenbasierten Zugriffskontrolle (RBAC) von Kubernetes finden Sie unter [Verwendung der RBAC-Autorisierung](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.

1. Bestimmen Sie, welche Anmeldeinformationen `kubectl` für den Zugriff auf Ihren Cluster verwendet. Amazon Resource Name (ARN)Auf Ihrem Computer können Sie mit dem folgenden Befehl sehen, welche Anmeldeinformationen `kubectl` verwendet. *\$1/.kube/config*Ersetzen Sie ihn durch den Pfad zu Ihrer `kubeconfig` Datei, wenn Sie nicht den Standardpfad verwenden.

   ```
   cat ~/.kube/config
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   [...]
   contexts:
   - context:
       cluster: my-cluster.region-code.eksctl.io
       user: admin@my-cluster.region-code.eksctl.io
     name: admin@my-cluster.region-code.eksctl.io
   current-context: admin@my-cluster.region-code.eksctl.io
   [...]
   ```

   In der vorherigen Beispielausgabe werden die Anmeldeinformationen für einen Benutzer mit dem Namen *admin* für einen Cluster mit dem Namen *my-cluster* konfiguriert. Wenn dies der Benutzer ist, der den Cluster erstellt hat, hat er bereits Zugriff auf Ihren Cluster. Wenn es nicht der Benutzer ist, der den Cluster erstellt hat, müssen Sie die verbleibenden Schritte ausführen, um den Cluster-Zugriff für andere IAM-Prinzipale zu aktivieren. [Bewährte Methoden für IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) empfehlen, dass Sie Rollen statt Benutzern Berechtigungen gewähren. Mit dem folgenden Befehl können Sie sehen, welche anderen Prinzipale derzeit Zugriff auf Ihren Cluster haben:

   ```
   kubectl describe -n kube-system configmap/aws-auth
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   Name:         aws-auth
   Namespace:    kube-system
   Labels:       <none>
   Annotations:  <none>
   
   Data
   ====
   mapRoles:
   ----
   - groups:
     - system:bootstrappers
     - system:nodes
     rolearn: arn:aws: iam::111122223333:role/my-node-role
     username: system:node:{{EC2PrivateDNSName}}
   
   
   BinaryData
   ====
   
   Events:  <none>
   ```

   Das vorherige Beispiel ist eine standardmäßige `aws-auth`-`ConfigMap`. Nur die Knoten-Instance-Rolle hat Zugriff auf den Cluster.

1. Stellen Sie sicher, dass `roles` und `rolebindings` oder `clusterroles` und `clusterrolebindings` vorhanden sind, denen Sie IAM-Prinzipale zuordnen können. Weitere Informationen über diese Ressourcen finden Sie unter [RBAC-Autorisierung verwenden](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) in der Kubernetes-Dokumentation.

   1. Zeigen Sie Ihre vorhandenen Kubernetes `roles` oder `clusterroles` an. `Roles` sind auf einen `namespace` ausgelegt, aber `clusterroles` sind auf den Cluster ausgelegt.

      ```
      kubectl get roles -A
      ```

      ```
      kubectl get clusterroles
      ```

   1. Zeigen Sie die Details einer beliebigen `role` oder `clusterrole` an, die in der vorherigen Ausgabe zurückgegeben wurden, und bestätigen Sie, dass Sie die Berechtigungen (`rules`) hat, die Ihre IAM-Prinzipale in Ihrem Cluster haben sollen.

      Ersetzen Sie *role-name* durch einen `role`-Namen, den der vorherige Befehl zurückgegeben hat. Ersetzen Sie *kube-system* durch den Namespace der `role`.

      ```
      kubectl describe role role-name -n kube-system
      ```

      Ersetzen Sie *cluster-role-name* durch einen `clusterrole`-Namen, den der vorherige Befehl zurückgegeben hat.

      ```
      kubectl describe clusterrole cluster-role-name
      ```

   1. Zeigen Sie Ihre vorhandenen Kubernetes `rolebindings` oder `clusterrolebindings` an. `Rolebindings` sind auf einen `namespace` ausgelegt, aber `clusterrolebindings` sind auf den Cluster ausgelegt.

      ```
      kubectl get rolebindings -A
      ```

      ```
      kubectl get clusterrolebindings
      ```

   1. Zeigen Sie die Details einer beliebigen `rolebinding` oder `clusterrolebinding` an und bestätigen Sie, dass sie eine `role` oder `clusterrole` aus dem vorherigen Schritt hat, die als `roleRef` aufgeführt wird, und einen Gruppennamen, der für `subjects` aufgeführt wird.

      Ersetzen Sie *role-binding-name* durch einen `rolebinding`-Namen, den der vorherige Befehl zurückgegeben hat. Ersetzen SIe *kube-system* mit dem `namespace` der `rolebinding`.

      ```
      kubectl describe rolebinding role-binding-name -n kube-system
      ```

      Eine Beispielausgabe sieht wie folgt aus.

      ```
      apiVersion: rbac.authorization.k8s.io/v1
      kind: RoleBinding
      metadata:
        name: eks-console-dashboard-restricted-access-role-binding
        namespace: default
      subjects:
      - kind: Group
        name: eks-console-dashboard-restricted-access-group
        apiGroup: rbac.authorization.k8s.io
      roleRef:
        kind: Role
        name: eks-console-dashboard-restricted-access-role
        apiGroup: rbac.authorization.k8s.io
      ```

      Ersetzen Sie *cluster-role-binding-name* durch einen `clusterrolebinding`-Namen, den der vorherige Befehl zurückgegeben hat.

      ```
      kubectl describe clusterrolebinding cluster-role-binding-name
      ```

      Eine Beispielausgabe sieht wie folgt aus.

      ```
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: eks-console-dashboard-full-access-binding
      subjects:
      - kind: Group
        name: eks-console-dashboard-full-access-group
        apiGroup: rbac.authorization.k8s.io
      roleRef:
        kind: ClusterRole
        name: eks-console-dashboard-full-access-clusterrole
        apiGroup: rbac.authorization.k8s.io
      ```

1. Bearbeiten Sie die `aws-auth`-`ConfigMap`. Sie können ein Tool wie `eksctl` verwenden, um die `ConfigMap` zu aktualisieren, oder Sie können sie durch manuelle Bearbeitung aktualisieren.
**Wichtig**  
Wir empfehlen die Verwendung von `eksctl` oder einem anderen Tool, um die `ConfigMap` zu bearbeiten. Informationen zu anderen Tools, die Sie verwenden können, finden Sie unter [Use tools to make changes to the aws- authConfigMap](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#use-tools-to-make-changes-to-the-aws-auth-configmap) in den Amazon EKS-Best-Practices-Leitfäden. Ist `aws-auth`-`ConfigMap` falsch formatiert, können Sie den Zugriff auf Ihren Cluster verlieren.
   + Schritte zum [Bearbeiten der Konfigurationszuordnung mit eksctl](#configmap-eksctl) anzeigen.
   + Schritte zum [manuellen Bearbeiten der Konfigurationszuordnung](#configmap-manual) anzeigen.

### Configmap mit Eksctl bearbeiten
<a name="configmap-eksctl"></a>

1. Sie benötigen eine Version `0.215.0` oder eine neuere Version des `eksctl` Befehlszeilentools, das auf Ihrem Gerät installiert ist oder AWS CloudShell. Informationen zum Installieren und Aktualisieren von `eksctl` finden Sie in der Dokumentation zu `eksctl` unter [Installation](https://eksctl.io/installation).

1. Zeigen Sie die aktuellen Mappings in der `ConfigMap` an. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters. *region-code*Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet.

   ```
   eksctl get iamidentitymapping --cluster my-cluster --region=region-code
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   ARN                                                                                             USERNAME                                GROUPS                          ACCOUNT
   arn:aws: iam::111122223333:role/eksctl-my-cluster-my-nodegroup-NodeInstanceRole-1XLS7754U3ZPA    system:node:{{EC2PrivateDNSName}}       system:bootstrappers,system:nodes
   ```

1. Fügen Sie ein Mapping für eine Rolle hinzu. Ersetzen Sie *my-role* durch den Namen Ihrer Rolle. *eks-console-dashboard-full-access-group*Ersetzen Sie durch den Namen der Gruppe, die in Ihrem Kubernetes `RoleBinding` oder `ClusterRoleBinding` Objekt angegeben ist. Ersetzen Sie *111122223333* durch Ihre Konto-ID. Sie können *admin* mit einem beliebigen Namen ersetzen, den Sie wählen.

   ```
   eksctl create iamidentitymapping --cluster my-cluster --region=region-code \
       --arn arn:aws: iam::111122223333:role/my-role --username admin --group eks-console-dashboard-full-access-group \
       --no-duplicate-arns
   ```
**Wichtig**  
Der Rollen-ARN darf keinen Pfad wie `role/my-team/developers/my-role` enthalten. Das Format des ARN muss ` arn:aws: iam::111122223333:role/my-role ` sein. In diesem Beispiel muss `my-team/developers/` entfernt werden.

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   [...]
   2022-05-09 14:51:20 [ℹ]  adding identity "{arn-aws}iam::111122223333:role/my-role" to auth ConfigMap
   ```

1. Fügen Sie ein Mapping für einen Benutzer hinzu. [Bewährte Methoden für IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) empfehlen, dass Sie Rollen statt Benutzern Berechtigungen gewähren. Ersetzen Sie *my-user* durch den Benutzernamen. *eks-console-dashboard-restricted-access-group*Ersetzen Sie es durch den Namen der Gruppe, die in Ihrem `RoleBinding` Kubernetes oder Objekt angegeben ist. `ClusterRoleBinding` Ersetzen Sie *111122223333* durch Ihre Konto-ID. Sie können *my-user* mit einem beliebigen Namen ersetzen, den Sie wählen.

   ```
   eksctl create iamidentitymapping --cluster my-cluster --region=region-code \
       --arn arn:aws: iam::111122223333:user/my-user --username my-user --group eks-console-dashboard-restricted-access-group \
       --no-duplicate-arns
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   [...]
   2022-05-09 14:53:48 [ℹ]  adding identity "arn:aws: iam::111122223333:user/my-user" to auth ConfigMap
   ```

1. Zeigen Sie wieder die Mappings in der `ConfigMap` an.

   ```
   eksctl get iamidentitymapping --cluster my-cluster --region=region-code
   ```

   Eine Beispielausgabe sieht wie folgt aus.

   ```
   ARN                                                                                             USERNAME                                GROUPS                                  ACCOUNT
   arn:aws: iam::111122223333:role/eksctl-my-cluster-my-nodegroup-NodeInstanceRole-1XLS7754U3ZPA    system:node:{{EC2PrivateDNSName}}       system:bootstrappers,system:nodes
   arn:aws: iam::111122223333:role/admin                                                            my-role                                 eks-console-dashboard-full-access-group
   arn:aws: iam::111122223333:user/my-user                                                          my-user                                 eks-console-dashboard-restricted-access-group
   ```

### Configmap manuell bearbeiten
<a name="configmap-manual"></a>

1. Öffnen Sie `ConfigMap` zum Bearbeiten.

   ```
   kubectl edit -n kube-system configmap/aws-auth
   ```
**Anmerkung**  
Wenn Sie eine Fehlermeldung mit der Angabe "`Error from server (NotFound): configmaps "aws-auth" not found`" erhalten, wenden Sie das Verfahren unter [AWS-Auth auf Ihren Cluster anwenden ConfigMap an, um den](#aws-auth-configmap) Bestand anzuwenden. `ConfigMap`

1. Fügen Sie Ihre IAM-Prinzipale zu der `ConfigMap` hinzu. Eine IAM-Gruppe ist kein IAM-Prinzipal und kann daher nicht zu `ConfigMap` hinzugefügt werden.
   +  **So fügen Sie eine IAM-Rolle hinzu (z. B. für [Verbundbenutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html)):** Fügen Sie die Rollendetails zum Abschnitt `mapRoles` der `ConfigMap` unter `data` hinzu. Fügen Sie diesen Abschnitt hinzu, wenn er nicht bereits in der Datei vorhanden sind. Jeder Eintrag unterstützt die folgenden Parameter:
     +  **rolearn**: Der ARN der IAM-Rolle, den Sie hinzufügen möchten. Dieser Wert darf keinen Pfad enthalten. Sie können beispielsweise keinen ARN wie ` arn:aws: iam::111122223333:role/my-team/developers/role-name ` angeben. Der ARN muss stattdessen ` arn:aws: iam::111122223333:role/role-name ` sein.
     +  **username**: Der Benutzername in Kubernetes für die Zuweisung zur IAM-Rolle. 
     +  **Gruppen**: Die Gruppe oder Liste der Kubernetes-Gruppen, denen die Rolle zugeordnet werden soll. Die Gruppe kann eine Standardgruppe oder eine Gruppe sein, die in einer `clusterrolebinding` oder `rolebinding` angegeben ist. Weitere Informationen finden Sie unter [Standardrollen und Rollenbindungen](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#default-roles-and-role-bindings) in der Kubernetes-Dokumentation.
   +  **Um einen IAM-Benutzer hinzuzufügen:** [Bewährte Methoden von IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) empfehlen, dass Sie Rollen statt Benutzern Berechtigungen gewähren. Fügen Sie die Benutzerdetails zum `mapUsers`-Abschnitt der `ConfigMap` unter `data` hinzu. Fügen Sie diesen Abschnitt hinzu, wenn er nicht bereits in der Datei vorhanden sind. Jeder Eintrag unterstützt die folgenden Parameter:
     +  **userarn**: Die ARN des IAM-Benutzers, den Sie hinzufügen möchten.
     +  **username**: Der Benutzername in Kubernetes für die Zuweisung zum IAM-Benutzer.
     +  **Gruppen**: Die Gruppe oder Liste der Kubernetes-Gruppen, denen der Benutzer zugeordnet werden soll. Die Gruppe kann eine Standardgruppe oder eine Gruppe sein, die in einer `clusterrolebinding` oder `rolebinding` angegeben ist. Weitere Informationen finden Sie unter [Standardrollen und Rollenbindungen](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#default-roles-and-role-bindings) in der Kubernetes-Dokumentation.

1. Beispiel: Der folgende YAML-Block enthält:
   + Einen `mapRoles`-Abschnitt, der die IAM-Knoten-Instance Kubernetes-Gruppen zuordnet, sodass sich Knoten selbst bei dem Cluster und der `my-console-viewer-role`-IAM-Rolle registrieren können, die einer Kubernetes-Gruppe zugeordnet ist, die alle Kubernetes-Ressourcen für alle Cluster anzeigen kann. Eine Liste der erforderlichen IAM- und Kubernetes-Gruppenberechtigungen für die `my-console-viewer-role`-IAM-Rolle finden Sie unter [Erforderliche Berechtigungen](view-kubernetes-resources.md#view-kubernetes-resources-permissions).
   + Ein `mapUsers` Abschnitt, der den `admin` IAM-Benutzer aus dem AWS Standardkonto der `system:masters` Kubernetes-Gruppe und den `my-user` Benutzer aus einem anderen AWS Konto zuordnet, das einer Kubernetes-Gruppe zugeordnet ist, die Kubernetes-Ressourcen für einen bestimmten Namespace anzeigen kann. Eine Liste der erforderlichen IAM- und Kubernetes-Gruppenberechtigungen für die `my-user`-IAM-Benutzer finden Sie unter [Erforderliche Berechtigungen](view-kubernetes-resources.md#view-kubernetes-resources-permissions).

     Fügen Sie nach Bedarf Zeilen hinzu oder entfernen Sie sie und ersetzen Sie alle Beispielwerte durch Ihre eigenen Werte.

     ```
     # Please edit the object below. Lines beginning with a '#' will be ignored,
     # and an empty file will abort the edit. If an error occurs while saving this file will be
     # reopened with the relevant failures.
     #
     apiVersion: v1
     data:
       mapRoles: |
         - groups:
           - system:bootstrappers
           - system:nodes
           rolearn: arn:aws: iam::111122223333:role/my-role
           username: system:node:{{EC2PrivateDNSName}}
         - groups:
           - eks-console-dashboard-full-access-group
           rolearn: arn:aws: iam::111122223333:role/my-console-viewer-role
           username: my-console-viewer-role
       mapUsers: |
         - groups:
           - system:masters
           userarn: arn:aws: iam::111122223333:user/admin
           username: admin
         - groups:
           - eks-console-dashboard-restricted-access-group
           userarn: arn:aws: iam::444455556666:user/my-user
           username: my-user
     ```

1. Speichern Sie die Datei und beenden Sie den Text-Editor.

## Anwenden von `aws-auth` `ConfigMap` auf Ihren Cluster
<a name="aws-auth-configmap"></a>

`aws-auth` `ConfigMap` wird automatisch erstellt und auf Ihren Cluster angewendet, wenn Sie eine verwaltete Knotengruppe erstellen oder wenn Sie eine Knotengruppe mit `eksctl` erstellen. Sie wird anfänglich erstellt, um Knoten zu erlauben, Ihrem Cluster beizutreten, aber Sie verwenden diese `ConfigMap` auch, um rollenbasierten Zugriffssteuerungs(RBAC)-Zugriff auf IAM-Prinzipale hinzuzufügen. Wenn Sie keine selbstverwalteten Knoten gestartet und `aws-auth` `ConfigMap` nicht auf Ihren Cluster angewendet haben, können Sie das folgende Verfahren dafür verwenden.

1. Überprüfen Sie, ob Sie `aws-auth` `ConfigMap` bereits angewendet haben.

   ```
   kubectl describe configmap -n kube-system aws-auth
   ```

   Wenn die Fehlermeldung „ `Error from server (NotFound): configmaps "aws-auth" not found` “ angezeigt wird, fahren Sie mit den folgenden Schritten fort, um die Standard-`ConfigMap` anzuwenden.

1. Laden Sie die Authenticator-Konfigurationsübersicht herunter, bearbeiten Sie sie und wenden Sie sie an. AWS 

   1. Laden Sie die Konfigurationszuordnung herunter.

      ```
      curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm.yaml
      ```

   1. Stellen Sie in der Datei `aws-auth-cm.yaml` `rolearn` auf den Amazon-Ressourcennamen (ARN) der IAM-Rolle ein, die Ihren Knoten zugeordnet ist. Hierzu können Sie einen Texteditor verwenden oder *my-node-instance-role* ersetzen und den folgenden Befehl ausführen:

      ```
      sed -i.bak -e 's|<ARN of instance role (not instance profile)>|my-node-instance-role|' aws-auth-cm.yaml
      ```

      Ändern Sie keine weiteren Zeilen in dieser Datei.
**Wichtig**  
Der Rollen-ARN darf keinen Pfad wie `role/my-team/developers/my-role` enthalten. Das Format des ARN muss ` arn:aws: iam::111122223333:role/my-role ` sein. In diesem Beispiel muss `my-team/developers/` entfernt werden.

      Sie können die AWS CloudFormation Stack-Ausgaben für Ihre Knotengruppen überprüfen und nach den folgenden Werten suchen:
      +  **InstanceRoleARN** — Für Knotengruppen, die erstellt wurden mit `eksctl` 
      +  **NodeInstanceRole**— Für Knotengruppen, die mit von Amazon EKS bereitgestellten AWS CloudFormation Vorlagen erstellt wurden, im AWS-Managementkonsole 

   1. Wenden Sie die Konfiguration an. Die Ausführung dieses Befehls kann einige Minuten dauern.

      ```
      kubectl apply -f aws-auth-cm.yaml
      ```
**Anmerkung**  
Wenn Sie Autorisierungs- oder Ressourcenfehler erhalten, finden Sie weitere Informationen unter [Nicht autorisiert oder Zugriff verweigert (`kubectl`)](troubleshooting.md#unauthorized) im Thema zur Fehlerbehebung.

1. Sehen Sie sich den Status Ihrer Knoten an und warten Sie, bis diese in den `Ready`-Status eintreten.

   ```
   kubectl get nodes --watch
   ```

   Geben Sie `Ctrl`\$1`C` ein, um zum Shell-Prompt zurückzukehren.