Prendemos a autorização LDAP ao Kubernetes

Um breve tutorial sobre como usar o Kubernetes para conectar o Kubernetes ao servidor LDAP e configurar a importação de usuários e grupos usando o Keycloak. Isso permitirá que você configure o RBAC para seus usuários e use o proxy de autenticação para proteger o Kubernetes Dashboard e outros aplicativos que não podem se autorizar.

Instalar Keycloak

Suponha que você já tenha um servidor LDAP. Pode ser Active Directory, FreeIPA, OpenLDAP ou qualquer outra coisa. Se você não possui um servidor LDAP, em princípio, pode criar usuários diretamente na interface do Keycloak ou usar provedores públicos de OIDC (Google, Github, Gitlab), o resultado será quase o mesmo.

Primeiro, instalaremos o Keycloak em si, a instalação pode ser realizada separadamente e, imediatamente, no cluster Kubernetes, como regra, se você tiver vários clusters Kubernetes, seria mais fácil instalá-lo separadamente. Por outro lado, você sempre pode usar o gráfico oficial de leme e instalá-lo diretamente no seu cluster.

Para armazenar dados do Keycloak, você precisa de um banco de dados. Por padrão, h2 usado (todos os dados são armazenados localmente), mas também é possível usar o postgres , mysql ou mariadb .
Se você ainda decidir instalar o Keycloak separadamente, encontrará instruções mais detalhadas na documentação oficial .

Configuração da federação

Primeiro, crie um novo domínio. Domínio é o espaço da nossa aplicação. Cada aplicativo pode ter seu próprio território com diferentes usuários e configurações de autorização. O domínio mestre é usado pelo próprio Keycloak e não é correto usá-lo para qualquer outra coisa.

Clique em Adicionar região

O Kubernetes, por padrão, verifica se o usuário tem um email ou não. Como usamos nosso próprio servidor LDAP, essa verificação quase sempre retorna false . Vamos desligar a representação deste parâmetro no Kubernetes:

Escopos do cliente -> Email -> Mapeadores -> Email verificado (Excluir)

Agora configure a federação, para isso iremos a:

Federação do usuário -> Adicionar provedor ... -> ldap

Aqui está um exemplo de configuração para o FreeIPA:

O usuário keycloak-svc deve ser criado com antecedência em nosso servidor LDAP.

No caso do Active Directory, basta selecionar Fornecedor: Active Directory e as configurações necessárias são preenchidas automaticamente no formulário.

Clique em Save

Agora vamos seguir em frente:

Federação do usuário -> freeipa.example.org -> Mapeadores -> Nome

Agora ative o mapeamento de grupo:

Federação do usuário -> freeipa.example.org -> Mapeadores -> Criar

Isso completa a configuração da federação, vamos seguir para a configuração do cliente.

Configuração do cliente

Crie um novo cliente (um aplicativo que receberá usuários do Keycloak). Passamos:

Clientes -> Criar

Crie também escopo para grupos:

Escopos do cliente -> Criar

E configure o mapeador para eles:

Escopos do cliente -> grupos -> Mapeadores -> Criar

Agora, precisamos ativar o grupo de mapeamento em nosso escopo de cliente:

Clientes -> kubernetes -> Escopos do cliente -> Escopos do cliente padrão

Selecione grupos em escopos de cliente disponíveis , clique em Adicionar selecionado

Agora configure a autenticação do nosso aplicativo, vá para:

Clientes -> kubernetes

Clique em Salvar e isso conclui a configuração do cliente, agora na guia

Clientes -> kubernetes -> Credenciais

Você pode obter o segredo que usaremos no futuro.

Configurar o Kubernetes

Configurar o Kubernetes para autenticação OIDC é bastante trivial e não é muito complicado. Tudo o que você precisa fazer é colocar o certificado CA do servidor /etc/kubernetes/pki/oidc-ca.pem em /etc/kubernetes/pki/oidc-ca.pem e adicionar as opções necessárias para o kube-apiserver.
Para fazer isso, atualize /etc/kubernetes/manifests/kube-apiserver.yaml em todos os seus assistentes:

 ... spec: containers: - command: - kube-apiserver ... - --oidc-ca-file=/etc/kubernetes/pki/oidc-ca.pem - --oidc-client-id=kubernetes - --oidc-groups-claim=groups - --oidc-issuer-url=https://keycloak.example.org/auth/realms/kubernetes - --oidc-username-claim=email ... 

E também atualize a configuração do kubeadm no cluster, para não perder essas configurações ao atualizar:

 kubectl edit -n kube-system configmaps kubeadm-config 

 ... data: ClusterConfiguration: | apiServer: extraArgs: oidc-ca-file: /etc/kubernetes/pki/oidc-ca.pem oidc-client-id: kubernetes oidc-groups-claim: groups oidc-issuer-url: https://keycloak.example.org/auth/realms/kubernetes oidc-username-claim: email ... 

Isso completa a instalação do Kubernetes. Você pode repetir essas etapas em todos os seus clusters Kubernetes.

Autorização inicial

Após essas etapas, você já terá um cluster Kubernetes com autenticação OIDC configurada. O único ponto é que seus usuários não têm um cliente configurado, assim como seu próprio kubeconfig. Para resolver esse problema, você precisa configurar a emissão automática do kubeconfig para os usuários após a autorização bem-sucedida.

Para fazer isso, você pode usar aplicativos da web especiais que permitem autenticar o usuário e fazer o download do kubeconfig finalizado. Um dos mais convenientes é o Kuberos , que permite descrever todos os clusters do Kubernetes em uma configuração e alternar facilmente entre eles.

Para configurar o Kuberos, apenas descreva o modelo para o kubeconfig e execute com os seguintes parâmetros:

 kuberos https://keycloak.example.org/auth/realms/kubernetes kubernetes /cfg/secret /cfg/template 

Consulte Uso no Github para mais detalhes.

Também é possível usar o kubelogin se você deseja autorizar diretamente no computador do usuário. Nesse caso, o usuário abre um navegador com um formulário de autorização no host local.

O kubeconfig resultante pode ser verificado em jwt.io. Apenas copie o valor dos users[].user.auth-provider.config.id-token do seu kubeconfig para o formulário no site e obtenha imediatamente a descriptografia.

Configuração RBAC

Ao configurar o RBAC, você pode consultar o nome de usuário (o campo de name no token jwt) e o grupo de usuários (o campo de groups no token jwt). Aqui está um exemplo de configuração de permissões para o grupo kubernetes-default-namespace-admins :

 apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: default-admins namespace: default rules: - apiGroups: - '*' resources: - '*' verbs: - '*' --- apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: kubernetes-default-namespace-admins namespace: default roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: default-admins subjects: - apiGroup: rbac.authorization.k8s.io kind: Group name: kubernetes-default-namespace-admins 

Mais exemplos de RBAC podem ser encontrados na documentação oficial do Kubernetes.

Configurar o proxy de autenticação

Existe um maravilhoso projeto keycloak-gatekeeper que permite proteger qualquer aplicativo, permitindo ao usuário se autenticar no servidor OIDC. Vou mostrar como você pode configurá-lo usando o Kubernetes Dashboard como um exemplo:

 apiVersion: extensions/v1beta1 kind: Deployment metadata: name: kubernetes-dashboard-proxy spec: replicas: 1 template: metadata: labels: app: kubernetes-dashboard-proxy spec: containers: - args: - --listen=0.0.0.0:80 - --discovery-url=https://keycloak.example.org/auth/realms/kubernetes - --client-id=kubernetes - --client-secret=<your-client-secret-here> - --redirection-url=https://kubernetes-dashboard.example.org - --enable-refresh-tokens=true - --encryption-key=ooTh6Chei1eefooyovai5ohwienuquoh - --upstream-url=https://kubernetes-dashboard.kube-system - --resources=uri=/* image: keycloak/keycloak-gatekeeper name: kubernetes-dashboard-proxy ports: - containerPort: 80 livenessProbe: httpGet: path: /oauth/health port: 80 initialDelaySeconds: 3 timeoutSeconds: 2 readinessProbe: httpGet: path: /oauth/health port: 80 initialDelaySeconds: 3 timeoutSeconds: 2 --- apiVersion: v1 kind: Service metadata: name: kubernetes-dashboard-proxy spec: ports: - port: 80 protocol: TCP targetPort: 80 selector: app: kubernetes-dashboard-proxy type: ClusterIP