Esta documentação é referente à versão atual do GKE na AWS, lançada em novembro de 2021. Consulte as Notas de lançamento para mais informações.

Esta página foi traduzida pela API Cloud Translation.

Usar a Identidade da carga de trabalho com a AWS

A Identidade da carga de trabalho permite atribuir identidades e autorizações detalhadas e distintas para cada aplicativo no cluster. A identidade da carga de trabalho é a maneira recomendada para aplicativos em execução no GKE na AWS acessarem serviços da AWS e do Google Cloud. Para mais informações, consulte Identidade da carga de trabalho.

Neste tópico, explicamos como criar um provedor OIDC, provisionar contas de serviço e testar uma carga de trabalho de amostra usando a identidade da carga de trabalho.

Criar um provedor OIDC do IAM da AWS para o cluster

Para usar a identidade da carga de trabalho com o cluster, primeiro crie um provedor OIDC do IAM da AWS que faça referência ao cluster. Se você já tem um provedor OIDC do IAM para seu cluster, pule esta seção.

Para criar o provedor, siga estas etapas:

Determine o URI do emissor do OIDC para seu cluster:
```
gcloud container aws clusters describe CLUSTER_NAME \
     --location=GOOGLE_CLOUD_LOCATION \
     --format='value(workloadIdentityConfig.issuerUri)'
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- GOOGLE_CLOUD_LOCATION pelo nome do local do Google Cloud em que esse pool de nós será gerenciado, conforme definido nas regiões de gerenciamento do Google Cloud.
A saída inclui o URI do emissor do OIDC do cluster. Salve esse valor na etapa a seguir.
Em seguida, crie um provedor OIDC do IAM da AWS que faça referência ao cluster com o seguinte comando:
```
aws iam create-open-id-connect-provider \
    --url ISSUER_URI \
    --client-id-list sts.amazonaws.com \
    --thumbprint-list 08745487e891c19e3078c1f2a07e452950ef36f6
```
Substitua ISSUER_URI pelo URI do emissor da etapa anterior.

A impressão digital do serviço do Google Cloud que exibe o URI do emissor é sempre 08745487e891c19e3078c1f2a07e452950ef36f6.

Configurar um papel do IAM da AWS com uma política de IAM anexada

Para configurar um papel do IAM da AWS e anexar uma política a ele, siga estas etapas:

Determine o host do emissor removendo o prefixo https:// do URI do emissor. Por exemplo, se o URI for https://oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster, o host será oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster. Salve esse valor. Você precisará dele mais tarde.

Determine o nome do recurso da Amazon (ARN) do provedor executando:

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

Substitua ISSUER_HOST pelo nome do host do URI do emissor do cluster.

Em seguida, crie uma política de confiança para fornecer credenciais OIDC à conta de serviço do Kubernetes. Crie um arquivo chamado trust-policy.json com o seguinte conteúdo:
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "PROVIDER_ARN"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "ISSUER_HOST:sub": "system:serviceaccount:NAMESPACE:KSA_NAME"
        }
      }
    }
  ]
}
```
Substitua:
- PROVIDER_ARN: o ARN do provedor de OIDC do IAM do cluster
- ISSUER_HOST: o nome do host do URI do emissor para o cluster.
- NAMESPACE: o namespace do Kubernetes em que o aplicativo é executado;
- KSA_NAME: a conta de serviço do Kubernetes (KSA) a ser usada para o aplicativo.

Crie um papel do IAM da AWS:

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

Substitua AWS_ROLE_NAME pelo nome do papel do IAM da AWS para o aplicativo.

Anexe uma política do IAM da AWS ao papel:
```
aws iam attach-role-policy --role-name=AWS_ROLE_NAME \
    --policy-arn=AWS_POLICY_ARN
```
Substitua:
- AWS_ROLE_NAME: o nome do papel do IAM da AWS para o aplicativo
Por exemplo, para criar um papel chamado ec2-readonly, com a política arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess, execute o seguinte comando:
```
aws iam attach-role-policy --role-name=ec2-readonly \
    --policy-arn=arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess
```

Implantar um aplicativo de amostra

Para testar a identidade da carga de trabalho, siga estas etapas para implantar um aplicativo de amostra:

Determine o ARN do papel:

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

Substitua AWS_ROLE_NAME.

Crie um manifesto para um namespace, uma KSA e um pod do Kubernetes. Copie o seguinte manifesto do YAML para um arquivo chamado 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

Substitua:

NAMESPACE
KSA_NAME
AWS_ROLE_ARN: o ARN do papel do IAM da AWS para o aplicativo
AWS_REGION: a região da AWS do cluster

Aplique o manifesto:
```
kubectl apply -f workload-identity-test.yaml
```
Aguarde alguns minutos até que o pod seja iniciado e vá para a seção a seguir.

Verificar se o aplicativo de amostra está funcionando

Para verificar se o aplicativo de amostra pode acessar a API EC2, observe os registros do pod:

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

Se o pod puder acessar a API EC2, a saída incluirá informações sobre zonas de disponibilidade do EC2 e será semelhante a esta:

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

Limpar

Para remover este aplicativo de amostra, siga estas etapas:

Exclua o manifesto do aplicativo de amostra do seu cluster:
```
kubectl delete -f workload-identity-test.yaml
```

Desanexe a política do AWS IAM do papel:

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

Substitua AWS_ROLE_NAME pelo nome do papel do IAM da AWS para o aplicativo.

Exclua o papel do IAM da AWS:
```
aws iam delete-role --role-name AWS_ROLE_NAME
```
Substitua AWS_ROLE_NAME pelo nome do papel do IAM da AWS para o aplicativo.
Exclua o provedor OIDC do AWS IAM:
```
aws iam delete-open-id-connect-provider --open-id-connect-provider-arn PROVIDER_ARN
```
Substitua PROVIDER_ARN pelo ARN do provedor OIDC do IAM para o cluster.

A seguir

Saiba mais sobre como usar a identidade da carga de trabalho com o Google Cloud.