ProHoster > Blog > Administración > Fixamos a autorización LDAP a Kubernetes

Fixamos a autorización LDAP a Kubernetes

Fixamos a autorización LDAP a Kubernetes

Un pequeno tutorial sobre como pode usar Keycloak para conectar Kubernetes ao seu servidor LDAP e configurar a importación de usuarios e grupos. Isto permitirache configurar RBAC para os teus usuarios e usar o proxy de autenticación para protexer o panel de control de Kubernetes e outras aplicacións que non poden autenticarse.

Instalación de Keycloak

Supoñamos que xa tes un servidor LDAP. Isto pode ser Active Directory, FreeIPA, OpenLDAP ou calquera outra cousa. Se non tes un servidor LDAP, en principio podes crear usuarios directamente na interface Keycloak ou usar provedores públicos de oidc (Google, Github, Gitlab), o resultado será case o mesmo.

En primeiro lugar, imos instalar o propio Keycloak. A instalación pódese realizar por separado ou directamente nun clúster de Kubernetes. Por regra xeral, se tes varios clústeres de Kubernetes, sería máis fácil instalalo por separado. Por outra banda sempre podes usar carta oficial de timón e instálao directamente no seu clúster.

Para almacenar os datos de Keycloak necesitarás unha base de datos. O predeterminado é h2 (todos os datos almacénanse localmente), pero tamén é posible utilizalos postgres, mysql ou mariadb.
Se aínda así decides instalar Keycloak por separado, atoparás instrucións máis detalladas en documentación oficial.

Configuración da federación

Primeiro de todo, imos crear un novo reino. Realm é o espazo da nosa aplicación. Cada aplicación pode ter o seu propio reino con diferentes usuarios e configuracións de autorización. O reino Mestre é usado polo propio Keycloak e está mal usalo para calquera outra cousa.

Faga clic aquí Engadir reino

opción
Valor

nome
kubernetes

Mostrar Name
Kubernetes

Nome de visualización HTML
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

Kubernetes comproba por defecto se o correo electrónico do usuario está confirmado ou non. Xa que usamos o noso propio servidor LDAP, esta comprobación volverá case sempre false. Desactivemos a representación desta opción en Kubernetes:

Ámbitos de cliente -> email -> Mapeadores -> Correo electrónico verificado (Eliminar)

Agora imos configurar a federación; para facelo, vai a:

Federación de usuarios -> Engadir provedor... -> ldap

Aquí tes un exemplo de configuración de FreeIPA:

opción
Valor

Nome de visualización da consola
freeipa.example.org

Vendedor
Red Hat Directory Server

Atributo LDAP UUID
ipauniqueid

URL de conexión
ldaps://freeipa.example.org

Usuarios DN
cn=users,cn=accounts,dc=example,dc=org

Enlace DN
uid=keycloak-svc,cn=users,cn=accounts,dc=example,dc=org

Vincular credencial
<password>

Permitir a autenticación Kerberos:
on

Reino Kerberos:
EXAMPLE.ORG

Principal do servidor:
HTTP/[email protected]

KeyTab:
/etc/krb5.keytab

Usuario keycloak-svc deben crearse previamente no noso servidor LDAP.

No caso de Active Directory, só tes que seleccionar Vendedor: Active Directory e as configuracións necesarias introduciranse no formulario automaticamente.

Faga clic aquí gardar

Agora imos adiante:

Federación de usuarios -> freeipa.example.org -> Mapeadores -> Nome

opción
Valor

Atributo Ldap
givenName

Agora imos activar a asignación de grupos:

Federación de usuarios -> freeipa.example.org -> Mapeadores -> crear

opción
Valor

nome
groups

Tipo de mapeador
group-ldap-mapper

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

Estratexia de recuperación de grupos de usuarios
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Agora que a configuración da federación está completa, pasemos á configuración do cliente.

Configuración do cliente

Imos crear un novo cliente (unha aplicación que recibirá usuarios de Keycloak). Seguimos:

Clientes -> crear

opción
Valor

ID de cliente
kubernetes

Tipo de acceso
confidenrial

URL raíz
http://kubernetes.example.org/

URI de redirección válidos
http://kubernetes.example.org/*

URL de administrador
http://kubernetes.example.org/

Tamén creemos un ámbito para grupos:

Ámbitos de cliente -> crear

opción
Valor

Modelo
No template

nome
groups

Camiño de grupo completo
false

E configura un mapeador para eles:

Ámbitos de cliente -> grupos -> Mapeadores -> crear

opción
Valor

nome
groups

Tipo de mapeador
Group membership

Nome da reclamación do token
groups

Agora necesitamos activar o grupo de mapas no noso ámbito de cliente:

Clientes -> kubernetes -> Ámbitos de cliente -> Ámbitos de cliente predeterminados

seleccionar grupos в Ámbitos de cliente dispoñibles, prema Engadir seleccionado

Agora imos configurar a autenticación da nosa aplicación, vai a:

Clientes -> kubernetes

opción
Valor

Autorización habilitada
ON

Prememos gardar e con isto complétase a configuración do cliente, agora na pestana

Clientes -> kubernetes -> credenciais

podes conseguir Segredo que usaremos máis adiante.

Configuración de Kubernetes

Configurar Kubernetes para a autorización OIDC é bastante trivial e non moi complicado. Todo o que tes que facer é poñer o certificado CA do teu servidor OIDC /etc/kubernetes/pki/oidc-ca.pem e engade as opcións necesarias para kube-apiserver.
Para iso, actualiza /etc/kubernetes/manifests/kube-apiserver.yaml en todos os teus 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
...

Ademais, actualice a configuración de kubeadm no clúster para non perder esta configuración ao actualizar:

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

Isto completa a configuración de Kubernetes. Podes repetir estes pasos en todos os teus clústeres de Kubernetes.

Autorización inicial

Despois destes pasos, xa terás un clúster de Kubernetes con autorización OIDC configurada. O único é que os teus usuarios aínda non teñen un cliente configurado nin o seu propio kubeconfig. Para resolver este problema, cómpre configurar a distribución automática de kubeconfig aos usuarios despois da autorización exitosa.

Para iso, podes usar aplicacións web especiais que che permiten autenticar o usuario e despois descargar o kubeconfig xa preparado. Unha das máis convenientes é Kuberos, permítelle describir todos os clústeres de Kubernetes nunha soa configuración e cambiar facilmente entre eles.

Para configurar Kuberos, só tes que describir o modelo para kubeconfig e executalo cos seguintes parámetros:

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

Para información máis detallada consulte Uso en Github.

Tamén é posible usar kubelogin se quere autorizar directamente no ordenador do usuario. Neste caso, o usuario abrirá un navegador cun formulario de autorización en localhost.

O kubeconfig resultante pódese comprobar no sitio web jwt.io. Simplemente copie o valor users[].user.auth-provider.config.id-token desde o teu kubeconfig ata o formulario do sitio web e recibe inmediatamente unha transcrición.

Configurando RBAC

Ao configurar RBAC, pode facer referencia tanto ao nome de usuario (campo name no token jwt) e por grupo de usuarios (campo groups en ficha jwt). Aquí tes un exemplo de configuración de dereitos para un 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

Podes atopar máis exemplos de RBAC en documentación oficial de Kubernetes

Configurando o proxy de autenticación

Hai un proxecto marabilloso garda-chaveiro, que permite protexer calquera aplicación proporcionando ao usuario a posibilidade de autenticarse no servidor OIDC. Vouche mostrar como configuralo usando Kubernetes Dashboard como exemplo:

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

Fonte: www.habr.com

Engadir un comentario