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 ti consente di assegnare identità e autorizzazioni distinte e granulari per ogni applicazione nel tuo cluster. Workload Identity è il metodo consigliato per consentire alle applicazioni in esecuzione in GKE su AWS di accedere ai servizi Google Cloud e AWS. Per ulteriori informazioni, consulta Workload Identity.

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

Crea un provider OIDC AWS IAM per il cluster

Per utilizzare l'identità del carico di lavoro con il tuo cluster, devi prima creare un fornitore OIDC IAM AWS che faccia riferimento al tuo cluster. Se hai già un provider OIDC IAM per il tuo cluster, puoi saltare questa sezione.

Per creare il provider:

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 Google Cloud posizione da cui verrà gestito questo pool di nodi, come definito nelle Google Cloud regioni di gestione
L'output include l'URI dell'emittente OIDC del cluster. Salva questo valore per il passaggio successivo.
Successivamente, crea un provider OIDC AWS IAM che fa 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.

Il thumbprint del Google Cloud servizio che serve l'URI dell'emittente è sempre08745487e891c19e3078c1f2a07e452950ef36f6.

Configurare un ruolo AWS IAM con un criterio IAM associato

Per configurare un ruolo IAM AWS e associarvi un criterio:

Determina l'host del emittente rimuovendo il prefisso https:// dall'URI dell'emittente. Ad esempio, se l'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'ARN (Amazon Resource Name) 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 emittente per il cluster.

A questo punto, crea un criterio di attendibilità per fornire le credenziali OIDC all'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 OIDC IAM del cluster
- ISSUER_HOST: il nome host dall'URI emittente per il cluster.
- NAMESPACE: lo spazio dei nomi Kubernetes in cui viene eseguita l'applicazione
- KSA_NAME: l'account di servizio Kubernetes (KSA) da utilizzare per l'applicazione

Crea un ruolo AWS IAM:

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 IAM AWS per l'applicazione.

Collega 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 il criterio 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 carico di lavoro, 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 vai alla sezione successiva.

Verificare che l'applicazione di esempio funzioni

Per verificare che l'applicazione di esempio possa accedere all'API EC2, controlla 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 e ha il seguente aspetto:

-------------------------------------------------
|           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 il criterio AWS IAM dal ruolo:

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

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

Elimina il ruolo IAM AWS:
```
aws iam delete-role --role-name AWS_ROLE_NAME
```
Sostituisci AWS_ROLE_NAME con il nome del ruolo AWS IAM per l'applicazione.
Elimina il provider OIDC AWS IAM:
```
aws iam delete-open-id-connect-provider --open-id-connect-provider-arn PROVIDER_ARN
```
Sostituisci PROVIDER_ARN con l'ARN del provider IAM OIDC per il cluster.

Passaggi successivi

Scopri di più su come utilizzare Workload Identity con i servizi Google Cloud.

Utilizza Workload Identity con AWS Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.