🗺️ 🧑‍🤝‍🧑 🦎 Autenticación en Kubernetes con Dex: sujete LDAP 👂🏾 📇 👩🏼‍💻

Hoy repasaré los detalles de configuración de autenticación en Kubernetes usando Dex junto con LDAP, y también mostraré cómo puede agregar usuarios estáticos a Dex.

En este artículo no me detendré en los principios básicos de Dex, sino que procederé inmediatamente a instalar y configurar LDAP. Puede familiarizarse con los principios de Dex en este artículo .

Qué hacemos:

Entonces vamos.

Le mostraré un ejemplo de un clúster de Kubernetes listo para usar con Helm versión 3 e Ingress, así como tres nombres de dominio.

Instalar y configurar el servidor OpenLDAP

Usaremos OpenLDAP como LDAP en la distribución ubuntu 18.04.
Nuestro nombre de servidor: openldap.dtln.cloud.

Estamos conectados al servidor y comenzamos la instalación de OpenLDAP. Durante la instalación, se nos pedirá que establezcamos una contraseña:
```
sudo apt update 
sudo apt install slapd ldap-utils
```
Reconfigurando OpenLDAP para nuestro dominio:
```
sudo dpkg-reconfigure slapd 
```
Elija no :
Ingrese el nombre de dominio:
Ingrese el nombre de la organización:
Repita la entrada de contraseña:
Incluimos soporte para STARTTLS. Ponemos los paquetes necesarios:
```
sudo apt install gnutls-bin ssl-cert
```

CA-:

sudo sh -c "certtool --generate-privkey > /etc/ssl/private/cakey.pem"

/etc/ssl/ca.info:
```
cn = DTLN Company
ca
cert_signing_key
```

CA-a , :

sudo certtool --generate-self-signed --load-privkey /etc/ssl/private/cakey.pem --template /etc/ssl/ca.info --outfile /etc/ssl/certs/cacert.pem
sudo certtool --generate-privkey --bits 1024 --outfile /etc/ssl/private/openldap_key.pem

/etc/ssl/openldap.info:

organization = DTLN Company
cn = openldap.dtln.cloud
tls_www_server
encryption_key
signing_key
expiration_days = 3650

sudo certtool --generate-certificate --load-privkey /etc/ssl/private/openldap_key.pem --load-ca-certificate /etc/ssl/certs/cacert.pem --load-ca-privkey /etc/ssl/private/cakey.pem --template /etc/ssl/openldap.info --outfile /etc/ssl/certs/openldap.pem

OpenLDAP STARTTLS. certinfo.dif:

dn: cn=config
add: olcTLSCACertificateFile
olcTLSCACertificateFile: /etc/ssl/certs/cacert.pem
-
add: olcTLSCertificateFile
olcTLSCertificateFile: /etc/ssl/certs/openldap.pem
-
add: olcTLSCertificateKeyFile
olcTLSCertificateKeyFile: /etc/ssl/private/openldap_key.pem

sudo ldapmodify -Y EXTERNAL -H ldapi:/// -f certinfo.dif

sudo chgrp openldap /etc/ssl/private/openldap_key.pem
sudo chmod 0640 /etc/ssl/private/openldap_key.pem
sudo gpasswd -a openldap ssl-cert
sudo systemctl restart slapd.service

, /etc/ldap/ldap.conf :
```
TLS_CACERT /etc/ssl/certs/cacert.pem
```

STARTTLS:

ldapwhoami -H ldap://openldap.dtln.cloud -x -ZZ

LDAP-

, x , Kubernetes. content.ldif:

dn: ou=People,dc=openldap,dc=dtln,dc=cloud
objectClass: organizationalUnit
ou: People
dn: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud
objectClass: person
objectClass: inetOrgPerson
sn: doe
cn: jane
mail: janedoe@openldap.dtln.cloud
userpassword: foo_password

dn: cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud
objectClass: person
objectClass: inetOrgPerson
sn: doe
cn: john
mail: johndoe@openldap.dtln.cloud
userpassword: bar_password

# Group definitions.

dn: ou=Groups,dc=openldap,dc=dtln,dc=cloud
objectClass: organizationalUnit
ou: Groups

dn: cn=admins,ou=Groups,dc=openldap,dc=dtln,dc=cloud
objectClass: groupOfNames
cn: admins
member: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud

dn: cn=developers,ou=Groups,dc=openldap,dc=dtln,dc=cloud
objectClass: groupOfNames
cn: developers
member: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud
member: cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud

Expanda la estructura descrita con el comando:

ldapadd -x -D cn=admin,dc=openldap,dc=dtln,dc=cloud -W -f content.ldif

Asegúrese de que nuestros usuarios estén en el directorio:

ldapwhoami -vvv -h openldap.dtln.cloud -p 389 -D cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud -x -w bar_password -ZZ
ldapwhoami -vvv -h openldap.dtln.cloud -p 389 -D cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud -x -w foo_password -ZZ

Conectamos soporte para OpenID Connect

Pasemos a la configuración del clúster de Kubernetes.

Usamos el dominio dex.ash.dtln.cloud para acceder al servidor Dex API, y login.ash.dtln.cloud para acceder al clúster.

Implementamos el clúster sin los instaladores kubeadm o kops, por lo que la configuración de OIDC se puede agregar inmediatamente a la unidad systemd. En otros casos, la configuración se realiza mejor utilizando estas utilidades.

Editamos la unidad /etc/systemd/system/kube-apiserver.service y agregamos los parámetros de inicio a la sección ExecStart :

--oidc-client-id=dex-k8s-authenticator \
--oidc-groups-claim=groups \
--oidc-username-claim=email \
--oidc-issuer-url=https://dex.ash.dtln.cloud/ \

Reiniciamos nuestras API, verificamos que hayan aumentado:

sudo systemctl daemon-reload
sudo systemctl restart kube-apiserver
sudo systemctl status kube-apiserver

Crear un certificado multidominio

Ahora ve al clúster de Kubernetes.

Instalamos cert-manager usando Helm:

helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager --namespace kube-system jetstack/cert-manager --version v0.13.0

Describimos la solicitud de un certificado SAN para nuestros dominios en cert.yml:

---
apiVersion: cert-manager.io/v1alpha2
kind: ClusterIssuer
metadata:
  name: letsencrypt-dex
spec:
  acme:
    email: kubernetes@dataline.ru
    server: https://acme-v02.api.letsencrypt.org/directory
    privateKeySecretRef:
      name: letsencrypt-key-dex
    solvers:
    - http01:
        ingress:
          class: nginx
---
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
  name: auth-dex
  namespace: kube-system
spec:
  secretName: cert-auth-dex
  issuerRef:
    kind: ClusterIssuer
    name: letsencrypt-dex
  commonName: dex.ash.dtln.cloud
  dnsNames:
  - dex.ash.dtln.cloud
  - login.ash.dtln.cloud

Ejecutamos el comando:
```
kubectl apply -f cert.yaml
```
Ahora miramos el estado de nuestra solicitud de certificado con los siguientes comandos:
```
kubectl get certificates --all-namespaces
kubectl get challenges --all-namespaces
```
Estamos a la espera de confirmación, el proceso puede demorar un poco:

Instalar Dex

Para Dex, necesitamos ca.crt, ca.key del servidor maestro. Generalmente están en el directorio / etc / kubernetes / pki /.
También necesitamos un certificado de CA anterior con OpenLDAP que generamos, ubicado en la ruta /etc/ssl/certs/cacert.pem

Descargue las fuentes dex-authenticator y vaya al directorio:

git clone git@github.com:mintel/dex-k8s-authenticator.git
cd dex-k8s-authenticator/

Preparamos la configuración para Dex-auth, pegamos el contenido del ca.crt copiado previamente, es importante observar la sangría:

---
global:
  deployEnv: prod
dexK8sAuthenticator:
  clusters:
    - name: 'ash.dtln.cloud'
      short_description: "k8s cluster"
      description: "Kubernetes cluster"
      issuer: https://dex.ash.dtln.cloud/
      k8s_master_uri: https://kubernetes.dtln.cloud:6443 # url or ip
      client_id: dex-k8s-authenticator
      static_context_name: false
      client_secret: acDEgDEcIg7RX0U7A9hlW2pGGraHDuMAZ4qFEKg2fUHHxr8
      redirect_uri: https://login.ash.dtln.cloud/callback
      k8s_ca_pem: |
        -----BEGIN CERTIFICATE-----
        #   ca.crt
        -----END CERTIFICATE-----
ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - login.ash.dtln.cloud
  tls:
    - secretName: cert-auth-dex
      hosts:
        - login.ash.dtln.cloud

Traducimos el contenido de cacert.pem a base64 para agregarlo a la configuración:
```
cacert.pem | base64
```

Dex, . staticPasswords bcrypt:

---
global:
  deployEnv: prod
tls:
  certificate: |-
    -----BEGIN CERTIFICATE-----
    # ca.crt
    -----END CERTIFICATE-----
  key: |-
    -----BEGIN RSA PRIVATE KEY-----
    # ca.key
    -----END RSA PRIVATE KEY-----
ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - dex.ash.dtln.cloud
  tls:
    - secretName: cert-auth-dex
      hosts:
        - dex.ash.dtln.cloud
serviceAccount:
  create: true
  name: dex-auth-sa
config:
  issuer: https://dex.ash.dtln.cloud/
  storage:
    type: kubernetes
    config:
      inCluster: true
  web:
    http: 0.0.0.0:5556
  frontend:
    theme: "coreos"
    issuer: "kube-dtln"
    issuerUrl: "https://login.ash.dtln.cloud"
  expiry:
    signingKeys: "6h"
    idTokens: "24h"
  logger:
    level: debug
    format: json
  oauth2:
    responseTypes: ["code", "token", "id_token"]
    skipApprovalScreen: true

  connectors:
  - type: ldap
    id: ldap
    name: LDAP
    config:
      insecureNoSSL: false
      insecureSkipVerify: false
      startTLS: true #   
      rootCAData: |-
        # cacert.pem  base64 
        # 
     
      host: openldap.dtln.cloud:389
      usernamePrompt: Email Address
      userSearch:
        baseDN: ou=People,dc=openldap,dc=dtln,dc=cloud
        filter: "(objectClass=person)"
        username: mail
        idAttr: DN
        emailAttr: mail
        nameAttr: cn
      groupSearch:
        baseDN: ou=Groups,dc=openldap,dc=dtln,dc=cloud
        filter: "(objectClass=groupOfNames)"

        userMatchers:
        - userAttr: DN
          groupAttr: member

        nameAttr: cn

  staticClients:
  - id: dex-k8s-authenticator
    name: Kubernetes Dev Cluster
    secret: 'acDEgDEcIg7RX0U7A9hlW2pGGraHDuMAZ4qFEKg2fUHHxr8'
    redirectURIs:
      - https://login.ash.dtln.cloud/callback

  enablePasswordDB: True

  staticPasswords:
    #       base64
  - email: "admin@dtln.cloud"
    # bcrypt hash of the string "password"
    hash: "$2a$10$2b2cU8CPhOTaGrs1HRQuAueS7JTT5ZHsHSzYiFPm1leZck7Mc8T4W"
    username: "admin"
    userID: "08a8684b-db88-4b73-90a9-3cd1661f5466"

dex dex-auth- :

helm install dex --namespace kube-system --values dex.yaml charts/dex
helm install dex-auth --namespace kube-system --values dex-auth.yml charts/dex-k8s-authenticator

kubeconfig

, pod’. login.ash.dtln.cloud. , mail- .

static- mail:
Dex-auth. C kubeconfig-. :
Ahora intente acceder al clúster y obtenga un error. Así es, nuestro usuario no tiene derechos, así que pasemos a configurar RBAC.

Configuramos la autorización RBAC

Por ejemplo, asignamos al usuario estático a la función del sistema de administración del clúster y a los usuarios del grupo de desarrolladores a la función de visualización, que solo permite ver recursos. Entonces el contenido del archivo crb.yml debería ser así:

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: dex-admin
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: User
  name: "admin@dtln.cloud"

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: dex-developers
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: view
subjects:
- kind: Group
  name: "developers"

Cambie al contexto principal y aplique el archivo yaml creado al clúster:
```
kubectl config set-context default
kubectl apply -f crb.yml
```

Observamos los contextos disponibles y volvemos a nuestro usuario:

kubectl config get-contexts
kubectl config set-context johndoe-ash.dtln.cloud

Esto completa la configuración de Dex junto con OpenLDAP.

Un par de consejos para el final:

Si surgen problemas, lo primero que debe verificar es el formato de los archivos yaml y prestar atención a la sangría.
Las barras diagonales en las direcciones deben coincidir con los ejemplos.
pod’ Dex, Dex-auth, kube-api .

Autenticación en Kubernetes con Dex: sujete LDAP