Esta documentación es para la versión actual de GKE en AWS, publicada en noviembre de 2021. Consulta las notas de la versión para obtener más información.

Usa Workload Identity con AWS

Workload Identity te permite asignar identidades y autorizaciones distintas y detalladas para cada aplicación en el clúster. Workload Identity es la forma recomendada para que las aplicaciones que se ejecutan dentro de GKE en AWS accedan a los servicios de AWS y Google Cloud. Para obtener más información, consulta Workload Identity.

En este tema, se explica cómo crear un proveedor de OIDC, aprovisionar cuentas de servicio y probar una carga de trabajo de muestra mediante Workload Identity.

Crea un proveedor de OIDC de IAM de AWS para tu clúster

Para usar Workload Identity con el clúster, primero debes crear un proveedor de OIDC de IAM de AWS que haga referencia a tu clúster. Si ya tienes un proveedor de OIDC de IAM para tu clúster, puedes omitir esta sección.

Para crear el proveedor, sigue estos pasos:

Determina el URI del emisor de OIDC para el clúster:
```
gcloud container aws clusters describe CLUSTER_NAME \
     --location=GOOGLE_CLOUD_LOCATION \
     --format='value(workloadIdentityConfig.issuerUri)'
```
Reemplaza lo siguiente:
- CLUSTER_NAME: Es el nombre de tu clúster.
- GOOGLE_CLOUD_LOCATION con el nombre de la ubicación de Google Cloud desde la que se administrará este grupo de nodos, como se define en las regiones de administración de Google Cloud
El resultado incluye el URI del emisor de OIDC del clúster. Guarda este valor para el paso siguiente.
Luego, crea un proveedor de OIDC de IAM de AWS que haga referencia a tu clúster con el siguiente comando:
```
aws iam create-open-id-connect-provider \
    --url ISSUER_URI \
    --client-id-list sts.amazonaws.com \
    --thumbprint-list 08745487e891c19e3078c1f2a07e452950ef36f6
```
Reemplaza ISSUER_URI por el URI del emisor del paso anterior.

La huella digital del servicio de Google Cloud que entrega el URI de la entidad emisora siempre es 08745487e891c19e3078c1f2a07e452950ef36f6.

Configura un rol de IAM de AWS con una política de IAM adjunta

Para configurar un rol de IAM de AWS y adjuntarle una política, sigue estos pasos:

Determina el host del emisor mediante la eliminación del prefijo https:// del URI del emisor. Por ejemplo, si tu URI es https://oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster, el host es oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster. Guarda este valor. Lo necesitarás más tarde.
Determina el nombre de recurso de Amazon (ARN) del proveedor mediante la ejecución de lo siguiente:
```
aws iam list-open-id-connect-providers --output=text \
    --query 'OpenIDConnectProviderList[?ends_with(Arn, `ISSUER_HOST`) == `true`].Arn'
```
Reemplaza ISSUER_HOST por el nombre de host del URI del emisor para el clúster.
A continuación, crea una política de confianza para proporcionar credenciales de OIDC a la cuenta de servicio de Kubernetes. Crea un archivo llamado trust-policy.json con los siguientes contenidos:
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "PROVIDER_ARN"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "ISSUER_HOST:sub": "system:serviceaccount:NAMESPACE:KSA_NAME"
        }
      }
    }
  ]
}
```
Reemplaza lo siguiente:
- PROVIDER_ARN: El ARN del proveedor de OIDC de IAM del clúster
- ISSUER_HOST: el nombre de host del URI del emisor para el clúster.
- NAMESPACE: El espacio de nombres de Kubernetes en el que se ejecuta la aplicación
- KSA_NAME: La cuenta de servicio de Kubernetes (KSA) que se usará para la aplicación

Crea un rol de IAM de AWS:

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

Reemplaza AWS_ROLE_NAME con el nombre del rol de IAM de AWS para la aplicación.

Adjunta una política de IAM de AWS al rol a continuación:
```
aws iam attach-role-policy --role-name=AWS_ROLE_NAME \
    --policy-arn=AWS_POLICY_ARN
```
Reemplaza lo siguiente:
- AWS_ROLE_NAME: Es el nombre del rol de IAM de AWS para la aplicación.
Por ejemplo, para crear un rol llamado ec2-readonly, con la política arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess, ejecuta el siguiente comando:
```
aws iam attach-role-policy --role-name=ec2-readonly \
    --policy-arn=arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess
```

Implementar una aplicación de ejemplo

Para probar la identidad de cargas de trabajo, sigue estos pasos a fin de implementar una aplicación de ejemplo:

Determina el ARN del rol:

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

Reemplaza AWS_ROLE_NAME.

Crea un manifiesto para un espacio de nombres de Kubernetes, KSA y un Pod. Copia el siguiente manifiesto en un archivo llamado 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

Reemplaza lo siguiente:

NAMESPACE
KSA_NAME
AWS_ROLE_ARN: El ARN del rol de IAM de AWS para la aplicación
AWS_REGION: La región de AWS del clúster

Aplica el manifiesto
```
kubectl apply -f workload-identity-test.yaml
```
Espera varios minutos para que se inicie el Pod y continúa con la siguiente sección.

Verifica que la aplicación de ejemplo funcione

Para verificar que la aplicación de ejemplo pueda acceder a la API de EC2, observa los registros del pod:

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

Si el Pod puede acceder a la API de EC2, el resultado incluye información sobre las zonas de disponibilidad de EC2 y es similar a lo siguiente:

-------------------------------------------------
|           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           ||
|+---------------------+-----------------------+|

Limpia

Para quitar la aplicación de ejemplo, sigue estos pasos:

Borra el manifiesto de la aplicación de ejemplo del clúster:
```
kubectl delete -f workload-identity-test.yaml
```
Desconecta la política de IAM de AWS del rol:
```
aws iam detach-role-policy --role-name AWS_ROLE_NAME \
    --policy-arn arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess
```
Reemplaza AWS_ROLE_NAME con el nombre del rol de IAM de AWS para la aplicación.
Borra el rol de IAM de AWS:
```
aws iam delete-role --role-name AWS_ROLE_NAME
```
Reemplaza AWS_ROLE_NAME con el nombre del rol de IAM de AWS para la aplicación.
Borra el proveedor de OIDC de IAM de AWS:
```
aws iam delete-open-id-connect-provider --open-id-connect-provider-arn PROVIDER_ARN
```
Reemplaza PROVIDER_ARN por el ARN del proveedor de OIDC de IAM para el clúster.

¿Qué sigue?

Obtén información sobre cómo usar Workload Identity con servicios de Google Cloud.