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

# Assegnare ruoli IAM agli account di servizio Kubernetes
<a name="associate-service-account-role"></a>

Questo argomento spiega come configurare un account di servizio Kubernetes per assumere un ruolo AWS Identity and Access Management (IAM). Tutti i Pod configurati per utilizzare l'account di servizio possono quindi accedere a qualsiasi AWS servizio a cui il ruolo dispone delle autorizzazioni per accedere.

## Prerequisiti
<a name="_prerequisites"></a>
+ Un cluster esistente. Se non ne possiedi già uno, crealo seguendo una delle guide in [Nozioni di base su Amazon EKS](getting-started.md).
+ Creare un provider di identità OpenID Connect (OIDC) IAM per il cluster. Per sapere se disponi di un account o, per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md).
+ Versione `2.12.3` o successiva o versione `1.27.160` o successiva dell'interfaccia a riga di AWS comando (AWS CLI) installata e configurata sul dispositivo o. AWS CloudShell Per verificare la versione attuale, usa `aws --version | cut -d / -f2 | cut -d ' ' -f1`. I gestori di pacchetti come `yum``apt-get`, o Homebrew per macOS sono spesso diverse versioni dell'ultima versione della CLI AWS . Per installare la versione più recente, consulta [Installazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [configurazione rapida con aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) nella Guida per l'utente dell'*interfaccia a riga di AWS comando*. La versione AWS CLI installata in AWS CloudShell potrebbe anche contenere diverse versioni precedenti alla versione più recente. Per aggiornarlo, consulta [Installazione della AWS CLI nella tua home directory nella Guida per](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software) l'* AWS CloudShell utente*.
+ Lo strumento a riga di comando `kubectl` è installato sul dispositivo o AWS CloudShell. La versione può essere uguale oppure immediatamente precedente o successiva alla versione di Kubernetes del cluster. Ad esempio, se la versione del cluster è `1.29`, puoi usare `kubectl` versione `1.28`, `1.29` o `1.30`. Per installare o aggiornare `kubectl`, consulta [Impostazione di `kubectl` e `eksctl`](install-kubectl.md):
+ Un file `kubectl` `config` esistente che contiene la configurazione del cluster. Per creare un file `kubectl` `config`, consulta [Connettere kubectl a un cluster EKS creando un file kubeconfig](create-kubeconfig.md).

## Fase 1: creare la policy IAM
<a name="irsa-associate-role-procedure"></a>

Se desideri associare una policy IAM esistente al ruolo IAM, passa al prossimo passaggio.

1. Creare una policy IAM Puoi creare la tua policy o copiare una policy AWS gestita che già concede alcune delle autorizzazioni di cui hai bisogno e personalizzarla in base alle tue esigenze specifiche. Per ulteriori informazioni, consulta [Creating IAM policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) nella *Guida per l’utente di IAM*.

1. Crea un file che includa le autorizzazioni per i AWS servizi a cui desideri che i tuoi Pod accedano. Per un elenco di tutte le azioni per tutti i AWS servizi, consulta il [Service Authorization](https://docs.aws.amazon.com/service-authorization/latest/reference/) Reference.

   Puoi eseguire il comando seguente per creare un file policy di esempio che consenta l’accesso in sola lettura a un bucket Amazon S3. Facoltativamente, puoi archiviare le informazioni di configurazione o uno script di bootstrap in questo bucket; i container nel pod possono leggere il file dal bucket e caricarlo nell’applicazione. Se desideri creare questa policy di esempio, copia i seguenti contenuti sul dispositivo. Sostituiscilo *my-pod-secrets-bucket* con il nome del tuo bucket ed esegui il comando.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

1. Creare la policy IAM.

   ```
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

## Fase 2: creare e associare il ruolo IAM
<a name="_step_2_create_and_associate_iam_role"></a>

Creare un ruolo IAM e associarlo a un account di servizio Kubernetes. È possibile utilizzare uno dei due `eksctl` o la AWS CLI.

### Creare e associare il ruolo (eksctl)
<a name="_create_and_associate_role_eksctl"></a>

Questo comando `eksctl` crea un account di servizio Kubernetes nel namespace specificato, crea un ruolo IAM (se non esiste) con il nome specificato, allega un ARN della policy IAM esistente al ruolo e annota l’account di servizio con l’ARN del ruolo IAM. Assicurati di sostituire i valori segnaposto di esempio in questo comando con i valori specifici. Per l’installazione o l’aggiornamento di `eksctl`, consulta la sezione [Installation](https://eksctl.io/installation) nella documentazione di `eksctl`.

```
eksctl create iamserviceaccount --name my-service-account --namespace default --cluster my-cluster --role-name my-role \
    --attach-policy-arn arn:aws: iam::111122223333:policy/my-policy --approve
```

**Importante**  
Se il ruolo o l’account del servizio esiste già, il comando precedente potrebbe non riuscire. `eksctl` ha diverse opzioni che puoi fornire in queste situazioni. Per ulteriori informazioni, esegui `eksctl create iamserviceaccount --help`.

### Creazione e associazione di ruoli (AWS CLI)
<a name="create_and_associate_role_shared_aws_cli"></a>

Se disponi di un account di servizio Kubernetes esistente che deve assumere un ruolo IAM, puoi saltare questa fase.

1. Creare un account di servizio Kubernetes. Copia i seguenti contenuti sul dispositivo. Sostituiscilo *my-service-account* con il nome desiderato e *default* con un namespace diverso, se necessario. Se si modifica*default*, lo spazio dei nomi deve già esistere.

   ```
   cat >my-service-account.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: my-service-account
     namespace: default
   EOF
   kubectl apply -f my-service-account.yaml
   ```

1. Imposta l'ID AWS del tuo account su una variabile di ambiente con il seguente comando.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Imposta il provider di identità OIDC del cluster su una variabile di ambiente con il comando seguente. Sostituisci *my-cluster* con il nome del cluster.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Imposta le variabili per lo spazio dei nomi e il nome dell'account del servizio. Sostituisci *my-service-account* con l'account del servizio Kubernetes che desideri assumere il ruolo. Sostituisci *default* con lo spazio dei nomi dell'account del servizio.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Per creare una policy di attendibilità del ruolo IAM, esegui il comando seguente. Se desideri consentire a tutti gli account di servizio all’interno di un namespace di utilizzare il ruolo, copia i seguenti contenuti sul dispositivo. Sostituisci *StringEquals* con `StringLike` e sostituisci *\$1service\$1account* con. `*` Puoi aggiungere più voci nelle condizioni `StringEquals` e `StringLike` riportate di seguito per utilizzare più account di servizio o namespace con il ruolo. Per consentire ai ruoli di un AWS account diverso da quello in cui si trova il cluster di assumere il ruolo, consulta [Eseguire l’autenticazione a un altro account con IRSA](cross-account-access.md) per ulteriori informazioni.

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::123456789012:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   ```

1. Crea il ruolo. Sostituisci *my-role* con un nome per il ruolo IAM e *my-role-description* con una descrizione per il tuo ruolo.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Allegare una policy IAM al ruolo. Sostituisci *my-role* con il nome del ruolo IAM e *my-policy* con il nome di una policy esistente che hai creato.

   ```
   aws iam attach-role-policy --role-name my-role --policy-arn=arn:aws: iam::$account_id:policy/my-policy
   ```

1. Annota l'account del servizio con il nome della risorsa Amazon (ARN) del ruolo IAM che desideri che l'account del servizio assuma. Sostituisci *my-role* con il nome del ruolo IAM esistente. Supponiamo di aver consentito a un ruolo di un AWS account diverso da quello in cui si trova il cluster di assumere il ruolo in un passaggio precedente. Quindi, assicurati di specificare l' AWS account e il ruolo dell'altro account. Per ulteriori informazioni, consulta [Eseguire l’autenticazione a un altro account con IRSA](cross-account-access.md).

   ```
   kubectl annotate serviceaccount -n $namespace $service_account eks.amazonaws.com/role-arn=arn:aws: iam::$account_id:role/my-role
   ```

1. (Facoltativo) [Configura l'endpoint del servizio AWS Security Token per un account di servizio](configure-sts-endpoint.md). AWS consiglia di utilizzare un endpoint AWS STS regionale anziché un endpoint globale. Ciò riduce la latenza, fornisce una ridondanza integrata e aumenta la validità del token di sessione.

## Fase 3: confermare la configurazione
<a name="irsa-confirm-role-configuration"></a>

1. Confermare che la policy di attendibilità del ruolo IAM sia configurata correttamente.

   ```
   aws iam get-role --role-name my-role --query Role.AssumeRolePolicyDocument
   ```

   Di seguito viene riportato un output di esempio.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
               },
               "Action": "sts:AssumeRoleWithWebIdentity",
               "Condition": {
                   "StringEquals": {
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:default:my-service-account",
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                   }
               }
           }
       ]
   }
   ```

1. Conferma che la policy che hai associato al tuo ruolo in un passaggio precedente sia associata al ruolo.

   ```
   aws iam list-attached-role-policies --role-name my-role --query "AttachedPolicies[].PolicyArn" --output text
   ```

   Di seguito viene riportato un output di esempio.

   ```
    arn:aws: iam::111122223333:policy/my-policy
   ```

1. Imposta una variabile per memorizzare il nome della risorsa Amazon (ARN) della policy che desideri utilizzare. Sostituiscilo *my-policy* con il nome della politica per cui desideri confermare le autorizzazioni.

   ```
   export policy_arn=arn:aws: iam::111122223333:policy/my-policy
   ```

1. Visualizza la versione predefinita della policy.

   ```
   aws iam get-policy --policy-arn $policy_arn
   ```

   Di seguito viene riportato un output di esempio.

   ```
   {
       "Policy": {
           "PolicyName": "my-policy",
           "PolicyId": "EXAMPLEBIOWGLDEXAMPLE",
           "Arn": "arn:aws: iam::111122223333:policy/my-policy",
           "Path": "/",
           "DefaultVersionId": "v1",
           [...]
       }
   }
   ```

1. Visualizza il contenuto della policy per assicurarti che includa tutte le autorizzazioni di cui il pod ha bisogno. Se necessario, sostituiscilo *1* nel comando seguente con la versione restituita nell'output precedente.

   ```
   aws iam get-policy-version --policy-arn $policy_arn --version-id v1
   ```

   Di seguito viene riportato un output di esempio.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

   Se hai creato la policy di esempio in un passaggio precedente, il risultato è lo stesso. Se hai creato una politica diversa, il *example* contenuto è diverso.

1. Confermare che l’account di servizio Kubernetes sia annotato con il ruolo.

   ```
   kubectl describe serviceaccount my-service-account -n default
   ```

   Di seguito viene riportato un output di esempio.

   ```
   Name:                my-service-account
   Namespace:           default
   Annotations:         eks.amazonaws.com/role-arn: arn:aws: iam::111122223333:role/my-role
   Image pull secrets:  <none>
   Mountable secrets:   my-service-account-token-qqjfl
   Tokens:              my-service-account-token-qqjfl
   [...]
   ```

## Fasi successive
<a name="_next_steps"></a>
+  [Configurazione di pod per utilizzare un account di servizio Kubernetes](pod-configuration.md)