AWS IAM Authenticator para Kubernetes

Uma ferramenta para usar credenciais do 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 isso?
• Uso com Kops
• Como funciona?
• O que é um cluster ID?
• Especificando Credenciais e Usando Perfis da AWS
• Autorização de API de 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 do AWS IAM para provisionar e atualizar o cluster. Ao usar o AWS IAM Authenticator para 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 a aplicação de 2FA/MFA.

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

Como eu uso isso?

Assumindo que você tem um cluster em execução na AWS e deseja adicionar suporte ao AWS IAM Authenticator para Kubernetes, você precisa:

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

1. Criar uma role IAM

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

• Escolha a opção "Role for cross-account access" / "Provide access between AWS accounts you own".
• Cole o número do ID da sua conta da AWS (disponível no canto superior direito do console).
• Sua role não precisa de nenhuma política adicional anexada.

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

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

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

Também pode ignorar este passo e usar:

• Uma função existente (como uma função de acesso entre contas).
• Um usuário IAM (ver mapUsers abaixo).
• Uma instância EC2 ou uma função federada (ver mapRoles abaixo).

2. Executar o servidor

O servidor destina-se a ser executado em cada um dos seus nós master como um DaemonSet com host networking, para que possa expor uma porta localhost.

Para um exemplo de configuração de ConfigMap e DaemonSet, ver deploy/example.yaml. Antes de o aplicar, atualize estes valores para o seu cluster:

• Substitua os ARNs IAM de exemplo (arn:aws:iam::000000000000:...) em config.yaml.
• Defina clusterID com um valor único para o seu cluster.
• Verifique se as regras de agendamento do DaemonSet correspondem às labels/taints dos seus nós control-plane.

Depois, implemente-o:

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 num nó de control-plane, o aws-iam-authenticator server criará o kubeconfig do webhook no host em /etc/kubernetes/aws-iam-authenticator/kubeconfig.yaml (ou no caminho configurado através de --generate-kubeconfig).

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

Se estiver a construir um instalador automatizado, também pode pré-gerar facilmente os ficheiros de certificado, chave e kubeconfig do webhook usando aws-iam-authenticator init. Este comando irá gerar ficheiros e colocá-los nos diretórios de saída configurados.

Pode executá-lo em cada nó master antes de iniciar o API server. Também pode gerá-los antes de provisionar os nós master e instalá-los nos caminhos de host apropriados.

Se não pré-gerar os ficheiros, o aws-iam-authenticator server irá gerá-los a pedido. Isto funciona, mas requer que reinicie o seu Kubernetes API server após a instalação.

3. Configurar o seu API server para comunicar com o servidor

A API do Kubernetes integra-se com o AWS IAM Authenticator for Kubernetes usando um webhook de autenticação por token. Quando executa aws-iam-authenticator server, este irá gerar um ficheiro de configuração de webhook e guardá-lo no sistema de ficheiros do host. Terá de adicionar um único flag adicional à configuração do seu API server:

--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 seu pod do servidor de API. Você também pode precisar reiniciar o daemon kubelet no seu nó master para que ele carregue 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 do kubernetes

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

Usando a flag --backend-mode, você pode configurar o servidor para obter 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.