We koppelen LDAP-autorisatie aan Kubernetes

Een korte tutorial over hoe u Keycloak kunt gebruiken om Kubernetes met uw LDAP-server te verbinden en de import van gebruikers en groepen te configureren. Hiermee kunt u RBAC voor uw gebruikers configureren en auth-proxy gebruiken om Kubernetes Dashboard en andere applicaties te beschermen die zichzelf niet kunnen verifiëren.

Keycloak-installatie

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

Laten we eerst Keycloak zelf installeren, de installatie kan afzonderlijk worden uitgevoerd, of rechtstreeks op het Kubernetes-cluster. Als u meerdere Kubernetes-clusters heeft, is het in de regel eenvoudiger om deze afzonderlijk te installeren. Aan de andere kant kun je altijd gebruiken officiële roerkaart en installeer het rechtstreeks in uw cluster.

Om Keycloak-gegevens op te slaan heeft u een database nodig. Standaard is h2 (alle gegevens worden lokaal opgeslagen), maar het is ook mogelijk om er gebruik van te maken postgres, mysql of mariadb.
Als u toch besluit Keycloak afzonderlijk te installeren, vindt u meer gedetailleerde instructies in officiële documentatie.

Federatie instellen

Laten we eerst een nieuw rijk creëren. Realm is de ruimte van onze applicatie. Elke applicatie kan zijn eigen domein hebben met verschillende gebruikers en autorisatie-instellingen. Het Meesterrijk wordt door Keycloak zelf gebruikt en het is verkeerd om het voor iets anders te gebruiken.

Klik Rijk toevoegen

Keuze
Waarde

Naam
kubernetes

Weergavenaam
Kubernetes

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

Kubernetes controleert standaard of de e-mail van de gebruiker is bevestigd of niet. Omdat we onze eigen LDAP-server gebruiken, komt deze controle vrijwel altijd terug false. Laten we de weergave van deze optie in Kubernetes uitschakelen:

Klantbereiken -> E-mail -> Mappers -> email geverifieerd (Verwijderen)

Laten we nu de federatie opzetten, hiervoor gaan we naar:

Gebruikersfederatie -> Aanbieder toevoegen… -> ldap

Hier is een voorbeeld van instellingen voor FreeIPA:

Keuze
Waarde

Consoleweergavenaam
freeipa.example.org

Verkoper
Red Hat Directory Server

UUID LDAP-kenmerk
ipauniqueid

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

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

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

Inloggegevens binden
<password>

Kerberos-authenticatie toestaan:
on

Kerberos-rijk:
EXAMPLE.ORG

Server-principal:
HTTP/[email protected]

KeyTab:
/etc/krb5.keytab

Gebruiker keycloak-svc moet vooraf op onze LDAP-server worden aangemaakt.

In het geval van Active Directory selecteert u eenvoudigweg Leverancier: Active Directory en de benodigde instellingen worden automatisch in het formulier ingevoegd.

Klik Bespaar

Laten we nu verder gaan:

Gebruikersfederatie -> freeipa.voorbeeld.org -> Mappers -> Voornaam

Keuze
Waarde

Ldap-kenmerk
givenName

Laten we nu groepstoewijzing inschakelen:

Gebruikersfederatie -> freeipa.voorbeeld.org -> Mappers -> creëren

Keuze
Waarde

Naam
groups

Mapper-type
group-ldap-mapper

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

Gebruikersgroepen halen strategie op
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Hiermee is de configuratie van de federatie voltooid. Laten we verder gaan met het instellen van de client.

Cliënt instellen

Laten we een nieuwe client aanmaken (een applicatie die gebruikers van Keycloak zal ontvangen). Laten we verder gaan:

Klanten -> creëren

Keuze
Waarde

klant-ID
kubernetes

Toegangstype
confidenrial

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

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

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

Ook voor groepen creëren we ruimte:

Klantbereik -> creëren

Keuze
Waarde

Sjabloon
No template

Naam
groups

Volledig groepspad
false

En stel een mapper voor ze in:

Klantbereik -> groepen -> Mappers -> creëren

Keuze
Waarde

Naam
groups

Mapper-type
Group membership

Tokenclaimnaam
groups

Nu moeten we de toewijzingsgroep inschakelen in ons clientbereik:

Klanten -> kubernetes -> Klantbereik -> Standaard clientbereiken

kiezen groepen в Beschikbare klantbereiken, druk op Voeg geselecteerde toe

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

Klanten -> kubernetes

Keuze
Waarde

Autorisatie ingeschakeld
ON

Laten we drukken besparen en hiermee is de clientconfiguratie voltooid, nu op het tabblad

Klanten -> kubernetes -> Geloofsbrieven

je kan krijgen Geheim die we verder zullen gebruiken.

Kubernetes configureren

Het opzetten van Kubernetes voor OIDC-autorisatie is vrij triviaal en niet erg ingewikkeld. Het enige wat u hoeft te doen is het CA-certificaat van uw OIDC-server in te voeren /etc/kubernetes/pki/oidc-ca.pem en voeg de benodigde opties voor kube-apiserver toe.
Om dit te doen, moet u updaten /etc/kubernetes/manifests/kube-apiserver.yaml op al je meesters:

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

En update ook de kubeadm-configuratie in het cluster om deze instellingen tijdens de update niet te verliezen:

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

Hiermee is de Kubernetes-installatie voltooid. U kunt deze stappen herhalen voor al uw Kubernetes-clusters.

Initiële autorisatie

Na deze stappen beschikt u al over een Kubernetes-cluster met geconfigureerde OIDC-autorisatie. Het enige is dat uw gebruikers nog geen geconfigureerde client of een eigen kubeconfig hebben. Om dit probleem op te lossen, moet u de automatische distributie van kubeconfig naar gebruikers configureren na succesvolle autorisatie.

Hiervoor kunt u speciale webapplicaties gebruiken waarmee u de gebruiker kunt authenticeren en vervolgens de kant-en-klare kubeconfig kunt downloaden. Een van de handigste is Kubero's, kunt u alle Kubernetes-clusters in één configuratie beschrijven en er eenvoudig tussen schakelen.

Om Kuberos te configureren, beschrijft u gewoon de sjabloon voor kubeconfig en voert u deze uit met de volgende parameters:

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 te gebruiken kubelogin als u rechtstreeks op de computer van de gebruiker wilt autoriseren. In dit geval opent de gebruiker een browser met een autorisatieformulier op localhost.

De resulterende kubeconfig kan op de site worden gecontroleerd jwt.io. Kopieer gewoon de waarde users[].user.auth-provider.config.id-token van uw kubeconfig naar een formulier op de site en ontvang meteen het transcript.

RBAC-opstelling

Bij het configureren van RBAC kunt u zowel naar de gebruikersnaam (field name in het jwt-token) en voor een groep gebruikers (field groups in jwt-token). Hier is een voorbeeld van het instellen van rechten voor een groep kubernetes-default-namespace-admins:

kubernetes-default-naamruimte-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 officiële Kubernetes-documentatie

auth-proxy instellen

Er is een prachtig project sleutelmantel-poortwachter, waarmee u elke toepassing kunt beschermen door de gebruiker de mogelijkheid te bieden zich te authenticeren bij de OIDC-server. Ik laat je zien hoe je het configureert met Kubernetes Dashboard als voorbeeld:

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=<your-client-secret-here>
        - --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: www.habr.com