Una breve instrucción sobre cómo usar Kubernetes con Keycloak para enlazar a su servidor LDAP y configurar la importación de usuarios y grupos. Esto le permitirá configurar RBAC para sus usuarios y usar el proxy de autenticación para proteger el Panel de control de Kubernetes y otras aplicaciones que no pueden autorizarse.
Instalar Keycloak
Supongamos que ya tiene un servidor LDAP. Podría ser Active Directory, FreeIPA, OpenLDAP o cualquier otra cosa. Si no tiene un servidor LDAP, entonces, en principio, puede crear usuarios directamente en la interfaz de Keycloak o utilizar proveedores públicos de oidc (Google, Github, Gitlab), el resultado será casi el mismo.
En primer lugar, instalaremos Keycloak en sí, la instalación se puede realizar por separado e inmediatamente en el clúster de Kubernetes, por regla general, si tiene varios clústeres de Kubernetes, sería más fácil instalarlo por separado. Por otro lado, siempre puedes usar el gráfico oficial de timón e instalarlo directamente en tu clúster.
Para almacenar datos de Keycloak, necesita una base de datos. Por defecto, h2 usa h2 (todos los datos se almacenan localmente), pero también es posible usar postgres , mysql o mariadb .
Si aún decide instalar Keycloak por separado, encontrará instrucciones más detalladas en la documentación oficial .
Configuración de federación
Primero, crea un nuevo reino. El reino es el espacio de nuestra aplicación. Cada aplicación puede tener su propio ámbito con diferentes usuarios y configuraciones de autorización. El dominio maestro es utilizado por Keycloak y no es correcto usarlo para nada más.
Haz clic en Agregar reino
| Opcion | Valor |
|---|
| Nombre | kubernetes |
| Nombre para mostrar | Kubernetes |
| Nombre para mostrar HTML | <img src="https://kubernetes.io/images/nav_logo.svg" width="400" \> |
Kubernetes por defecto verifica si el usuario tiene un correo electrónico o no. Como usamos nuestro propio servidor LDAP, esta verificación casi siempre devolverá false . Apaguemos la representación de este parámetro en Kubernetes:
Ámbitos del cliente -> Correo electrónico -> Mapeadores -> Correo electrónico verificado (Eliminar)
Ahora configure la federación, para esto iremos a:
Federación de usuarios -> Agregar proveedor ... -> ldap
Aquí hay un ejemplo de configuración para FreeIPA:
| Opcion | Valor |
|---|
| Nombre para mostrar de la consola | freeipa.example.org |
| Vendedor | Red Hat Directory Server |
| Atributo LDAP UUID | ipauniqueid |
| URL de conexión | ldaps://freeipa.example.org |
| DN de usuarios | cn=users,cn=accounts,dc=example,dc=org |
| Bind dn | uid=keycloak-svc,cn=users,cn=accounts,dc=example,dc=org |
| Credencial de enlace | <password> |
| Permitir autenticación Kerberos: | on |
| Reino Kerberos: | EXAMPLE.ORG |
| Principal del servidor: | HTTP/freeipa.example.org@EXAMPLE.ORG |
| KeyTab: | /etc/krb5.keytab |
El usuario keycloak-svc debe crearse previamente en nuestro servidor LDAP.
En el caso de Active Directory, simplemente seleccione Proveedor: Active Directory y la configuración necesaria se completará automáticamente en el formulario.
Haga clic en Guardar
Ahora sigamos adelante:
Federación de usuarios -> freeipa.example.org -> Mappers -> Nombre
| Opcion | Valor |
|---|
| Atributo de Ldap | givenName |
Ahora habilite la asignación de grupo:
Federación de usuarios -> freeipa.example.org -> Mapeadores -> Crear
| Opcion | Valor |
|---|
| Nombre | groups |
| Tipo de mapeador | group-ldap-mapper |
| DN de grupos LDAP | cn=groups,cn=accounts,dc=example,dc=org |
| Estrategia de recuperación de grupos de usuarios | GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE |
Esto completa la configuración de la federación, pasemos a configurar el cliente.
Configuración del cliente
Cree un nuevo cliente (una aplicación que recibirá usuarios de Keycloak). Pasamos:
Clientes -> Crear
| Opcion | Valor |
|---|
| ID del cliente | kubernetes |
| Tipo de acceso | confidenrial |
| URL raíz | http://kubernetes.example.org/ |
| URI de redireccionamiento válidos | http://kubernetes.example.org/* |
| URL de administrador | http://kubernetes.example.org/ |
También cree un alcance para grupos:
Ámbitos del cliente -> Crear
| Opcion | Valor |
|---|
| Plantilla | No template |
| Nombre | groups |
| Ruta de grupo completa | false |
Y configure el mapeador para ellos:
Ámbitos del cliente -> grupos -> Mapeadores -> Crear
| Opcion | Valor |
|---|
| Nombre | groups |
| Tipo de mapeador | Group membership |
| Nombre de reclamo de token | groups |
Ahora necesitamos habilitar el grupo de mapeo en el alcance de nuestro cliente:
Clientes -> kubernetes -> Ámbitos de cliente -> Ámbitos de cliente predeterminados
Seleccione grupos en Ámbitos de cliente disponibles , haga clic en Agregar seleccionados
Ahora configure la autenticación de nuestra aplicación, vaya a:
Clientes -> kubernetes
| Opcion | Valor |
|---|
| Autorización habilitada | ON |
Haga clic en guardar y esto completa la configuración del cliente, ahora en la pestaña
Clientes -> kubernetes -> Credenciales
Puede obtener Secret, que usaremos en el futuro.
Configurar Kubernetes
Configurar Kubernetes para la autenticación OIDC es bastante trivial y no es muy complicado. Todo lo que necesita hacer es colocar el certificado de CA de su servidor /etc/kubernetes/pki/oidc-ca.pem en /etc/kubernetes/pki/oidc-ca.pem y agregar las opciones necesarias para kube-apiserver.
Para hacer esto, actualice /etc/kubernetes/manifests/kube-apiserver.yaml en todos sus asistentes:
... 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 ...
Y también actualice la configuración de kubeadm en el clúster, para no perder esta configuración al 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 ...
Esto completa la configuración de Kubernetes. Puede repetir estos pasos en todos sus grupos de Kubernetes.
Autorización inicial
Después de estos pasos, ya tendrá un clúster de Kubernetes con autenticación OIDC configurada. El único punto es que sus usuarios aún no tienen un cliente configurado, así como su propio kubeconfig. Para resolver este problema, debe configurar la emisión automática de kubeconfig a los usuarios después de una autorización exitosa.
Para hacer esto, puede usar aplicaciones web especiales que le permitan autenticar al usuario y luego descargar el kubeconfig terminado. Uno de los más convenientes es Kuberos , que le permite describir todos los clústeres de Kubernetes en una configuración y cambiar fácilmente entre ellos.
Para configurar Kuberos, solo describa la plantilla para kubeconfig y ejecute con los siguientes parámetros:
kuberos https://keycloak.example.org/auth/realms/kubernetes kubernetes /cfg/secret /cfg/template
Vea Uso en Github para más detalles.
También es posible usar kubelogin si desea autorizar directamente en la computadora del usuario. En este caso, el usuario abre un navegador con un formulario de autorización en localhost.
El kubeconfig resultante se puede verificar en jwt.io. Simplemente copie el valor de users[].user.auth-provider.config.id-token desde su kubeconfig al formulario en el sitio e inmediatamente obtenga el descifrado.
Configuración RBAC
Al configurar RBAC, puede hacer referencia tanto al nombre de usuario (el campo de name en el token jwt) como al grupo de usuarios (el campo de groups en el token jwt). Aquí hay un ejemplo de configuración de permisos para el 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
Se pueden encontrar más ejemplos de RBAC en la documentación oficial de Kubernetes.
Configurar auth-proxy
Existe un maravilloso proyecto de keycloak-gatekeeper que le permite proteger cualquier aplicación y le brinda al usuario la posibilidad de autenticarse con el servidor OIDC. Le mostraré cómo puede configurarlo usando Kubernetes Dashboard como ejemplo:
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