Integrerer LDAP-godkendelse med Kubernetes

En kort vejledning til, hvordan du kan forbinde Kubernetes med din LDAP-server ved hjælp af Keycloak og konfigurere import af brugere og grupper. Dette vil gøre det muligt at konfigurere RBAC for dine brugere og bruge auth-proxy til at beskytte Kubernetes Dashboard og andre applikationer, der ikke kan autentificere sig selv.

Installation af Keycloak

Lad os antage, at du allerede har en LDAP-server. Det kan være Active Directory, FreeIPA, OpenLDAP eller noget andet. Hvis du ikke har en LDAP-server, kan du grundlæggende oprette brugere direkte i Keycloak-interfacet eller bruge offentlige oidc-udbydere (Google, Github, Gitlab), resultatet vil blive næsten det samme.

Først skal vi installere selve Keycloak; installationen kan udføres separat eller direkte i Kubernetes-klyngen. Hvis du har flere Kubernetes-klynger, vil det typisk være lettere at installere det separat. På den anden side kan du altid bruge den officielle helm-chart og installere den direkte i din klynge.

For at gemme data i Keycloak har du brug for en database. Som standard bruges h2 (alle data gemmes lokalt), men det er også muligt at bruge postgres, mysql eller mariadb.
Hvis du alligevel har besluttet at installere Keycloak separat, finder du mere detaljerede instruktioner i den officielle dokumentation.

Konfiguration af federation

Først opretter vi et nyt realm. Et realm er et rum for vores applikation. Hver applikation kan have sit eget realm med forskellige brugere og autentifikationsindstillinger. Master realm bruges af Keycloak selv, og det er forkert at bruge det til andet.

Klik på Tilføj realm

Mulighed
Værdi

Navn
kubernetes

Visningsnavn
Kubernetes

HTML Visningsnavn
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

Kubernetes tjekker som standard, om en brugers e-mail er bekræftet eller ej. Da vi bruger vores egen LDAP-server, vil denne kontrol næsten altid returnere false. Lad os deaktivere visningen af denne parameter i Kubernetes:

Klientomfang —> E-mail —> Mapper —> E-mail bekræftet (Slet)

Nu konfigurerer vi federation, for dette går vi til:

Brugerfederation —> Tilføj udbyder… —> ldap

Her er et eksempel på konfiguration for FreeIPA:

Mulighed
Værdi

Konsol Visningsnavn
freeipa.example.org

Leverandør
Red Hat Directory Server

UUID LDAP-attribut
ipauniqueid

Forbindelses-URL
ldaps://freeipa.example.org

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

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

Bind Credential
<password>

Tillad Kerberos autentifikation:
on

Kerberos Realm:
EXAMPLE.ORG

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

KeyTab:
/etc/krb5.keytab

Brugeren keycloak-svc skal oprettes på forhånd på vores LDAP-server.

I tilfælde af Active Directory er det tilstrækkeligt blot at vælge Leverandør: Active Directory og de nødvendige indstillinger vil automatisk blive indsat i formen.

Klik på Gem

Nu går vi videre til:

Brugerfederation —> freeipa.example.org —> Mapper —> Fornavn

Mulighed
Værdi

LDAP-attribut
givenName

Lad os nu aktivere gruppe-mapping:

Brugerfederation —> freeipa.example.org —> Mapper —> Opret

Mulighed
Værdi

Navn
groups

Mapper type
group-ldap-mapper

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

Brugergrupper Hentningsstrategi
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Nu er konfigurationen af federation afsluttet, lad os gå videre til klientkonfigurationen.

Klientkonfiguration

Vi opretter en ny klient (applikation, der vil hente brugere fra Keycloak). Gå til:

Klienter —> Opret

Mulighed
Værdi

Denne ID bruges til at identificere
kubernetes

Adgangstype
confidenrial

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

Gyldige omdirigerings-URIs
http://kubernetes.example.org/*

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

Vi opretter også et scope for grupper:

Klient Scopes —> Opret

Mulighed
Værdi

Skabelon
Ingen skabelon

Navn
groups

Fuld gruppevej
false

Og vi konfigurerer mapper til dem:

Klient Scopes —> groups —> Mapper —> Opret

Mulighed
Værdi

Navn
groups

Mapper Type
Gruppemedlemskab

Token Claim Navn
groups

Nu skal vi aktivere gruppering i vores klient scope:

Klienter —> kubernetes —> Klient Scopes —> Standard Klient Scopes

Vi vælger groups i Tilgængelige Client Scopes, klik på Tilføj valgte

Lad os nu konfigurere godkendelse af vores applikation, gå til:

Klienter —> kubernetes

Mulighed
Værdi

Autorisation Aktiveret
TIL

Klik på gem og hermed er oprettelsen af klienten færdig, nu på fanen

Klienter —> kubernetes —> Oplysninger

vil du kunne få Secret som vi vil bruge fremadrettet.

Kubernetes konfiguration

Konfiguration af Kubernetes til OIDC-godkendelse er ganske triviel og ikke særlig kompleks. Alt, hvad du behøver, er at placere CA-certifikatet fra din OIDC-server i /etc/kubernetes/pki/oidc-ca.pem og tilføje de nødvendige indstillinger til kube-apiserver.
For at gøre dette, opdater /etc/kubernetes/manifests/kube-apiserver.yaml på alle dine mastere:

...
spec:
  containere:
  - kommando:
    - 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
...

Opdater også kubeadm-konfigurationen i klyngen, så du ikke mister disse indstillinger ved opdatering:

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

Nu er konfigurationen af Kubernetes afsluttet. Du kan gentage disse handlinger i alle dine Kubernetes-klynger.

Indledende godkendelse

Efter disse handlinger vil du have en Kubernetes-klynge med konfigureret OIDC-godkendelse. Den eneste ting er, at dine brugere endnu ikke har konfigureret en klient eller deres egen kubeconfig. For at løse dette problem skal du konfigurere automatisk udstedelse af kubeconfig til brugerne efter en succesfuld godkendelse.

Til dette kan du bruge specielle webapplikationer, der muliggør brugerautentifikation og derefter muliggør download af en klar kubeconfig. En af de mest bekvemme er Kuberos, som gør det muligt at beskrive alle Kubernetes-klynger i én konfigurationsfil og nemt skifte imellem dem.

For at konfigurere Kuberos er det nok at beskrive en skabelon til kubeconfig og starte med følgende parametre:

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

For more detailed information, see Brug on Github.

It is also possible to use kubelogin if you want to perform authentication directly on the user's computer. In this case, a browser will open for the user with an authentication form on localhost.

The obtained kubeconfig can be verified on the site jwt.io. Just copy the value users[].user.auth-provider.config.id-token from your kubeconfig into the form on the site and immediately get the decryption.

Setting up RBAC

When configuring RBAC, you can refer to either the username (the field name in the jwt token) or to the user group (the field groups in the jwt token). Here is an example of rights configuration for the group 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

More examples for RBAC can be found in den officielle dokumentation fra Kubernetes

Konfiguration af auth-proxy

There is a wonderful project keycloak-gatekeeper, which allows securing any application, giving the user the ability to authenticate on an OIDC server. I will show how to set it up using the example of 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

Kilde: habr.com