O produto descrito nesta documentação, GKE na AWS, agora está em modo de manutenção e será encerrado em 17 de março de 2027.

Esta página foi traduzida pela API Cloud Translation.

Use o Workload Identity com a AWS

A identidade de carga de trabalho permite-lhe atribuir identidades distintas e detalhadas, bem como autorização, a cada aplicação no seu cluster. O Workload Identity é a forma recomendada para as aplicações em execução no GKE na AWS acederem aos serviços da AWS e do Google Cloud. Google Cloud Para mais informações, consulte o artigo Identidade da carga de trabalho.

Este tópico explica como criar um fornecedor OIDC, aprovisionar contas de serviço e testar uma carga de trabalho de exemplo com a identidade de carga de trabalho. Esta página destina-se a administradores de identidade e de contas, operadores e programadores que pretendem criar e gerir políticas relacionadas com autorizações de utilizadores. Para saber mais acerca das funções comuns e das tarefas de exemplo que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns do utilizador do GKE.

Crie um fornecedor OIDC do IAM da AWS para o seu cluster

Para usar o Workload Identity com o seu cluster, primeiro, cria um fornecedor OIDC do AWS IAM que faça referência ao seu cluster. Se já tiver um fornecedor OIDC do IAM para o seu cluster, pode ignorar esta secção.

Para criar o fornecedor, siga estes passos:

Determine o URI do emissor OIDC para o seu cluster:
```
gcloud container aws clusters describe CLUSTER_NAME \
     --location=GOOGLE_CLOUD_LOCATION \
     --format='value(workloadIdentityConfig.issuerUri)'
```
Substitua o seguinte:
- CLUSTER_NAME: o nome do seu cluster
- GOOGLE_CLOUD_LOCATION: o nome da Google Cloud localização a partir da qual este node pool vai ser gerido, conforme definido nas Google Cloud regiões de gestão
O resultado inclui o URI do emissor OIDC do seu cluster. Guarde este valor para o passo seguinte.
Em seguida, crie um fornecedor OIDC do IAM da AWS que faça referência ao seu 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 do passo anterior.

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

Configure uma função de IAM do AWS com uma política de IAM anexada

Para configurar uma função do AWS IAM e anexar-lhe uma política, siga estes passos:

Determine o anfitrião 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 anfitrião é oidc-provider.com/v1/projects/pid/locations/us-west1/awsClusters/awscluster. Guarde este valor. Vai precisar dele mais tarde.
Determine o nome do recurso da Amazon (ARN) do fornecedor executando o seguinte comando:
```
aws iam list-open-id-connect-providers --output=text \
    --query 'OpenIDConnectProviderList[?ends_with(Arn, `ISSUER_HOST`) == `true`].Arn'
```
Substitua ISSUER_HOST pelo nome do anfitrião do URI do emissor para o cluster.
Em seguida, crie uma política de confiança para fornecer credenciais OIDC à conta de serviço do Kubernetes. Crie um ficheiro denominado 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 o seguinte:
- PROVIDER_ARN: o ARN do fornecedor OIDC do IAM do cluster
- ISSUER_HOST: o nome do anfitrião do URI do emissor para o cluster.
- NAMESPACE: o namespace do Kubernetes onde a aplicação é executada
- KSA_NAME: a conta de serviço do Kubernetes (KSA) a usar para a aplicação

Crie uma função de IAM do AWS:

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

Substitua AWS_ROLE_NAME pelo nome da função do AWS IAM para a aplicação.

Anexe uma política de IAM do AWS à função:
```
aws iam attach-role-policy --role-name=AWS_ROLE_NAME \
    --policy-arn=AWS_POLICY_ARN
```
Substitua o seguinte:
- AWS_ROLE_NAME: o nome da função de IAM da AWS para a aplicação
Por exemplo, para criar uma função denominada 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
```

Implemente uma aplicação de exemplo

Para testar a identidade da carga de trabalho, siga estes passos para implementar uma aplicação de exemplo:

Determine o ARN da função:

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

Substituir AWS_ROLE_NAME.

Crie um manifesto para um espaço de nomes, um KSA e um pod do Kubernetes. Copie o seguinte manifesto para um ficheiro denominado 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 o seguinte:

NAMESPACE
KSA_NAME
AWS_ROLE_ARN: o ARN da função de IAM da AWS para a aplicação
AWS_REGION: a região da AWS do cluster

Aplique o manifesto:
```
kubectl apply -f workload-identity-test.yaml
```
Aguarde vários minutos até que o Pod seja iniciado e avance para a secção seguinte.

Verifique se a aplicação de exemplo está a funcionar

Para verificar se a aplicação de exemplo consegue aceder à API EC2, consulte os registos do pod:

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

Se o Pod conseguir aceder à API EC2, o resultado inclui informações sobre as zonas de disponibilidade do EC2 e é semelhante ao seguinte:

-------------------------------------------------
|           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 esta aplicação de exemplo, siga estes passos:

Elimine o manifesto da aplicação de exemplo do cluster:
```
kubectl delete -f workload-identity-test.yaml
```

Desassocie a política de IAM do AWS da função:

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