Integrando a autenticação LDAP ao Kubernetes

Um pequeno guia sobre como usar o Keycloak para vincular o Kubernetes ao seu servidor LDAP e configurar a importação de usuários e grupos. Isso permitirá configurar o RBAC para seus usuários e usar o auth-proxy para proteger o Kubernetes Dashboard e outros aplicativos que não conseguem autenticar por conta própria.

Instalação do Keycloak

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

Primeiramente, vamos instalar o Keycloak. A instalação pode ser feita separadamente ou diretamente no cluster Kubernetes. Normalmente, se você tiver vários clusters Kubernetes, seria mais fácil instalá-lo separadamente. Por outro lado, você sempre pode usar o chart helm oficial e instalá-lo diretamente em seu cluster.

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

Configuração da federação

Primeiramente, vamos criar um novo realm. Um realm é o espaço do nosso aplicativo. Cada aplicativo pode ter seu próprio realm com diferentes usuários e configurações de autenticação. O realm Master é usado pelo próprio Keycloak e não é apropriado utilizá-lo para mais nada.

Clique em Adicionar realm

Opção
Valor

Nome
kubernetes

Nome de exibição
Kubernetes

Nome de exibição em HTML
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

O Kubernetes, por padrão, verifica se o e-mail do usuário está confirmado ou não. Como estamos usando nosso próprio servidor LDAP, essa verificação quase sempre retornará falso. Vamos desabilitar a apresentação desse parâmetro no Kubernetes:

Escopos de cliente —> Email —> Mappers —> Email verificado (Excluir)

Agora vamos configurar a federação, para isso, vamos para:

Federação de usuários —> Adicionar provedor… —> ldap

Vou dar um exemplo de configuração para FreeIPA:

Opção
Valor

Nome de exibição do console
freeipa.exemplo.org

Fornecedor
Red Hat Directory Server

Atributo UUID LDAP
ipauniqueid

URL de conexão
ldaps://freeipa.example.org

DN dos usuários
cn=usuários,cn=accounts,dc=exemplo,dc=org

DN de ligação
uid=keycloak-svc,cn=users,cn=accounts,dc=exemplo,dc=org

Credencial de ligação
<senha>

Permitir autenticação Kerberos:
ativado

Reino Kerberos:
EXAMPLE.ORG

Principal do servidor:
HTTP/freeipa.exemplo.org@EXAMPLE.ORG

KeyTab:
/etc/krb5.keytab

O usuário keycloak-svc precisa ser criado previamente em nosso servidor LDAP.

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

Clique em Salvar

Agora vamos para:

Federação de usuários —> freeipa.exemplo.org —> Mappers —> Primeiro Nome

Opção
Valor

Atributo Ldap
givenName

Agora vamos ativar o mapeamento de grupos:

Federação de usuários —> freeipa.exemplo.org —> Mappers —> Criar

Opção
Valor

Nome
grupos

Tipo de Mapeador
group-ldap-mapper

LDAP Groups DN
cn=groups,cn=accounts,dc=example,dc=org

Estratégia de Recuperação de Grupos de Usuários
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Com isso, a configuração da federação está completa, vamos para a configuração do cliente.

Configuração do Cliente

Vamos criar um novo cliente (aplicativo que receberá usuários do Keycloak). Vamos para:

Clientes —> Criar

Opção
Valor

ID do Cliente
kubernetes

Tipo de Acesso
confidenrial

URL Raiz
http://kubernetes.example.org/

URIs de Redirecionamento Válidos
http://kubernetes.example.org/*

URL do Admin
http://kubernetes.example.org/

Também criaremos um escopo para grupos:

Escopos do Cliente —> Criar

Opção
Valor

Modelo
Sem modelo

Nome
grupos

Caminho completo do grupo
falso

E vamos configurar o mapeador para eles:

Escopos do Cliente —> grupos —> Mappers —> Criar

Opção
Valor

Nome
grupos

Tipo de Mapeador
Membro do Grupo

Nome da Reivindicação do Token
grupos

Agora precisamos ativar o mapeamento de grupos em nosso escopo de cliente:

Clientes —> kubernetes —> Escopos do Cliente —> Escopos Padrão do Cliente

Escolhendo grupos em Escopos de Cliente Disponíveis, clicamos em Adicionar selecionados

Agora vamos configurar a autenticação do nosso aplicativo, vamos para:

Clientes —> kubernetes

Opção
Valor

Autorização Habilitada
ATIVADO

Clicaremos em salvar e assim a configuração do cliente está concluída, agora na aba

Clientes —> kubernetes —> Credenciais

você poderá obter Segredo que usaremos posteriormente.

Configuração do Kubernetes

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

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

Além disso, atualize a configuração do kubeadm no cluster para não perder essas configurações durante a atualização:

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

Com isso, a configuração do Kubernetes está concluída. Você pode repetir estas ações em todos os seus clusters Kubernetes.

Autenticação Inicial

Após essas ações, você já terá um cluster Kubernetes com a autorização OIDC configurada. A única questão é que seus usuários ainda 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 autenticação bem-sucedida.

Para isso, você pode usar aplicações web específicas que permitem a autenticação do usuário e, em seguida, baixar o kubeconfig pronto. Uma das mais convenientes é Kuberos, que permite descrever todos os clusters Kubernetes em uma configuração e alternar facilmente entre eles.

Para configurar o Kuberos, é suficiente descrever o template para o kubeconfig e executá-lo com os seguintes parâmetros:

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

Para informações mais detalhadas, consulte Usage no GitHub.

Também é possível usar kubelogin se você deseja realizar a autenticação diretamente no computador do usuário. Neste caso, o usuário verá um navegador com um formulário de autenticação no localhost.

O kubeconfig obtido pode ser verificado no site jwt.io. Basta copiar o valor users[].user.auth-provider.config.id-token do seu kubeconfig para o formulário do site e imediatamente obter a decodificação.

Configuração do RBAC

Ao configurar o RBAC, você pode referir-se tanto ao nome do usuário (campo nome no token jwt), quanto ao grupo de usuários (campo grupos no token jwt). Aqui está um exemplo de configuração de direitos para o grupo kubernetes-default-namespace-admins:

kubernetes-default-namespace-admins.yaml

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

Configuração do auth-proxy

Há um projeto incrível chamado keycloak-gatekeeper, que permite proteger qualquer aplicação, fornecendo ao usuário a possibilidade de se autenticar em um servidor OIDC. Vou mostrar como configurá-lo usando o exemplo do Kubernetes Dashboard:

dashboard-proxy.yaml

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

Fonte: habr.com