Adicione um usuário do IAM ao cluster do Amazon EKS Como aplicar o ConfigMapaws-auth ao seu cluster

Conceder aos usuários do IAM acesso ao Kubernetes com um ConfigMap

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.

O acesso ao seu cluster usando entidades principais do IAM é ativado pelo AWS IAM Authenticator for Kubernetes, 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 do aws-auth, consulte Full Configuration Format (Formato de configuração completo) no GitHub.

Adicione um usuário do IAM ao cluster do Amazon EKS

Quando você cria um cluster do Amazon EKS, a entidade principal do IAM 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 em aws-auth ConfigMap.

nota

Para obter mais informações sobre a configuração de controle de acesso baseado em função (RBAC) do Kubernetes, consulte Using RBAC Authorization (Usar autorização RBAC) na documentação do Kubernetes.

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 ~/.kube/config pelo caminho do arquivo kubeconfig se você não usar o caminho padrão.
```
cat ~/.kube/config
```
Veja um exemplo de saída abaixo.
```
[...]
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 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.
Verifique se você tem as roles e rolebindings ou clusterroles e clusterrolebindings existentes do Kubernetes para as quais é possível mapear as entidades principais do IAM. Para saber mais sobre esses recursos, consulte Using RBAC Authorization (Usar autorização RBAC) na documentação do Kubernetes.
1. Visualize as roles e clusterroles existentes do Kubernetes. As 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
```
2. 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
```
3. Visualize as rolebindings e clusterrolebindings existentes do Kubernetes. As 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
```
4. 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 um exemplo de saída abaixo.
```
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 um exemplo de saída abaixo.
```
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
```
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 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.
- Veja as etapas para editar o configmap manualmente.

Editar o configmap com eksctl

Você precisa da versão 0.199.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 na documentação do eksctl.

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

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 seu objeto Kubernetes RoleBinding ou ClusterRoleBinding. 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
```
Adicione um mapeamento referente a um usuário. As melhores práticas do IAM 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 no seu objeto Kubernetes RoleBinding ou ClusterRoleBinding. 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
```

Visualize os mapeamentos no ConfigMap novamente.


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

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 para aplicar o estoque ConfigMap.
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): 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 o perfil 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 Perfis padrão e vinculações de perfis na documentação do Kubernetes.
- Para adicionar um usuário do IAM: as melhores práticas do IAM 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 (nomeusuário): o nome do usuário no Kubernetes a ser mapeado para o usuário do IAM.
  - groups (grupos): 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 Perfis padrão e vinculações de perfis na documentação do Kubernetes.
Por exemplo, o seguinte bloco YAML contém:
- Uma seção mapRoles que mapeia a instância de 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 obter 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.
- Uma seção mapUsers que mapeia o usuário do IAM admin da conta da AWS padrão para o grupo system:masters do Kubernetes 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 dos grupos do IAM e do Kubernetes necessárias para o usuário do IAM my-user, consulte Permissões obrigatórias.
  
  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
```
Salve o arquivo e saia do seu editor de texto.

Como aplicar o `ConfigMapaws-auth` ao seu cluster

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.

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.
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
```
2. 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 AWS Management Console
3. 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) no tópico de solução de problemas.
Observe o status de seus nós e aguarde até que eles atinjam o status Ready.
```
kubectl get nodes --watch
```
Insira Ctrl+C para retornar a um prompt de shell.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Analisar permissões da política de acesso

Conceda aos usuários acesso ao Kubernetes com um provedor OIDC externo