Il prodotto descritto da questa documentazione, GKE su AWS, è ora in modalità di manutenzione e verrà chiuso il 17 marzo 2027.

Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizza Workload Identity con AWS

Workload Identity consente di assegnare l'autorizzazione e identità distinte e granulari per ogni applicazione nel tuo cluster. Workload Identity è il metodo consigliato per le applicazioni in esecuzione in GKE su AWS per accedere ai servizi AWS e Google Cloud . Per maggiori informazioni, consulta Workload Identity.

Questo argomento spiega come creare un provider OIDC, eseguire il provisioning dei service account e testare un carico di lavoro di esempio utilizzando l'identità del carico di lavoro. Questa pagina è dedicata ad amministratori di identità e account, operatori e sviluppatori che vogliono creare e gestire criteri relativi alle autorizzazioni utente. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli utente e attività comuni di GKE. Google Cloud

Crea un provider OIDC IAM AWS per il tuo cluster

Per utilizzare Workload Identity con il tuo cluster, devi prima creare un provider AWS IAM OIDC che faccia riferimento al tuo cluster. Se hai già un provider IAM OIDC per il tuo cluster, puoi saltare questa sezione.

Per creare il fornitore:

Determina l'URI dell'emittente OIDC per il tuo cluster:
```
gcloud container aws clusters describe CLUSTER_NAME \
     --location=GOOGLE_CLOUD_LOCATION \
     --format='value(workloadIdentityConfig.issuerUri)'
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del cluster
- GOOGLE_CLOUD_LOCATION: il nome della località Google Cloud da cui verrà gestito questo pool di nodi, come definito nelle regioni di gestioneGoogle Cloud
L'output include l'URI dell'emittente OIDC del cluster. Salva questo valore per il passaggio successivo.
Successivamente, crea un provider AWS IAM OIDC che faccia riferimento al tuo cluster con il seguente comando:
```
aws iam create-open-id-connect-provider \
    --url ISSUER_URI \
    --client-id-list sts.amazonaws.com \
    --thumbprint-list 08745487e891c19e3078c1f2a07e452950ef36f6
```
Sostituisci ISSUER_URI con l'URI dell'emittente del passaggio precedente.

L'impronta del servizio che gestisce l'URI emittente è sempre 08745487e891c19e3078c1f2a07e452950ef36f6. Google Cloud

Configura un ruolo AWS IAM con un criterio IAM collegato

Per configurare un ruolo IAM AWS e collegarvi un criterio, segui questi passaggi:

Determina l'host dell'emittente rimuovendo il prefisso https:// dall'URI dell'emittente. Ad esempio, se il tuo URI è https://oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster, l'host è oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster. Salva questo valore. Ne avrai bisogno successivamente.

Determina l'Amazon Resource Name (ARN) del provider eseguendo:

aws iam list-open-id-connect-providers --output=text \
    --query 'OpenIDConnectProviderList[?ends_with(Arn, `ISSUER_HOST`) == `true`].Arn'

Sostituisci ISSUER_HOST con il nome host dell'URI dell'emittente per il cluster.

Successivamente, crea una policy di attendibilità per fornire le credenziali OIDC al account di servizio Kubernetes. Crea un file denominato trust-policy.json con i seguenti contenuti:
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "PROVIDER_ARN"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "ISSUER_HOST:sub": "system:serviceaccount:NAMESPACE:KSA_NAME"
        }
      }
    }
  ]
}
```
Sostituisci quanto segue:
- PROVIDER_ARN: l'ARN del provider IAM OIDC del cluster
- ISSUER_HOST: il nome host dell'URI dell'emittente per il cluster.
- NAMESPACE: lo spazio dei nomi Kubernetes in cui viene eseguita l'applicazione
- KSA_NAME: il account di servizio Kubernetes (KSA) da utilizzare per l'applicazione

Crea un ruolo IAM AWS:

aws iam create-role --role-name=AWS_ROLE_NAME \
    --assume-role-policy-document file://trust-policy.json

Sostituisci AWS_ROLE_NAME con il nome del ruolo AWS IAM per l'applicazione.

Allega un criterio AWS IAM al ruolo:
```
aws iam attach-role-policy --role-name=AWS_ROLE_NAME \
    --policy-arn=AWS_POLICY_ARN
```
Sostituisci quanto segue:
- AWS_ROLE_NAME: il nome del ruolo AWS IAM per l'applicazione
Ad esempio, per creare un ruolo denominato ec2-readonly con la policy arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess, esegui il seguente comando:
```
aws iam attach-role-policy --role-name=ec2-readonly \
    --policy-arn=arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess
```

Deployment di un'applicazione di esempio

Per testare l'identità del workload, segui questi passaggi per eseguire il deployment di un'applicazione di esempio:

Determina l'ARN del ruolo:

aws iam get-role --role-name=AWS_ROLE_NAME --query 'Role.Arn'

Sostituisci AWS_ROLE_NAME.

Crea un manifest per uno spazio dei nomi, un KSA e un pod Kubernetes. Copia il seguente manifest in un file denominato workload-identity-test.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: NAMESPACE
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: KSA_NAME
  namespace: NAMESPACE
automountServiceAccountToken: false
---
apiVersion: v1
kind: Pod
metadata:
  name: aws-cli-example
  namespace: NAMESPACE
spec:
  serviceAccount: KSA_NAME
  containers:
  - name: aws-cli
    image: amazon/aws-cli:latest
    command:
    - /bin/bash
    - -c
    - "set -eu -o pipefail; while true; do aws ec2 describe-availability-zones; sleep 5; done"
    env:
    - name: AWS_ROLE_ARN
      value: AWS_ROLE_ARN
    - name: AWS_WEB_IDENTITY_TOKEN_FILE
      value: /var/run/secrets/aws-iam-token/serviceaccount/token
    - name: AWS_REGION
      value: AWS_REGION
    volumeMounts:
    - mountPath: /var/run/secrets/aws-iam-token/serviceaccount
      name: aws-iam-token
      readOnly: true
  volumes:
  - name: aws-iam-token
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          audience: sts.amazonaws.com
          expirationSeconds: 86400
          path: token

Sostituisci quanto segue:

NAMESPACE
KSA_NAME
AWS_ROLE_ARN: l'ARN del ruolo AWS IAM per l'applicazione
AWS_REGION: la regione AWS del cluster

Applica il manifest:
```
kubectl apply -f workload-identity-test.yaml
```
Attendi diversi minuti per l'avvio del pod e procedi alla sezione successiva.

Verifica che l'applicazione di esempio funzioni

Per verificare che l'applicazione di esempio possa accedere all'API EC2, esamina i log del pod:

kubectl logs -f aws-cli-example -n NAMESPACE

Se il pod può accedere all'API EC2, l'output include informazioni sulle zone di disponibilità EC2 ed è simile al seguente:

-------------------------------------------------
|           DescribeAvailabilityZones           |
+-----------------------------------------------+
||              AvailabilityZones              ||
|+---------------------+-----------------------+|
||  GroupName          |  us-west-2            ||
||  NetworkBorderGroup |  us-west-2            ||
||  OptInStatus        |  opt-in-not-required  ||
||  RegionName         |  us-west-2            ||
||  State              |  available            ||
||  ZoneId             |  usw2-az1             ||
||  ZoneName           |  us-west-2a           ||
|+---------------------+-----------------------+|
||              AvailabilityZones              ||
|+---------------------+-----------------------+|
||  GroupName          |  us-west-2            ||
||  NetworkBorderGroup |  us-west-2            ||
||  OptInStatus        |  opt-in-not-required  ||
||  RegionName         |  us-west-2            ||
||  State              |  available            ||
||  ZoneId             |  usw2-az2             ||
||  ZoneName           |  us-west-2b           ||
|+---------------------+-----------------------+|
||              AvailabilityZones              ||
|+---------------------+-----------------------+|
||  GroupName          |  us-west-2            ||
||  NetworkBorderGroup |  us-west-2            ||
||  OptInStatus        |  opt-in-not-required  ||
||  RegionName         |  us-west-2            ||
||  State              |  available            ||
||  ZoneId             |  usw2-az3             ||
||  ZoneName           |  us-west-2c           ||
|+---------------------+-----------------------+|
||              AvailabilityZones              ||
|+---------------------+-----------------------+|
||  GroupName          |  us-west-2            ||
||  NetworkBorderGroup |  us-west-2            ||
||  OptInStatus        |  opt-in-not-required  ||
||  RegionName         |  us-west-2            ||
||  State              |  available            ||
||  ZoneId             |  usw2-az4             ||
||  ZoneName           |  us-west-2d           ||
|+---------------------+-----------------------+|

Esegui la pulizia

Per rimuovere questa applicazione di esempio:

Elimina il file manifest dell'applicazione di esempio dal cluster:
```
kubectl delete -f workload-identity-test.yaml
```

Scollega la policy AWS IAM dal ruolo:

aws iam detach-role-policy --role-name AWS_ROLE_NAME \
    --policy-arn arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess