🥇 LDAP-authenticatie aansluiten op Kubernetes

Een korte handleiding over hoe je Keycloak kunt gebruiken om Kubernetes aan je LDAP-server te koppelen en het importeren van gebruikers en groepen te configureren. Dit maakt het mogelijk om RBAC voor je gebruikers in te stellen en auth-proxy te gebruiken om het Kubernetes-dashboard en andere applicaties te beveiligen die zelf geen autorisatie kunnen uitvoeren.

Installatie van Keycloak

Laten we aannemen dat je al een LDAP-server hebt. Dit kan Active Directory, FreeIPA, OpenLDAP of iets anders zijn. Als je geen LDAP-server hebt, kun je in principe gebruikers rechtstreeks in de Keycloak-interface aanmaken of openbare OIDC-providers (Google, Github, Gitlab) gebruiken; het resultaat zal bijna hetzelfde zijn.

Als eerste installeren we Keycloak. De installatie kan zowel apart als direct in het Kubernetes-cluster worden uitgevoerd. Over het algemeen zou het gemakkelijker zijn om het apart te installeren als je meerdere Kubernetes-clusters hebt. Aan de andere kant kun je altijd gebruik maken van de officiële helm-chart en het rechtstreeks in je cluster installeren.

Voor het opslaan van gegevens heeft Keycloak een database nodig. Standaard wordt h2 (alle gegevens worden lokaal opgeslagen), maar je kunt ook postgres, mysql of mariadb.
Als je toch besluit om Keycloak apart te installeren, vind je meer gedetailleerde instructies in de officiële documentatie.

Federatie-instellingen

Laten we eerst een nieuwe realm aanmaken. Een realm is de ruimte voor onze applicatie. Elke applicatie kan zijn eigen realm hebben met verschillende gebruikers en autorisatie-instellingen. De master realm wordt door Keycloak zelf gebruikt en het is niet juist om deze voor iets anders te gebruiken.

Klik op Voeg rijk toe

Optie
Waarde

Naam
kubernetes

Weergavenaam
Kubernetes

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

Kubernetes controleert standaard of het e-mailadres van de gebruiker is bevestigd. Aangezien we onze eigen LDAP-server gebruiken, zal deze controle bijna altijd terugkomen met false. Laten we de weergave van deze parameter in Kubernetes uitschakelen:

Client scopes —> E-mail —> Mappers —> E-mail bevestigd (Verwijderen)

Laten we nu de federatie instellen, daarvoor gaan we naar:

gebruikersfederatie —> Voeg provider toe… —> ldap

Hier is een voorbeeld van de instellingen voor FreeIPA:

Optie
Waarde

Console-weergavenaam
freeipa.example.org

Leverancier
Red Hat Directory Server

UUID LDAP-attribuut
ipauniqueid

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

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

Sta Kerberos-authenticatie toe:
on

Kerberos-realm:
EXAMPLE.ORG

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

KeyTab:
/etc/krb5.keytab

De gebruiker keycloak-svc moet van tevoren op onze LDAP-server worden aangemaakt.

In het geval van Active Directory is het voldoende om gewoon te kiezen voor Leverancier: Active Directory en de benodigde instellingen worden automatisch in het formulier ingevuld.

Klik op Opslaan

Laten we nu doorgaan naar:

gebruikersfederatie —> freeipa.example.org —> Mappers —> Voornaam

Optie
Waarde

Ldap attribuut
gegevenNaam

Laten we nu de groepenmapping inschakelen:

gebruikersfederatie —> freeipa.example.org —> Mappers —> Create

Optie
Waarde

Naam
groepen

Mapper type
groep-ldap-mapper

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

Gebruikersgroepen ophalen strategie
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Met deze instellingen is de federatie-configuratie voltooid, laten we doorgaan naar de cliëntconfiguratie.

Configuratie van de cliënt

We maken een nieuwe cliënt aan (de applicatie die gebruikers uit Keycloak zal ophalen). Ga verder naar:

Cliënten —> Create

Optie
Waarde

Cliënt ID
kubernetes

ToegangsType
vertrouwelijk

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

Geldige Redirect-URI's
http://kubernetes.example.org/*

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

We creëren ook een scope voor groepen:

Cliënt Scopes —> Create

Optie
Waarde

Sjabloon
Geen sjabloon

Naam
groepen

Volledige groepspad
false

En we configureren een mapper voor hen:

Cliënt Scopes —> groepen —> Mappers —> Create

Optie
Waarde

Naam
groepen

Mapper Type
Groepslidmaatschap

Token Claim Naam
groepen

We moeten nu de groepsmapping inschakelen in onze client scope:

Cliënten —> kubernetes —> Cliënt Scopes —> Standaard Client Scopes

We kiezen groepen in Beschikbare Client Scopes, we drukken op Voeg geselecteerde toe

Laten we nu de authenticatie van onze applicatie instellen, ga naar:

Cliënten —> kubernetes

Optie
Waarde

Autorisatie Ingeschakeld
AAN

Klik op opslaan en hiermee is de cliëntconfiguratie voltooid, nu op het tabblad

Cliënten —> kubernetes —> Referenties

kunt u verkrijgen Secret deze zullen we later gebruiken.

Kubernetes-instellingen

De configuratie van Kubernetes voor OIDC-autorisatie is vrij eenvoudig en niet al te ingewikkeld. Alles wat u hoeft te doen is het CA-certificaat van uw OIDC-server te plaatsen in /etc/kubernetes/pki/oidc-ca.pem en de noodzakelijke opties voor kube-apiserver toe te voegen.
Om dit te doen, werkt u de /etc/kubernetes/manifests/kube-apiserver.yaml op al uw masters bij:

...
spec:
  containers:
  - commando:
    - 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
...

En werk ook de kubeadm-configuratie in het cluster bij, zodat deze instellingen niet verloren gaan tijdens de update:

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

Met dit is de configuratie van Kubernetes voltooid. U kunt deze stappen herhalen in al uw Kubernetes-clusters.

Initiële autorisatie

Na deze stappen heeft u al een Kubernetes-cluster met geconfigureerde OIDC-autorisatie. Het enige punt is dat uw gebruikers nog geen geconfigureerde cliënt of eigen kubeconfig hebben. Om dit probleem op te lossen, moet u automatische kubeconfig-uitgifte aan gebruikers instellen na een succesvolle autorisatie.

Hiervoor kunnen speciale webapplicaties worden gebruikt die gebruikersauthenticatie toestaan en dan een kant-en-klare kubeconfig kunnen downloaden. Een van de handigste is Kuberos, het stelt u in staat om in één configuratie alle Kubernetes-clusters te beschrijven en eenvoudig tussen hen te schakelen.

Voor de configuratie van Kuberos is het voldoende om een sjabloon voor kubeconfig te beschrijven en deze met de volgende parameters te starten:

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

Voor meer gedetailleerde informatie, zie Gebruik op Github.

Het is ook mogelijk om kubelogin te gebruiken als u wilt inloggen rechtstreeks op de computer van de gebruiker. In dit geval opent de gebruiker een browser met een inlogformulier op localhost.

De verkregen kubeconfig kan worden gecontroleerd op de site jwt.io. Kopieer gewoon de waarde users[].user.auth-provider.config.id-token uit uw kubeconfig in het formulier op de site en ontvang direct de ontcijfering.

RBAC configuratie

Bij het instellen van RBAC kan zowel naar de gebruikersnaam (veld naam in het jwt-token), als naar de gebruikersgroep (veld groepen in het jwt-token) worden verwezen. Hier is een voorbeeld van het instellen van rechten voor de groep 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

Meer voorbeelden voor RBAC zijn te vinden in de officiële Kubernetes documentatie

Configuratie van auth-proxy

Er is een geweldig project keycloak-gatekeeper, dat het mogelijk maakt om elke applicatie te beveiligen door gebruikers de mogelijkheid te bieden zich aan te melden op de OIDC-server. Ik zal laten zien hoe je het kunt instellen aan de hand van 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

Bron: habr.com