Aggiunta di principali IAM al cluster Amazon EKS Applica la aws-authConfigMap al cluster

Contribuisci a migliorare questa pagina

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link Modifica questa pagina nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Concedi agli utenti IAM l'accesso a Kubernetes con un ConfigMap

Importante

La funzionalità aws-auth ConfigMap è obsoleta. Per il metodo consigliato per gestire l'accesso a Kubernetes, consulta. APIs Concedere agli utenti IAM l’accesso a Kubernetes con le voci di accesso EKS

L’accesso al cluster utilizzando i principali IAM è abilitato dall’autenticatore AWS IAM per Kubernetes, che viene eseguito sul piano di controllo di Amazon EKS. L’autenticatore riceve le informazioni di configurazione da aws-auth ConfigMap. Per tutte le impostazioni di ConfigMap aws-auth, consulta Formato di configurazione completo su GitHub.

Aggiunta di principali IAM al cluster Amazon EKS

Quando crei un cluster Amazon EKS, il principale IAM che crea il cluster riceve automaticamente le autorizzazioni system:masters nella configurazione del controllo degli accessi basato sul ruolo (RBAC) nel piano di controllo di Amazon EKS. Questo principale non è visualizzato in una configurazione visibile qualsiasi, quindi assicurati di tenere traccia di quale principale ha originariamente creato il cluster. Per concedere a ulteriori principali IAM la capacità di interagire con il cluster, modifica aws-auth ConfigMap all’interno di Kubernetes e crea rolebinding o clusterrolebinding Kubernetes con il nome di group specificato in aws-auth ConfigMap.

Nota

Per ulteriori informazioni sulla configurazione del controllo degli accessi basato sul ruolo (RBAC) di Kubernetes, consultare Using RBAC Authorization nella documentazione di Kubernetes.

Determina quali credenziali kubectl vengono utilizzate per accedere al cluster. Sul computer, è possibile vedere quali credenziali kubectl utilizza con il seguente comando. Sostituiscilo ~/.kube/config con il percorso kubeconfig del file se non utilizzi il percorso predefinito.
```
cat ~/.kube/config
```
Di seguito viene riportato un output di esempio.
```
[...]
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
[...]
```
Nell'output dell'esempio precedente, le credenziali per un utente denominato admin sono configurate per un cluster denominato my-cluster. Se si tratta dell’utente che ha creato il cluster, ha già accesso al cluster. Se l’utente non ha creato il cluster, devi completare i passaggi rimanenti per abilitare l’accesso al cluster per gli altri principali IAM. Le best practice IAM consigliano di concedere le autorizzazioni ai ruoli anziché agli utenti. Per visualizzare gli altri principali che hanno attualmente accesso al cluster, esegui il comando seguente:
```
kubectl describe -n kube-system configmap/aws-auth
```
Di seguito viene riportato un output di esempio.
```
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>
```
L’esempio precedente è una aws-auth ConfigMap predefinita. Solo il ruolo dell’istanza del nodo ha accesso al cluster.
Assicurati di disporre di roles e rolebindings o clusterroles e clusterrolebindings di Kubernetes da mappare ai principali IAM. Per ulteriori informazioni su queste risorse, consulta Utilizzo dell’autorizzazione RBAC nella documentazione di Kubernetes.
1. Visualizza i roles o clusterroles Kubernetes esistenti. L’ambito di Roles è namespace, mentre l’ambito di clusterroles è il cluster.
```
kubectl get roles -A
```
```
kubectl get clusterroles
```
2. Visualizza i dettagli dei valori role o clusterrole restituiti nell’output precedente e verifica di disporre delle autorizzazioni (rules) da concedere ai principali IAM del cluster.
  
  Sostituisci role-name con un nome del role restituito nell'output del comando precedente. Sostituisci kube-system con lo spazio dei nomi del role.
```
kubectl describe role role-name -n kube-system
```
  Sostituisci cluster-role-name con un nome del clusterrole restituito nell'output del comando precedente.
```
kubectl describe clusterrole cluster-role-name
```
3. Visualizza i rolebindings o clusterrolebindings Kubernetes esistenti. L’ambito di Rolebindings è namespace, mentre l’ambito di clusterrolebindings è il cluster.
```
kubectl get rolebindings -A
```
```
kubectl get clusterrolebindings
```
4. Visualizza i dettagli di rolebinding o clusterrolebinding e verifica che dispongano di un role or clusterrole della fase precedente elencato come un roleRef e un nome di gruppo elencato per subjects.
  
  Sostituisci role-binding-name con un nome del rolebinding restituito nell'output del comando precedente. Sostituisci kube-system con lo namespace del rolebinding.
```
kubectl describe rolebinding role-binding-name -n kube-system
```
  Di seguito viene riportato un output di esempio.
```
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
```
  Sostituisci cluster-role-binding-name con un nome del clusterrolebinding restituito nell'output del comando precedente.
```
kubectl describe clusterrolebinding cluster-role-binding-name
```
  Di seguito viene riportato un output di esempio.
```
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
```
Modificare aws-auth ConfigMap. Per aggiornare ConfigMap puoi usare uno strumento adeguato, ad esempio eksctl, oppure puoi eseguire l’aggiornamento in modo manuale tramite modifica.

Importante
Ti consigliamo di utilizzare eksctl, o uno strumento simile, per modificare ConfigMap. Per informazioni su altri strumenti che puoi utilizzare, consulta Utilizzare gli strumenti per apportare modifiche a aws- authConfigMap nelle guide alle best practice di Amazon EKS. Una formattazione impropria di aws-auth ConfigMap può causare la perdita dell’accesso al cluster.
- Visualizzare le fasi per modificare configmap con eksctl.
- Visualizzare le fasi per modificare configmap manualmente.

Modificare Configmap con Eksctl

È necessaria la versione 0.215.0 o una versione successiva dello strumento da riga di eksctl comando installata sul dispositivo o AWS CloudShell. Per l’installazione o l’aggiornamento di eksctl, consulta la sezione Installation nella documentazione di eksctl.

Visualizza le mappature correnti in ConfigMap. Sostituisci my-cluster con il nome del cluster. Sostituiscilo region-code con la AWS regione in cui si trova il cluster.


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

Di seguito viene riportato un output di esempio.


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

Aggiungi una mappatura per un ruolo. Sostituisci my-role con il nome del tuo ruolo. Sostituisci eks-console-dashboard-full-access-group con il nome del gruppo specificato nel tuo Kubernetes RoleBinding o nell'oggetto. ClusterRoleBinding Sostituisci 111122223333 con l'ID del tuo account. Puoi sostituire admin con un nome a tua scelta.
```
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
```
Importante
L’ARN del ruolo non può includere un percorso, ad esempio role/my-team/developers/my-role. Il formato dell’ARN deve essere arn:aws: iam::111122223333:role/my-role. In questo esempio, my-team/developers/ deve essere rimosso.

Di seguito viene riportato un output di esempio.
```
[...]
2022-05-09 14:51:20 [ℹ]  adding identity "{arn-aws}iam::111122223333:role/my-role" to auth ConfigMap
```
Aggiungi una mappatura per un utente. Le best practice IAM consigliano di concedere le autorizzazioni ai ruoli anziché agli utenti. Sostituisci my-user con il tuo nome utente. Sostituisci eks-console-dashboard-restricted-access-group con il nome del gruppo specificato nel tuo RoleBinding Kubernetes o nell'oggetto. ClusterRoleBinding Sostituisci 111122223333 con l'ID del tuo account. Puoi sostituire my-user con un nome a tua scelta.
```
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
```
Di seguito viene riportato un output di esempio.
```
[...]
2022-05-09 14:53:48 [ℹ]  adding identity "arn:aws: iam::111122223333:user/my-user" to auth ConfigMap
```

Visualizza nuovamente le mappature nella ConfigMap.


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

Di seguito viene riportato un output di esempio.


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

Modificare Configmap manualmente

Apri ConfigMap per la modifica.
```
kubectl edit -n kube-system configmap/aws-auth
```
Nota
Se ricevi un errore che indica "Error from server (NotFound): configmaps "aws-auth" not found«, utilizza la procedura in Applica l'aws-auth al tuo cluster ConfigMap per applicare lo stock. ConfigMap
Aggiungi i tuoi principali IAM alla ConfigMap. Un gruppo IAM non è un principale IAM, quindi non può essere aggiunto alla ConfigMap.
- Per aggiungere un ruolo IAM (ad esempio, per utenti federati): aggiungere i dettagli del ruolo alla sezione mapRoles della ConfigMap, in data. Aggiungi questa sezione se non esiste già nel file. Ogni voce supporta i seguenti parametri:
  - rolearn: l’ARN; del ruolo IAM da aggiungere. Questo valore non può includere un percorso. Ad esempio, non puoi specificare un ARN, come arn:aws: iam::111122223333:role/my-team/developers/role-name. L’ARN deve essere arn:aws: iam::111122223333:role/role-name.
  - username: il nome utente all’interno di Kubernetes da associare al ruolo IAM.
  - groups: il gruppo o l’elenco dei gruppi Kubernetes a cui mappare il ruolo. Tale gruppo può essere un gruppo predefinito o un gruppo specificato in un clusterrolebinding o un rolebinding. Per ulteriori informazioni consultare Default roles and role bindings nella documentazione di Kubernetes.
- Per aggiungere un utente IAM: le best practice IAM consigliano di concedere le autorizzazioni ai ruoli anziché agli utenti. Aggiungi i dettagli dell’utente alla sezione mapUsers della ConfigMap, in data. Aggiungi questa sezione se non esiste già nel file. Ogni voce supporta i seguenti parametri:
  - userarn: L’ARN; dell’utente IAM da aggiungere.
  - username: Il nome utente all’interno di Kubernetes da associare all’utente IAM.
  - groups: il gruppo o l’elenco dei gruppi Kubernetes a cui mappare l’utente. Tale gruppo può essere un gruppo predefinito o un gruppo specificato in un clusterrolebinding o un rolebinding. Per ulteriori informazioni consultare Default roles and role bindings nella documentazione di Kubernetes.
Ad esempio, il blocco YAML seguente contiene:
- Una sezione mapRoles che mappa l’istanza del nodo IAM ai gruppi Kubernetes, in modo che i nodi possano registrarsi autonomamente con il cluster e il ruolo IAM my-console-viewer-role mappato a un gruppo Kubernetes in grado di visualizzare tutte le risorse Kubernetes per tutti i cluster. Per un elenco delle autorizzazioni del gruppo IAM e Kubernetes necessarie per il ruolo IAM my-console-viewer-role, consulta Autorizzazioni richieste.
- Una mapUsers sezione che mappa l'utente admin IAM dall' AWS account predefinito al gruppo system:masters Kubernetes e l'my-userutente di un AWS account diverso mappato a un gruppo Kubernetes in grado di visualizzare le risorse Kubernetes per uno spazio dei nomi specifico. Per un elenco delle autorizzazioni del gruppo IAM e Kubernetes necessarie per l’utente IAM my-user, consulta Autorizzazioni richieste.
  
  Aggiungi o rimuovi righe in base alle esigenze e sostituisci tutti i valori di esempio con quelli desiderati.
```
# 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
```
Salva il file ed esci dall’editor di testo.

Applica la `aws-authConfigMap` al cluster

La aws-auth ConfigMap viene creata e applicata automaticamente al cluster quando si crea un gruppo di nodi gestito o quando si crea un gruppo di nodi utilizzando eksctl. È inizialmente creata per consentire ai nodi di unirsi al cluster, ma questa ConfigMap può essere usata anche per aggiungere l’accesso RBAC (controllo degli accessi basato sul ruolo) a principali IAM. Se non hai avviato nodi autogestiti e non hai applicato la aws-auth ConfigMap al cluster, puoi farlo utilizzando la procedura seguente.

Controlla per vedere se è già stata applicata la aws-auth ConfigMap.
```
kubectl describe configmap -n kube-system aws-auth
```
Se ricevi un errore di tipo "Error from server (NotFound): configmaps "aws-auth" not found", procedi con le fasi seguenti per applicare lo stock ConfigMap.
Scarica, modifica e applica la mappa di configurazione dell'autenticatore. AWS
1. Scarica la mappa di configurazione.
```
curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm.yaml
```
2. Nel file aws-auth-cm.yaml, imposta il rolearn sul nome della risorsa Amazon (ARN) del ruolo IAM associato ai nodi. Per eseguire questa operazione, utilizza un editor di testo o sostituisci my-node-instance-role eseguendo il comando seguente:
```
sed -i.bak -e 's|<ARN of instance role (not instance profile)>|my-node-instance-role|' aws-auth-cm.yaml
```
  Non modificare altre righe in questo file.
  
  Importante
  L’ARN del ruolo non può includere un percorso, ad esempio role/my-team/developers/my-role. Il formato dell’ARN deve essere arn:aws: iam::111122223333:role/my-role. In questo esempio, my-team/developers/ deve essere rimosso.
  
  Puoi ispezionare gli output dello AWS CloudFormation stack per i tuoi gruppi di nodi e cercare i seguenti valori:
  - InstanceRoleARN — Per i gruppi di nodi creati con eksctl
  - NodeInstanceRole— Per i gruppi di nodi creati con i AWS CloudFormation modelli forniti da Amazon EKS nel Console di gestione AWS
3. Applica la configurazione. L’esecuzione di questo comando potrebbe richiedere alcuni minuti.
```
kubectl apply -f aws-auth-cm.yaml
```
  Nota
  Se ricevi qualsiasi altro errore di tipo di risorsa o autorizzazione, consulta la sezione Accesso negato o non autorizzato (kubectl) nell’argomento relativo alla risoluzione dei problemi.
Guarda lo stato dei nodi e attendi che raggiungano lo stato Ready.
```
kubectl get nodes --watch
```
Inserisci Ctrl+C per tornare a un prompt della shell.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Tutorial: creare con i gruppi Kubernetes

Collegare il provider OIDC