🥇Collegare l'autenticazione LDAP a Kubernetes

Breve istruzione su come utilizzare Keycloak per collegare Kubernetes al tuo server LDAP e configurare l'importazione di utenti e gruppi. Questo permetterà di configurare RBAC per i tuoi utenti e di utilizzare auth-proxy per proteggere il Kubernetes Dashboard e altre applicazioni che non possono eseguire l'autenticazione autonomamente.

Installazione di Keycloak

Supponiamo che tu abbia già un server LDAP. Può essere Active Directory, FreeIPA, OpenLDAP o qualsiasi altra cosa. Se non hai un server LDAP, puoi comunque creare utenti direttamente nell'interfaccia di Keycloak oppure utilizzare provider oidc pubblici (Google, Github, Gitlab), il risultato sarà quasi lo stesso.

Iniziamo installando Keycloak, l'installazione può essere eseguita separatamente o direttamente nel cluster Kubernetes; in genere, se hai più cluster Kubernetes, sarebbe più semplice installarlo separatamente. D'altra parte, puoi sempre utilizzare il chart helm ufficiale e installarlo direttamente nel tuo cluster.

Per memorizzare i dati di Keycloak, avrai bisogno di un database. Per impostazione predefinita, viene utilizzato h2 (tutti i dati sono memorizzati localmente), ma è anche possibile utilizzare postgres, mysql o mariadb.
Se hai deciso di installare Keycloak separatamente, troverai istruzioni più dettagliate in documentazione ufficiale.

Impostazione della federazione

Per prima cosa, creiamo un nuovo realm. Un realm è lo spazio della nostra applicazione. Ogni applicazione può avere il proprio realm con utenti e impostazioni di autorizzazione differenti. Il realm Master è utilizzato da Keycloak stesso e non è corretto usarlo per qualcos'altro.

Clicchiamo su Aggiungi realm

Opzione
Value

Name
kubernetes

Nome visualizzato
Kubernetes

Nome da visualizzare in HTML
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

Kubernetes verifica per impostazione predefinita se l'email dell'utente è stata confermata. Poiché stiamo utilizzando il nostro server LDAP, questa verifica restituirà quasi sempre false. Disattiviamo la visualizzazione di questo parametro in Kubernetes:

Ambiti client —> Email —> Mapper —> Email verificata (Elimina)

Ora configuriamo la federazione, per farlo andiamo a:

Federazione utenti —> Aggiungi provider… —> ldap

Riporterò un esempio di configurazione per FreeIPA:

Opzione
Value

Nome da visualizzare in console
freeipa.example.org

Vendor
Red Hat Directory Server

Attributo UUID LDAP
ipauniqueid

URL di connessione
ldaps://freeipa.example.org

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

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

Credenziale Bind
<password>

Consenti l'autenticazione Kerberos:
on

Realm Kerberos:
EXAMPLE.ORG

Server Principale:
HTTP/freeipa.example.org@EXAMPLE.ORG

KeyTab:
/etc/krb5.keytab

L'utente keycloak-svc deve essere creato in anticipo sul nostro server LDAP.

Nel caso di Active Directory, è sufficiente selezionare Venditore: Active Directory e le impostazioni necessarie verranno automaticamente inserite nel modulo.

Clicchiamo su Salva

Ora andiamo a:

Federazione utenti —> freeipa.example.org —> Mapper —> Nome

Opzione
Value

Attributo Ldap
givenName

Ora attiviamo il mapping dei gruppi:

Federazione utenti —> freeipa.example.org —> Mapper —> Crea

Opzione
Value

Name
groups

Tipo di Mapper
group-ldap-mapper

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

Strategia di Recupero dei Gruppi Utenti
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Con questo, la configurazione della federazione è completata, procediamo con la configurazione del client.

Configurazione del client

Creiamo un nuovo client (l'applicazione che riceverà gli utenti da Keycloak). Andiamo a:

Clients —> Crea

Opzione
Value

Client ID
kubernetes

Tipo di Accesso
confidenziale

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

URI di Reindirizzamento Validi
http://kubernetes.example.org/*

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

Creeremo anche uno scope per i gruppi:

Scope del Client —> Crea

Opzione
Value

Modello
Nessun template

Name
groups

Percorso completo del gruppo
false

E configuriamo il mapper per essi:

Scope del Client —> groups —> Mapper —> Crea

Opzione
Value

Name
groups

Tipo di Mapper
Appartenenza al gruppo

Nome del Token Claim
groups

Ora dobbiamo attivare il mapping dei gruppi nel nostro client scope:

Clients —> kubernetes —> Scope del Client —> Scopes Client Predefiniti

Selezioniamo groups in Client Scopes Disponibili, facciamo clic su Aggiungi selezionati

Ora configuriamo l'autenticazione della nostra applicazione, andiamo a:

Clients —> kubernetes

Opzione
Value

Autorizzazione Abilitata
ACCESO

Clicchiamo salva e con questo la configurazione del client è completata, ora nella scheda

Clients —> kubernetes —> Credenziali

potrete ottenere Secret che utilizzeremo in seguito.

Configurazione Kubernetes

La configurazione di Kubernetes per l'autenticazione OIDC è piuttosto banale e non è qualcosa di molto complesso. Tutto ciò che è necessario è posizionare il certificato CA del vostro server OIDC in /etc/kubernetes/pki/oidc-ca.pem e aggiungere le opzioni necessarie per kube-apiserver.
A tale scopo, aggiornate /etc/kubernetes/manifests/kube-apiserver.yaml su tutti i vostri master:

...
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 aggiornate anche il file di configurazione kubeadm nel cluster, per non perdere queste impostazioni durante l'aggiornamento:

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

Con questo, la configurazione di Kubernetes è completata. Potete ripetere queste azioni in tutti i vostri cluster Kubernetes.

Autenticazione Iniziale

Dopo queste operazioni avrete già un cluster Kubernetes con l'autenticazione OIDC configurata. L'unico problema è che i vostri utenti non hanno ancora un client configurato né un proprio kubeconfig. Per risolvere questo problema, è necessario configurare il rilascio automatico del kubeconfig agli utenti dopo una autorizzazione riuscita.

A tal fine, si possono utilizzare applicazioni web specializzate, che permettono di autenticare l'utente e poi scaricare un kubeconfig pronto. Una delle più comode è Kuberos, esso consente di descrivere tutti i cluster Kubernetes in un'unica configurazione e passare facilmente tra di essi.

Per configurare Kuberos è sufficiente descrivere un template per kubeconfig e avviarlo con i seguenti parametri:

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

Per informazioni più dettagliate, vedere Utilizzo su Github.

È anche possibile utilizzare kubelogin se desideri effettuare l'autenticazione direttamente sul computer dell'utente. In questo caso, si aprirà un browser con un modulo di autenticazione su localhost.

Il kubeconfig ottenuto può essere verificato sul sito jwt.io. Basta copiare il valore users[].user.auth-provider.config.id-token dal tuo kubeconfig nel modulo del sito e riceverai subito la decodifica.

Configurazione RBAC

Durante la configurazione dell'RBAC è possibile riferirsi sia al nome utente (campo name nel token jwt), sia al gruppo di utenti (campo groups nel token jwt). Ecco un esempio di configurazione dei diritti per il gruppo 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

Ulteriori esempi per RBAC possono essere trovati in della documentazione ufficiale di Kubernetes

Configurazione dell'auth-proxy

C'è un ottimo progetto keycloak-gatekeeper, che consente di proteggere qualsiasi applicazione, fornendo all'utente la possibilità di autenticarsi su un server OIDC. Ti mostrerò come configurarlo usando come esempio il 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