AWS IAM Authenticator for Kubernetes

Uma ferramenta para usar credenciais AWS IAM para autenticar em um cluster Kubernetes. O trabalho inicial nesta ferramenta foi conduzido pela Heptio. O projeto recebe contribuições de vários engenheiros da comunidade e atualmente é mantido pela Heptio e pelos engenheiros de OSS da Amazon EKS.

Índice

• Por que eu quero isso?
• Como eu uso?
• Uso do Kops
• Como funciona?
• O que é um ID de cluster?
• Especificando credenciais e usando perfis AWS
• Autorização de API fora de um cluster
• Solução de problemas
• Formato completo de configuração
• Desenvolvimento
• Comunidade, discussão, contribuição e suporte

Por que eu quero isso?

Se você é um administrador executando um cluster Kubernetes na AWS, você já precisa gerenciar credenciais AWS IAM para provisionar e atualizar o cluster. Ao usar o AWS IAM Authenticator for Kubernetes, você evita ter que gerenciar uma credencial separada para acesso ao Kubernetes. O AWS IAM também fornece uma série de propriedades interessantes, como uma trilha de auditoria fora de banda (via CloudTrail) e aplicação de 2FA/MFA.

Se você está construindo um instalador Kubernetes na AWS, o AWS IAM Authenticator for Kubernetes pode simplificar seu processo de bootstrap. Você não precisará, de alguma forma, contrabandear com segurança sua credencial inicial de administrador para fora do cluster recém-instalado. Em vez disso, você pode criar uma função dedicada KubernetesAdmin no momento do provisionamento do cluster e configurar o Authenticator para permitir logins de administradores de cluster.

Como eu uso?

Supondo que você tenha um cluster em execução na AWS e queira adicionar suporte ao AWS IAM Authenticator for Kubernetes, você precisa:

1. Criar uma função IAM que você usará para identificar usuários.
2. Executar o servidor Authenticator como um DaemonSet.
3. Configurar seu servidor de API para falar com o Authenticator.
4. Configurar o kubectl para usar tokens do Authenticator.

1. Criar uma função IAM

Primeiro, você deve criar uma ou mais funções IAM que serão mapeadas para usuários/grupos dentro do seu cluster Kubernetes. A maneira mais fácil de fazer isso é entrar no Console AWS:

• Escolha a opção "Função para acesso entre contas" / "Fornecer acesso entre contas AWS que você possui".
• Cole o número do seu ID de conta AWS (disponível no canto superior direito do console).
• Sua função não precisa de nenhuma política adicional anexada.

Isso criará uma função IAM sem permissões que pode ser assumida por usuários/funções autorizados na sua conta. Anote o Amazon Resource Name (ARN) da sua função, que você precisará abaixo.

Você também pode fazer isso em uma única etapa usando a AWS CLI em vez do Console AWS:```sh

get your account ID

ACCOUNT_ID=$(aws sts get-caller-identity --output text --query 'Account')

define a role trust policy that opens the role to users in your account (limited by IAM policy)

POLICY=$(echo -n '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::'; echo -n "$ACCOUNT_ID"; echo -n ':root"},"Action":"sts:AssumeRole","Condition":{}}]}')

create a role named KubernetesAdmin (will print the new role's ARN)

aws iam create-role
--role-name KubernetesAdmin
--description "Kubernetes administrator role (for AWS IAM Authenticator for Kubernetes)."
--assume-role-policy-document "$POLICY"
--output text
--query 'Role.Arn'

Você também pode pular esta etapa e usar:
 - Uma função existente (como uma função de acesso entre contas).
 - Um usuário IAM (veja `mapUsers` abaixo).
 - Uma instância EC2 ou uma função federada (veja `mapRoles` abaixo).

### 2. Execute o servidor
O servidor deve ser executado em cada um dos seus nós master como um DaemonSet com rede do host, para que possa expor uma porta localhost.

Para uma configuração de exemplo de ConfigMap e DaemonSet, veja [`deploy/example.yaml`](https://github.com/kubernetes-sigs/aws-iam-authenticator/blob/master/deploy/example.yaml).
Antes de aplicá-la, atualize estes valores para o seu cluster:
 - Substitua os ARNs de IAM de espaço reservado (`arn:aws:iam::000000000000:...`) em `config.yaml`.
 - Defina `clusterID` para um valor único para o seu cluster.
 - Verifique se as regras de agendamento do DaemonSet correspondem aos rótulos/taints dos seus nós do plano de controle.

Em seguida, implemente-o:```sh
kubectl apply -f deploy/example.yaml
kubectl -n kube-system rollout status daemonset/aws-iam-authenticator
kubectl -n kube-system get pods -l k8s-app=aws-iam-authenticator

Quando o pod estiver em execução em um nó do plano de controle, o aws-iam-authenticator server criará o kubeconfig do webhook no host em /etc/kubernetes/aws-iam-authenticator/kubeconfig.yaml (ou no caminho configurado via --generate-kubeconfig).

(Opcional) Pré-gerar um certificado, chave e kubeconfig

Se você estiver criando um instalador automatizado, também pode pré-gerar facilmente os arquivos de certificado, chave e kubeconfig do webhook usando aws-iam-authenticator init. Este comando gerará os arquivos e os colocará nos diretórios de saída configurados.

Você pode executar isso em cada nó mestre antes de iniciar o servidor de API. Você também pode gerá-los antes de provisionar os nós mestres e instalá-los nos caminhos de host apropriados.

Se você não pré-gerar os arquivos, o aws-iam-authenticator server os gerará sob demanda. Isso funciona, mas requer que você reinicie o servidor de API do Kubernetes após a instalação.

3. Configure seu servidor de API para se comunicar com o servidor

A API do Kubernetes integra-se ao AWS IAM Authenticator for Kubernetes usando um webhook de autenticação por token. Quando você executa aws-iam-authenticator server, ele gera um arquivo de configuração do webhook e o salva no sistema de arquivos do host. Você precisará adicionar um único flag adicional à configuração do seu servidor de API:``` --authentication-token-webhook-config-file=/etc/kubernetes/aws-iam-authenticator/kubeconfig.yaml

Em muitos clusters, o servidor de API é executado como um pod estático.
Você pode adicionar a flag a `/etc/kubernetes/manifests/kube-apiserver.yaml`.
Certifique-se de que o diretório do host `/etc/kubernetes/aws-iam-authenticator/` esteja montado no pod do seu servidor de API.
Você também pode precisar reiniciar o daemon kubelet no seu nó mestre para aplicar a definição atualizada do pod estático:```
systemctl restart kubelet.service

4. Criar mapeamentos de função/usuário IAM para usuário/grupo kubernetes

O comportamento padrão do servidor é buscar mapeamentos exclusivamente dos campos mapUsers e mapRoles do seu arquivo de configuração. Consulte Formato Completo de Configuração abaixo para detalhes.

Usando a flag --backend-mode, você pode configurar o servidor para buscar mapeamentos de dois backends adicionais: um ConfigMap no estilo EKS (--backend-mode=EKSConfigMap) ou recursos personalizados IAMIdentityMapping (--backend-mode=CRD). O backend padrão, o arquivo de configuração do servidor que é montado pelo pod do servidor, corresponde a --backend-mode=MountedFile.