

 **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.

# Conceder aos usuários do IAM acesso ao Kubernetes com um ConfigMap
<a name="auth-configmap"></a>

**Importante**  
O `aws-auth ConfigMap` está obsoleto. Para conhecer o método recomendado para gerenciar o acesso a APIs do Kubernetes, consulte [Conceder aos usuários do IAM acesso ao Kubernetes com entradas de acesso ao EKS](access-entries.md).

O acesso ao seu cluster usando [entidades principais do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) é ativado pelo [AWS IAM Authenticator for Kubernetes](https://github.com/kubernetes-sigs/aws-iam-authenticator#readme), que é executado no ambiente de gerenciamento do Amazon EKS. O autenticador obtém suas informações de configuração do `ConfigMap` `aws-auth`. Para todas as configurações do `ConfigMap` `aws-auth`, consulte [Formato de configuração completo](https://github.com/kubernetes-sigs/aws-iam-authenticator#full-configuration-format) no GitHub.

## Adicione um usuário do IAM ao cluster do Amazon EKS
<a name="aws-auth-users"></a>

Quando você cria um cluster do Amazon EKS, a [entidade principal do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) que cria o cluster, recebe automaticamente permissões `system:masters` na configuração de controle de acesso baseado em perfil (RBAC) no ambiente de gerenciamento do Amazon EKS. Como essa entidade principal não é exibida em nenhuma configuração visível, mantenha o controle de qual entidade principal criou o cluster originalmente. Para conceder a outras entidades principais do IAM a capacidade de interagir com o cluster, edite o `aws-auth ConfigMap` no Kubernetes e crie um `rolebinding` ou `clusterrolebinding` do Kubernetes com o nome de um `group` especificado no `aws-auth ConfigMap`.

**nota**  
Para obter mais informações sobre a configuração de controle de acesso baseado em perfil (RBAC) do Kubernetes, consulte [Using RBAC Authorization](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) na documentação do Kubernetes.

1. Determine quais credenciais o `kubectl` está usando para acessar o cluster. Em seu computador, você pode ver quais credenciais o `kubectl` usa com o comando a seguir. Substitua *\$1/.kube/config* pelo caminho do arquivo `kubeconfig` se você não usar o caminho padrão.

   ```
   cat ~/.kube/config
   ```

   Veja abaixo um exemplo de saída.

   ```
   [...]
   contexts:
   - context:
       cluster: my-cluster.region-code.eksctl.io
       user: admin@my-cluster.region-code.eksctl.io
     name: admin@my-cluster.region-code.eksctl.io
   current-context: admin@my-cluster.region-code.eksctl.io
   [...]
   ```

   No exemplo de saída anterior, as credenciais de um usuário chamado *admin* são configuradas para um cluster chamado *my-cluster*. Se for o usuário que criou o cluster, ele já terá acesso ao cluster. Se não for o usuário que criou o cluster, será necessário concluir as etapas restantes para habilitar o acesso ao cluster para os outras entidades principais do IAM. [As melhores práticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) recomendam que você conceda permissões para perfis e não para usuários. É possível ver quais outras entidades principais atualmente têm acesso ao cluster com o seguinte comando:

   ```
   kubectl describe -n kube-system configmap/aws-auth
   ```

   Veja um exemplo de saída abaixo.

   ```
   Name:         aws-auth
   Namespace:    kube-system
   Labels:       <none>
   Annotations:  <none>
   
   Data
   ====
   mapRoles:
   ----
   - groups:
     - system:bootstrappers
     - system:nodes
     rolearn: arn:aws:iam::111122223333:role/my-node-role
     username: system:node:{{EC2PrivateDNSName}}
   
   
   BinaryData
   ====
   
   Events:  <none>
   ```

   O exemplo anterior é um `aws-auth` `ConfigMap` padrão. Apenas a função de instância de nó tem acesso ao cluster.

1. Verifique se você já tem `roles` e `rolebindings` ou `clusterroles` e `clusterrolebindings` do Kubernetes para os quais é possível mapear as entidades principais do IAM. Para saber mais sobre esses recursos, consulte [Usar a autorização de RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/), na documentação do Kubernetes.

   1. Visualize suas `roles` ou `clusterroles` existentes do Kubernetes. `Roles` têm o escopo definido para um `namespace`, mas `clusterroles` têm o escopo definido para o cluster.

      ```
      kubectl get roles -A
      ```

      ```
      kubectl get clusterroles
      ```

   1. Visualize os detalhes de qualquer `role` ou `clusterrole` retornada no resultado anterior e confirme que ela tem as permissões (`rules`) que você quer que as entidades principais do IAM tenham no cluster.

      Substitua *role-name* por um nome de `role` retornado na saída do comando anterior. Substitua *kube-system* pelo namespace da `role`.

      ```
      kubectl describe role role-name -n kube-system
      ```

      Substitua *cluster-role-name* por um nome de `clusterrole` retornado na saída do comando anterior.

      ```
      kubectl describe clusterrole cluster-role-name
      ```

   1. Visualize suas `rolebindings` ou `clusterrolebindings` existentes do Kubernetes. `Rolebindings` têm o escopo definido para um `namespace`, mas `clusterrolebindings` têm o escopo definido para o cluster.

      ```
      kubectl get rolebindings -A
      ```

      ```
      kubectl get clusterrolebindings
      ```

   1. Visualize os detalhes de qualquer `rolebinding` ou `clusterrolebinding` e confirme que ele tem uma `role` ou `clusterrole` da etapa anterior listada como `roleRef` e um nome de grupo listado para `subjects`.

      Substitua *role-binding-name* por um nome de `rolebinding` retornado na saída do comando anterior. Substitua *kube-system* pelo `namespace` da `rolebinding`.

      ```
      kubectl describe rolebinding role-binding-name -n kube-system
      ```

      Veja abaixo um exemplo de saída.

      ```
      apiVersion: rbac.authorization.k8s.io/v1
      kind: RoleBinding
      metadata:
        name: eks-console-dashboard-restricted-access-role-binding
        namespace: default
      subjects:
      - kind: Group
        name: eks-console-dashboard-restricted-access-group
        apiGroup: rbac.authorization.k8s.io
      roleRef:
        kind: Role
        name: eks-console-dashboard-restricted-access-role
        apiGroup: rbac.authorization.k8s.io
      ```

      Substitua *cluster-role-binding-name* por um nome de `clusterrolebinding` retornado na saída do comando anterior.

      ```
      kubectl describe clusterrolebinding cluster-role-binding-name
      ```

      Veja abaixo um exemplo de saída.

      ```
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: eks-console-dashboard-full-access-binding
      subjects:
      - kind: Group
        name: eks-console-dashboard-full-access-group
        apiGroup: rbac.authorization.k8s.io
      roleRef:
        kind: ClusterRole
        name: eks-console-dashboard-full-access-clusterrole
        apiGroup: rbac.authorization.k8s.io
      ```

1. Edite o `ConfigMap` `aws-auth`. É possível usar uma ferramenta como o `eksctl` para atualizar o `ConfigMap`, ou você pode atualizá-lo manualmente via edição.
**Importante**  
Convém usar `eksctl` ou outra ferramenta para editar o `ConfigMap`. Para obter informações sobre outras ferramentas que você pode usar, consulte [Usar ferramentas para fazer alterações no aws-authConfigMap](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#use-tools-to-make-changes-to-the-aws-auth-configmap) nos guias de práticas recomendadas do Amazon EKS. Um `aws-auth` `ConfigMap` formatado incorretamente pode fazer com que você perca o acesso ao cluster.
   + Veja as etapas para [editar o configmap com eksctl](#configmap-eksctl).
   + Veja as etapas para [editar o configmap manualmente](#configmap-manual).

### Editar o configmap com eksctl
<a name="configmap-eksctl"></a>

1. Você precisa da versão `0.215.0` ou posterior da ferramenta de linha de comando da `eksctl` instalada no seu dispositivo ou AWS CloudShell. Para instalar ou atualizar o `eksctl`, consulte [Instalação](https://eksctl.io/installation) na documentação do `eksctl`.

1. Visualize os mapeamentos atuais no `ConfigMap`. Substitua *my-cluster* pelo nome do cluster. Substitua *region-code* pela região da AWS em que seu cluster se encontra.

   ```
   eksctl get iamidentitymapping --cluster my-cluster --region=region-code
   ```

   Veja um exemplo de saída abaixo.

   ```
   ARN                                                                                             USERNAME                                GROUPS                          ACCOUNT
   arn:aws:iam::111122223333:role/eksctl-my-cluster-my-nodegroup-NodeInstanceRole-1XLS7754U3ZPA    system:node:{{EC2PrivateDNSName}}       system:bootstrappers,system:nodes
   ```

1. Adicione um mapeamento referente a uma função. Substitua *my-role* pelo nome da sua função. Substitua *eks-console-dashboard-full-access-group* pelo nome do grupo especificado no objeto `RoleBinding` ou `ClusterRoleBinding` do Kubernetes. Substitua *111122223333* pelo ID da sua conta. Você pode substituir *admin* por qualquer nome que escolher.

   ```
   eksctl create iamidentitymapping --cluster my-cluster --region=region-code \
       --arn arn:aws:iam::111122223333:role/my-role --username admin --group eks-console-dashboard-full-access-group \
       --no-duplicate-arns
   ```
**Importante**  
O ARN da função não pode incluir um caminho, como `role/my-team/developers/my-role`. O formato do ARN deve ser ` arn:aws:iam::111122223333:role/my-role `. Neste exemplo, `my-team/developers/` precisa ser removido.

   Veja um exemplo de saída abaixo.

   ```
   [...]
   2022-05-09 14:51:20 [ℹ]  adding identity "{arn-aws}iam::111122223333:role/my-role" to auth ConfigMap
   ```

1. Adicione um mapeamento referente a um usuário. [As melhores práticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) recomendam que você conceda permissões para perfis e não para usuários. Substitua *my-user* pelo seu nome de usuário. Substitua *eks-console-dashboard-restricted-access-group* pelo nome do grupo especificado na `RoleBinding` ou `ClusterRoleBinding` do Kubernetes. Substitua *111122223333* pelo ID da sua conta. Você pode substituir *my-user* por qualquer nome que escolher.

   ```
   eksctl create iamidentitymapping --cluster my-cluster --region=region-code \
       --arn arn:aws:iam::111122223333:user/my-user --username my-user --group eks-console-dashboard-restricted-access-group \
       --no-duplicate-arns
   ```

   Veja um exemplo de saída abaixo.

   ```
   [...]
   2022-05-09 14:53:48 [ℹ]  adding identity "arn:aws:iam::111122223333:user/my-user" to auth ConfigMap
   ```

1. Visualize os mapeamentos no `ConfigMap` novamente.

   ```
   eksctl get iamidentitymapping --cluster my-cluster --region=region-code
   ```

   Veja abaixo um exemplo de saída.

   ```
   ARN                                                                                             USERNAME                                GROUPS                                  ACCOUNT
   arn:aws:iam::111122223333:role/eksctl-my-cluster-my-nodegroup-NodeInstanceRole-1XLS7754U3ZPA    system:node:{{EC2PrivateDNSName}}       system:bootstrappers,system:nodes
   arn:aws:iam::111122223333:role/admin                                                            my-role                                 eks-console-dashboard-full-access-group
   arn:aws:iam::111122223333:user/my-user                                                          my-user                                 eks-console-dashboard-restricted-access-group
   ```

### Editar o configmap manualmente
<a name="configmap-manual"></a>

1. Abra o `ConfigMap` para edição.

   ```
   kubectl edit -n kube-system configmap/aws-auth
   ```
**nota**  
Se você receber um erro informando "`Error from server (NotFound): configmaps "aws-auth" not found`", use o procedimento em [Aplicar o ConfigMap aws-auth ao seu cluster](#aws-auth-configmap) para aplicar o estoque `ConfigMap`.

1. Adicione as entidades principais do IAM ao `ConfigMap`. Um grupo do IAM não é uma entidade principal do IAM, portanto, não pode ser adicionado ao `ConfigMap`.
   +  **Para adicionar uma função do IAM (por exemplo, para [usuários federados](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html)):** adicione os detalhes da função à seção `mapRoles` do `ConfigMap` em `data`. Adicione essa seção se ela ainda não existir no arquivo. Cada entrada oferece suporte aos seguintes parâmetros:
     +  **rolearn**: o ARN da função do IAM a ser adicionada. Esse valor não pode incluir um caminho. Por exemplo, não é possível especificar um ARN como ` arn:aws:iam::111122223333:role/my-team/developers/role-name `. O ARN precisa ser ` arn:aws:iam::111122223333:role/role-name `.
     +  **username**: o nome do usuário no Kubernetes a ser mapeado para a função do IAM.
     +  **groups**: o grupo ou a lista de grupos do Kubernetes para o qual mapear a função. O grupo pode ser padrão ou um grupo especificado em um `clusterrolebinding` ou `rolebinding`. Para obter mais informações, consulte [Default roles and role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#default-roles-and-role-bindings) na documentação do Kubernetes.
   +  **Para adicionar um usuário do IAM:** [as melhores práticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) recomendam que você conceda permissões para perfis e não para usuários. Adicione os detalhes do usuário à seção `mapUsers` do `ConfigMap` em `data`. Adicione essa seção se ela ainda não existir no arquivo. Cada entrada oferece suporte aos seguintes parâmetros:
     +  **userarn**: o ARN do usuário do IAM a ser adicionado.
     +  **username**: o nome do usuário no Kubernetes a ser mapeado para o usuário do IAM.
     +  **groups**: o grupo, ou a lista de grupos, do Kubernetes para o qual mapear o usuário. O grupo pode ser padrão ou um grupo especificado em um `clusterrolebinding` ou `rolebinding`. Para obter mais informações, consulte [Default roles and role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#default-roles-and-role-bindings) na documentação do Kubernetes.

1. Por exemplo, o seguinte bloco YAML contém:
   + Uma seção `mapRoles` que mapeia a instância do nó do IAM para grupos do Kubernetes, para que os nós possam se registrar no cluster e o perfil do IAM `my-console-viewer-role` que é mapeado para um grupo do Kubernetes que pode visualizar todos os recursos do Kubernetes para todos os clusters. Para acessar uma lista das permissões de grupos do IAM e do Kubernetes necessárias para o perfil do IAM `my-console-viewer-role`, consulte [Permissões obrigatórias](view-kubernetes-resources.md#view-kubernetes-resources-permissions).
   + Uma seção `mapUsers` que mapeia o usuário do IAM `admin` da conta da AWS padrão para o grupo do Kubernetes `system:masters` e o usuário `my-user` de uma conta da AWS diferente mapeada para um grupo do Kubernetes que pode visualizar recursos do Kubernetes de um namespace específico. Para acessar uma lista das permissões de grupos do IAM e do Kubernetes necessárias para o usuário do IAM `my-user`, consulte [Permissões obrigatórias](view-kubernetes-resources.md#view-kubernetes-resources-permissions).

     Adicione ou remova linhas conforme necessário e substitua todos os valores de exemplo por seus próprios valores.

     ```
     # Please edit the object below. Lines beginning with a '#' will be ignored,
     # and an empty file will abort the edit. If an error occurs while saving this file will be
     # reopened with the relevant failures.
     #
     apiVersion: v1
     data:
       mapRoles: |
         - groups:
           - system:bootstrappers
           - system:nodes
           rolearn: arn:aws:iam::111122223333:role/my-role
           username: system:node:{{EC2PrivateDNSName}}
         - groups:
           - eks-console-dashboard-full-access-group
           rolearn: arn:aws:iam::111122223333:role/my-console-viewer-role
           username: my-console-viewer-role
       mapUsers: |
         - groups:
           - system:masters
           userarn: arn:aws:iam::111122223333:user/admin
           username: admin
         - groups:
           - eks-console-dashboard-restricted-access-group
           userarn: arn:aws:iam::444455556666:user/my-user
           username: my-user
     ```

1. Salve o arquivo e saia do seu editor de texto.

## Como aplicar o `ConfigMap` `aws-auth` ao seu cluster
<a name="aws-auth-configmap"></a>

O `ConfigMap` `aws-auth` é criado e aplicado automaticamente ao cluster ao criar um grupo de nós gerenciados ou ao criar um grupo de nós usando `eksctl`. Ele é criado inicialmente para permitir que os nós ingressem no cluster, mas você também pode usar esse `ConfigMap` para adicionar acesso com controle de acesso baseado em função (RBAC) às entidades principais do IAM. Se já tiver iniciado os nós autogerenciados, mas ainda não tiver aplicado o `ConfigMap` `aws-auth` ao seu cluster, você poderá fazer isso usando o procedimento a seguir.

1. Verifique se você já aplicou o `ConfigMap` `aws-auth`.

   ```
   kubectl describe configmap -n kube-system aws-auth
   ```

   Se você receber um erro informando " `Error from server (NotFound): configmaps "aws-auth" not found` ", prossiga com as etapas a seguir para aplicar o estoque `ConfigMap`.

1. Faça download, edite e aplique o mapa de configuração do autenticador da AWS.

   1. Faça download do mapa de configuração.

      ```
      curl -O https://s3.us-west-2.amazonaws.com/amazon-eks/cloudformation/2020-10-29/aws-auth-cm.yaml
      ```

   1. No arquivo `aws-auth-cm.yaml`, defina o `rolearn` como o nome de recurso da Amazon (ARN) da função do IAM associada aos seus nós. Você pode fazer isso com um editor de texto ou substituindo *my-node-instance-role* e executando o seguinte comando:

      ```
      sed -i.bak -e 's|<ARN of instance role (not instance profile)>|my-node-instance-role|' aws-auth-cm.yaml
      ```

      Não modifique outras linhas do arquivo.
**Importante**  
O ARN da função não pode incluir um caminho, como `role/my-team/developers/my-role`. O formato do ARN deve ser ` arn:aws:iam::111122223333:role/my-role `. Neste exemplo, `my-team/developers/` precisa ser removido.

      Você pode inspecionar as saídas da pilha do AWS CloudFormation para seus grupos de nós e procurar os seguintes valores:
      +  **InstanceRoleARN**: para grupos de nós que foram criados com `eksctl` 
      +  **NodeInstanceRole** - Para grupos de nós que foram criados com os modelos do Amazon EKS fornecidos pelo AWS CloudFormation no Console de gerenciamento da AWS 

   1. Aplique a configuração. Esse comando pode demorar alguns minutos para ser concluído.

      ```
      kubectl apply -f aws-auth-cm.yaml
      ```
**nota**  
Se você receber qualquer erro de autorização ou de tipo de recurso, consulte [Acesso negado ou não autorizado (`kubectl`)](troubleshooting.md#unauthorized) no tópico de solução de problemas.

1. Observe o status de seus nós e aguarde até que eles atinjam o status `Ready`.

   ```
   kubectl get nodes --watch
   ```

   Insira `Ctrl`\$1`C` para retornar a um prompt de shell.