🥇Anslut LDAP-autentisering till Kubernetes

En liten instruktion om hur man med hjälp av Keycloak kan koppla Kubernetes till din LDAP-server och konfigurera import av användare och grupper. Detta gör det möjligt att ställa in RBAC för dina användare och använda auth-proxy för att skydda Kubernetes Dashboard och andra applikationer som inte kan autentisera sig själva.

Installation av Keycloak

Anta att du redan har en LDAP-server. Det kan vara Active Directory, FreeIPA, OpenLDAP eller något annat. Om du inte har en LDAP-server kan du i princip skapa användare direkt i Keycloaks gränssnitt eller använda offentliga oidc-leverantörer (Google, Github, Gitlab), resultatet blir nästan detsamma.

Först installerar vi själva Keycloak, installationen kan göras separat eller direkt i Kubernetes-klustret. Om du har flera Kubernetes-kluster är det oftast enklare att installera det separat. Å andra sidan kan du alltid använda den officiella helm-diagrammet och installera det direkt i ditt kluster.

För att lagra data till Keycloak behöver du en databas. Som standard används h2 (alla data lagras lokalt), men du kan också använda postgres, mysql eller mariadb.
Om du ändå har bestämt dig för att installera Keycloak separat hittar du mer detaljerade instruktioner i den officiella dokumentationen.

Konfigurering av federation

Först skapar vi en ny realm. En realm är rummet för vår applikation. Varje applikation kan ha sin egen realm med olika användare och autentiseringens inställningar. Master realm används av Keycloak självt och det är fel att använda det till något annat.

Klicka på Lägg till realm

Alternativ
Värde

Namn
kubernetes

Visningsnamn
Kubernetes

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

Kubernetes kontrollerar som standard om användarens e-post är verifierad eller inte. Eftersom vi använder vår egen LDAP-server kommer denna kontroll nästan alltid att returnera false. Låt oss stänga av visningen av denna parameter i Kubernetes:

Klienter —> Email —> Mappers —> E-post verifierad (Ta bort)

Nu ställer vi in federation, gå till:

Användarfederation —> Lägg till leverantör… —> ldap

Här är ett exempel på konfiguration för FreeIPA:

Alternativ
Värde

Konsol Visningsnamn
freeipa.example.org

Leverantör
Red Hat Directory Server

UUID LDAP-attribut
ipauniqueid

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

Användares DN
cn=users,cn=accounts,dc=example,dc=org

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

Bindningsuppgift
<password>

Tillåt Kerberos-autentisering:
on

Kerberos Realm:
EXAMPLE.ORG

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

KeyTab:
/etc/krb5.keytab

Användaren keycloak-svc måste skapas i förväg på vår LDAP-server.

I fallet med Active Directory räcker det att bara välja Leverantör: Active Directory och nödvändiga inställningar fylls automatiskt i formuläret.

Klicka på Save

Nu går vi till:

Användarfederation —> freeipa.example.org —> Mappers —> Förnamn

Alternativ
Värde

Ldap-attribut
givenName

Låt oss nu aktivera gruppmappning:

Användarfederation —> freeipa.example.org —> Mappers —> Skapa

Alternativ
Värde

Namn
grupper

Mapper typ
group-ldap-mapper

LDAP-grupper DN
cn=groups,cn=accounts,dc=example,dc=org

Användargruppers hämtstrategi
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Nu är konfigurationen av federationen klar, låt oss gå vidare till klientkonfigurationen.

Konfigurera klienten

Vi skapar en ny klient (applikation som kommer att hämta användare från Keycloak). Gå till:

Klienter —> Skapa

Alternativ
Värde

Klient-ID
kubernetes

Åtkomsttyp
confidenrial

Rot-URL
http://kubernetes.example.org/

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

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

Vi skapar också ett scope för grupper:

Klientomfång —> Skapa

Alternativ
Värde

Mall
Ingen mall

Namn
grupper

Full gruppväg
false

Och vi konfigurerar mappare för dem:

Klientomfång —> grupper —> Mappers —> Skapa

Alternativ
Värde

Namn
grupper

Mapper-typ
Gruppmedlemskap

Token kravnamn
grupper

Nu behöver vi aktivera gruppmappningen i vårt klientomfång:

Klienter —> kubernetes —> Klientomfång —> Standard klientomfång

Välj grupper på Tillgängliga klientomfång, tryck på Lägg till valda

Nu konfigurerar vi autentiseringen av vår applikation, gå vidare till:

Klienter —> kubernetes

Alternativ
Värde

Behörighet aktiverad
PÅ

Klicka på spara och nu är klientkonfigurationen avslutad, gå till fliken

Klienter —> kubernetes —> Referenser

där kan du få Hemmelighet som vi kommer att använda framöver.

Konfigurering av Kubernetes

Konfiguration av Kubernetes för OIDC-autentisering är ganska trivial och inget komplicerat. Det du behöver göra är att lägga CA-certifikat för din OIDC-server i /etc/kubernetes/pki/oidc-ca.pem och lägga till nödvändiga alternativ för kube-apiserver.
För detta, uppdatera /etc/kubernetes/manifests/kube-apiserver.yaml på alla dina noder:

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

Och uppdatera kubeadm-konfigurationen i klustret för att inte förlora dessa inställningar vid uppgradering:

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 är konfigurationen av Kubernetes klar. Du kan upprepa dessa åtgärder i alla dina Kubernetes-kluster.

Inledande autentisering

Efter dessa åtgärder kommer du att ha ett Kubernetes-kluster med konfigurerad OIDC-autentisering. Det enda problemet är att dina användare för tillfället inte har konfigurerade klienter eller sina egna kubeconfig. För att lösa detta problem behöver du konfigurera automatisk utfärdande av kubeconfig för användare efter lyckad autentisering.

För detta kan du använda speciella webbapplikationer som möjliggör autentisering av användaren och sedan ladda ner en färdig kubeconfig. En av de mest användarvänliga är Kuberos, den låter dig beskriva alla Kubernetes-kluster i en konfiguration och enkelt växla mellan dem.

För att konfigurera Kuberos behöver du bara beskriva mallen för kubeconfig och köra med följande parametrar:

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

För mer detaljerad information, se Användning på Github.

Det är också möjligt att använda kubelogin om du vill autentisera direkt på användarens dator. I så fall öppnas en webbläsare med en autentiseringsformulär på localhost.

Den erhållna kubeconfig kan kontrolleras på webbplatsen jwt.io. Kopiera bara värdet users[].user.auth-provider.config.id-token från din kubeconfig till formuläret på webbplatsen och få direkt avkodning.

RBAC-konfiguration

Vid konfiguration av RBAC kan du referera till både användarnamn (fält name i jwt-token), såväl som användargrupp (fält grupper i jwt-token). Här är ett exempel på åtkomstinställningar för gruppen 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

Fler exempel på RBAC kan hittas i den officiella Kubernetes-dokumentationen

Inställningar för auth-proxy

Det finns ett fantastiskt projekt keycloak-gatekeeper, som gör det möjligt att skydda vilken applikation som helst, genom att ge användaren möjlighet att autentisera sig mot OIDC-servern. Jag kommer att visa hur man konfigurerar det med Kubernetes Dashboard som exempel:

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

Källa: habr.com