**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 perfis do IAM às contas de serviço do Kubernetes
<a name="associate-service-account-role"></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). 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.

## Pré-requisitos
<a name="_prerequisites"></a>
+ 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).
+ Um provedor do IAM OpenID Connect (OIDC) para o cluster. Para saber se você já tem um ou como criar um, consulte [Criar um provedor de identidade OIDC do IAM para o cluster](enable-iam-roles-for-service-accounts.md).
+ Versão `2.12.3` ou posterior ou versão `1.27.160` ou posterior da AWS Command Line Interface (AWS CLI) instalada e configurada no seu dispositivo ou no AWS CloudShell. Para verificar sua versão atual, use `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 [Installing](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Quick configuration with 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`, você poderá 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).

## Etapa 1: criar a política do IAM
<a name="irsa-associate-role-procedure"></a>

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

1. 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. Você pode, 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
   ```

## Etapa 2: criar e associar o perfil do IAM
<a name="_step_2_create_and_associate_iam_role"></a>

Crie um perfil do IAM e associe-o a uma conta de serviço do Kubernetes. Você pode usar o `eksctl` ou a AWS CLI.

### Criar e associar um perfil (eksctl)
<a name="_create_and_associate_role_eksctl"></a>

Esse comando `eksctl` cria uma conta de serviço do Kubernetes no namespace especificado, cria um perfil do IAM (se não existir) com o nome especificado, anexa um ARN de política do IAM existente ao perfil e anota a conta de serviço com o ARN do perfil do IAM. Certifique-se de substituir os valores de espaço reservado de exemplo neste comando por seus valores específicos. Para instalar ou atualizar o `eksctl`, consulte [Instalação](https://eksctl.io/installation) na documentação do `eksctl`.

```
eksctl create iamserviceaccount --name my-service-account --namespace default --cluster my-cluster --role-name my-role \
    --attach-policy-arn arn:aws:iam::111122223333:policy/my-policy --approve
```

**Importante**  
Se a função ou a conta de serviço já existir, o comando anterior poderá falhar. O `eksctl` tem opções diferentes que você pode oferecer nessas situações. Para obter mais informações, execute `eksctl create iamserviceaccount --help`.

### Criar e associar um perfil (AWS CLI)
<a name="create_and_associate_role_shared_aws_cli"></a>

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

1. 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
   ```

1. Defina o ID da conta da AWS como uma variável de ambiente com o comando a seguir.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Defina o provedor de identidade OIDC do cluster como uma variável de ambiente com o comando a seguir. Substitua *my-cluster* pelo nome do cluster.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Defina variáveis para o namespace e o nome da conta de serviço. Substitua *my-service-account* pela conta de serviço do Kubernetes que você deseja que assuma o perfil. Substitua *default* (padrão) pelo namespace da conta de serviço.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Execute o seguinte comando para criar um arquivo de política de confiança para o perfil do IAM. Se você quiser permitir que todas as contas de serviço em um namespace usem o perfil, copie o conteúdo a seguir para o seu dispositivo. Substitua *StringEquals* por `StringLike` e substitua *\$1service\$1account* por `*`. É possível adicionar várias entradas nas condições `StringEquals` ou `StringLike` abaixo para permitir que várias contas de serviço ou namespaces assumam o perfil. Para permitir que perfis de uma conta da AWS diferente da conta em que seu cluster está assumam o perfil, consulte [Autenticar em outra conta com IRSA](cross-account-access.md) para obter mais informações.

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::123456789012:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   ```

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::$account_id:policy/my-policy
   ```

1. Anote sua conta de serviço com o nome do recurso da Amazon (ARN) do perfil do IAM que você deseja que a conta de serviço assuma. Substitua *my-role* pelo nome do seu perfil do IAM existente. Suponha que você tenha permitido que um perfil de uma conta AWS diferente da conta na qual seu cluster está assumisse o perfil em uma etapa anterior. Em seguida, certifique-se de especificar a conta AWS e o perfil da outra conta. Para obter mais informações, consulte [Autenticar em outra conta com IRSA](cross-account-access.md).

   ```
   kubectl annotate serviceaccount -n $namespace $service_account eks.amazonaws.com/role-arn=arn:aws:iam::$account_id:role/my-role
   ```

1. (Opcional) [Configure o endpoint do AWS Security Token Service para uma conta de serviço.](configure-sts-endpoint.md) A AWS recomenda o uso de um endpoint regional do AWS STS em vez do endpoint global. Isso reduz a latência, fornece redundância integrada e aumenta a validade do token da sessão.

## Etapa 3: confirmar a configuração
<a name="irsa-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": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
               },
               "Action": "sts:AssumeRoleWithWebIdentity",
               "Condition": {
                   "StringEquals": {
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:default:my-service-account",
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                   }
               }
           }
       ]
   }
   ```

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.

1. Verifique se a conta do serviço do Kubernetes está anotada com o perfil.

   ```
   kubectl describe serviceaccount my-service-account -n default
   ```

   Veja abaixo um exemplo de saída.

   ```
   Name:                my-service-account
   Namespace:           default
   Annotations:         eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/my-role
   Image pull secrets:  <none>
   Mountable secrets:   my-service-account-token-qqjfl
   Tokens:              my-service-account-token-qqjfl
   [...]
   ```

## Próximas etapas
<a name="_next_steps"></a>
+  [Configurar pods para usar uma conta de serviço do Kubernetes](pod-configuration.md)