**Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Atribuir um perfil do IAM a uma conta de serviço do Kubernetes
<a name="pod-id-association"></a>

Este tópico aborda como configurar uma conta de serviço do Kubernetes para assumir um perfil do AWS Identity and Access Management (IAM) com a Identidade de Pods do EKS. Qualquer pod que esteja configurado para usar a conta de serviço pode acessar qualquer serviço da AWS que o perfil tenha permissão para acessar.

Para criar uma associação de identidade de pod do EKS, há apenas uma única etapa; você cria a associação no EKS por meio de Console de gerenciamento da AWS, AWS CLI, AWS SDKs, AWS CloudFormation e outras ferramentas. Não há dados ou metadados sobre as associações dentro do cluster em nenhum objeto do Kubernetes, e você não adiciona anotações às contas de serviço.

 **Pré-requisitos** 
+ Um cluster existente. Se você não tiver um, poderá criá-lo seguindo um dos guias em [Começar a usar o Amazon EKS](getting-started.md).
+ A entidade principal do IAM que está criando a associação deve ter o `iam:PassRole`.
+ A versão mais recente da AWS CLI instalada e configurada em seu dispositivo ou no AWS CloudShell. É possível verificar sua versão atual com `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Os gerenciadores de pacotes, como `yum`, `apt-get` ou Homebrew para macOS, geralmente estão várias versões atrás da versão mais recente da AWS CLI. Para instalar a versão mais recente, consulte [Instalar](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Configuração rápida com aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config), no Guia do usuário da AWS Command Line Interface. A versão da AWS CLI instalada no AWS CloudShell também pode estar várias versões atrás da versão mais recente. Para atualizá-lo, consulte [Instalar a AWS CLI no seu diretório pessoal](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software), no Guia do usuário do AWS CloudShell.
+ A ferramenta da linha de comando `kubectl` está instalada no seu dispositivo ou no AWS CloudShell. A versão pode ser a mesma ou até uma versão secundária anterior ou posterior à versão do Kubernetes do seu cluster. Por exemplo, se a versão do cluster for a `1.29`, será possível usar o `kubectl` versão `1.28`, `1.29` ou `1.30` com ele. Para instalar ou atualizar o `kubectl`, consulte [Configurar o `kubectl` e o `eksctl`](install-kubectl.md).
+ Um arquivo `kubectl` `config` existente que contém a configuração do seu cluster. Para criar um arquivo `kubectl` `config`, consulte [Conecte o kubectl a um cluster de EKS criando um arquivo kubeconfig](create-kubeconfig.md).

## Criar uma associação de identidade de pod (console do AWS )
<a name="pod-id-association-create"></a>

1. Abra o [console do Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. No painel de navegação esquerdo, selecione **Clusters** e depois o nome do cluster para o qual você deseja configurar o complemento do atendente de Identidade de Pods do EKS.

1. Escolha a guia **Acesso**.

1. Nas **Associações do Pod Identity**, escolha **Criar**.

1. Para o **Perfil do IAM**, selecione o perfil do IAM com as permissões que você deseja que a workload tenha.
**nota**  
A lista contém apenas perfis que têm a política de confiança a seguir que permite que o EKS Pod Identity as use.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
               "Effect": "Allow",
               "Principal": {
                   "Service": "pods.eks.amazonaws.com"
               },
               "Action": [
                   "sts:AssumeRole",
                   "sts:TagSession"
               ]
           }
       ]
   }
   ```

    `sts:AssumeRole`: a Identidade de Pods do EKS usa `AssumeRole` para assumir o perfil do IAM antes de passar as credenciais temporárias para os pods.

    `sts:TagSession`: a Identidade de Pods do EKS usa `TagSession` para incluir *etiquetas de sessão* nas solicitações para o AWS STS.

   É possível usar essas tags nas *chaves de condição* na política de confiança para restringir quais contas de serviço, namespaces e clusters podem usar esse perfil.

   Para obter uma lista de chaves de condição do Amazon EKS, consulte [Condições definidas pelo Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-policy-keys) na *Referência de autorização de serviço*. Para saber com quais ações e recursos você pode usar a chave de condição, consulte [Ações definidas pelo Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions).

1. Em **Namespace do Kubernetes**, selecione o namespace do Kubernetes que contém a conta de serviço e a workload. Opcionalmente, é possível especificar um namespace por nome que não existe no cluster.

1. Em **conta de serviço do Kubernetes**, selecione a conta de serviço do Kubernetes a ser usada. O manifesto da workload do Kubernetes deve especificar essa conta de serviço. Opcionalmente, é possível especificar uma conta de serviço por nome que não existe no cluster.

1. (Opcional) Selecione **Desabilitar tags de sessão** para desabilitar as tags de sessão padrão que a Identidade de Pods adiciona automaticamente quando assume o perfil.

1. (Opcional) Alterne **Configurar política de sessão** para configurar uma política do IAM para aplicar restrições adicionais a essa associação de Identidade de Pods além das permissões definidas na política do IAM anexada ao perfil do IAM.
**nota**  
Uma política de sessão só pode ser aplicada quando a configuração **Desabilitar tags de sessão** está marcada.

1. (Opcional) Para as **Tags**, escolha **Adicionar tag** para adicionar metadados em um par de chave e valor. Essas tags são aplicadas à associação e podem ser usadas nas políticas do IAM.

   Repita essa etapa para adicionar várias tags.

1. Escolha **Criar**.

## Criar uma associação de identidade de pod (AWS CLI)
<a name="create_a_pod_identity_association_shared_aws_cli"></a>

1. Se você quiser associar uma política do IAM existente ao seu perfil do IAM, vá para a próxima etapa.

   Crie uma política do IAM. É possível criar a sua própria política ou copiar uma política gerenciada da AWS que já conceda algumas das permissões de que você precisa e a personalizar de acordo com seus requisitos específicos. Para obter mais informações, consulte [Criar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do usuário do IAM*.

   1. Crie um arquivo que inclua as permissões para os serviços da AWS que você deseja que os pods acessem. Para obter uma lista de todas as ações de todos os serviços do AWS, consulte a [Referência de autorização de serviço](https://docs.aws.amazon.com/service-authorization/latest/reference/).

      É possível executar o comando a seguir para criar um arquivo de política de exemplo que permita acesso somente leitura a um bucket do Amazon S3. É possível, opcionalmente, armazenar informações de configuração ou um script de bootstrap nesse bucket, e os contêineres no pod podem ler o arquivo do bucket e carregá-lo na aplicação. Se você quiser criar esse exemplo de política, copie o conteúdo a seguir para o seu dispositivo. Substitua {{my-pod-secrets-bucket}} pelo nome do seu bucket e execute o comando.

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": "s3:GetObject",
                  "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
              }
          ]
      }
      ```

   1. Crie a política do IAM.

      ```
      aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
      ```

1. Crie um perfil do IAM e associe-o a uma conta de serviço do Kubernetes.

   1. Se você já tem um conta de serviço do Kubernetes na qual deseja assumir um perfil do IAM, você pode ignorar esta etapa.

      Crie uma conta de serviço do Kubernetes. Copie o conteúdo a seguir para o seu dispositivo. Substitua {{my-service-account}} pelo nome desejado e {{default}} (padrão) por um namespace diferente, se necessário. Se você alterar o {{padrão}}, o namespace já deve existir.

      ```
      cat >my-service-account.yaml <<EOF
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: my-service-account
        namespace: default
      EOF
      kubectl apply -f my-service-account.yaml
      ```

      Execute o comando a seguir.

      ```
      kubectl apply -f my-service-account.yaml
      ```

   1. Execute o seguinte comando para criar um arquivo de política de confiança para o perfil do IAM.

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
                  "Effect": "Allow",
                  "Principal": {
                      "Service": "pods.eks.amazonaws.com"
                  },
                  "Action": [
                      "sts:AssumeRole",
                      "sts:TagSession"
                  ]
              }
          ]
      }
      ```

   1. Crie a função. Substitua {{my-role}} por um nome para seu perfil do IAM e {{my-role-description}} por uma descrição para seu perfil.

      ```
      aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
      ```

   1. Associe uma política do IAM ao seu perfil. Substitua {{my-role}} pelo nome do seu perfil do IAM e {{my-policy}} pelo nome de uma política existente que você criou.

      ```
      aws iam attach-role-policy --role-name my-role --policy-arn=arn:aws:iam::111122223333:policy/my-policy
      ```
**nota**  
Ao contrário dos perfis do IAM para contas de serviço, o EKS Pod Identity não usa uma anotação na conta de serviço.

   1. Execute o comando a seguir para criar a associação. Substitua `my-cluster` pelo nome do cluster, substitua {{my-service-account}} pelo nome desejado e {{default}} por um namespace diferente, se necessário.

      ```
      aws eks create-pod-identity-association --cluster-name my-cluster --role-arn arn:aws:iam::111122223333:role/my-role --namespace default --service-account my-service-account
      ```

      Veja abaixo um exemplo de saída.

      ```
      {
          "association": {
              "clusterName": "my-cluster",
              "namespace": "default",
              "serviceAccount": "my-service-account",
              "roleArn": "arn:aws:iam::111122223333:role/my-role",
              "associationArn": "arn:aws::111122223333:podidentityassociation/my-cluster/a-abcdefghijklmnop1",
              "associationId": "a-abcdefghijklmnop1",
              "tags": {},
              "createdAt": 1700862734.922,
              "modifiedAt": 1700862734.922
          }
      }
      ```
**nota**  
É possível especificar um namespace e uma conta de serviço por nome que não existe no cluster. É necessário criar o namespace, a conta de serviço e a workload que usa a conta de serviço para que a associação ao EKS Pod Identity funcione.

## Confirmar configuração
<a name="pod-id-confirm-role-configuration"></a>

1. Confirme se a política de confiança do perfil do IAM está configurada corretamente.

   ```
   aws iam get-role --role-name my-role --query Role.AssumeRolePolicyDocument
   ```

   Veja abaixo um exemplo de saída.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "Allow EKS Auth service to assume this role for Pod Identities",
               "Effect": "Allow",
               "Principal": {
                   "Service": "pods.eks.amazonaws.com"
               },
               "Action": [
                   "sts:AssumeRole",
                   "sts:TagSession"
               ]
           }
       ]
   }
   ```

1. Confirme se a política que você anexou ao seu perfil em uma etapa anterior está vinculada ao perfil.

   ```
   aws iam list-attached-role-policies --role-name my-role --query 'AttachedPolicies[].PolicyArn' --output text
   ```

   Veja um exemplo de saída abaixo.

   ```
                  arn:aws:iam::111122223333:policy/my-policy
   ```

1. Defina uma variável para armazenar o nome do recurso da Amazon (ARN) da política que deseja usar. Substitua {{my-policy}} pelo nome da política para a qual deseja confirmar permissões.

   ```
   export policy_arn=arn:aws:iam::111122223333:policy/my-policy
   ```

1. Visualize a versão padrão da política.

   ```
   aws iam get-policy --policy-arn $policy_arn
   ```

   Veja abaixo um exemplo de saída.

   ```
   {
       "Policy": {
           "PolicyName": "my-policy",
           "PolicyId": "EXAMPLEBIOWGLDEXAMPLE",
           "Arn": "arn:aws:iam::111122223333:policy/my-policy",
           "Path": "/",
           "DefaultVersionId": "v1",
           [...]
       }
   }
   ```

1. Confira o conteúdo da política para garantir que ela inclua todas as permissões de que seu pod precisa. Se necessário, substitua{{1}} no comando a seguir pela versão retornada na saída anterior.

   ```
   aws iam get-policy-version --policy-arn $policy_arn --version-id v1
   ```

   Veja abaixo um exemplo de saída.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-pod-secrets-bucket"
           }
       ]
   }
   ```

   Se você criou a política de exemplo em uma etapa anterior, sua saída será a mesma. Se você criou uma política diferente, então o {{exemplo}} de conteúdo é diferente.

## Próximas etapas
<a name="_next_steps"></a>

 [Configurar pods para acessar serviços da AWS com contas de serviço](pod-id-configure-pods.md)