ProHoster > Blog > Administratioun > Mir befestegt LDAP Autorisatioun ze Kubernetes

Mir befestegt LDAP Autorisatioun ze Kubernetes

Mir befestegt LDAP Autorisatioun ze Kubernetes

E kuerzen Tutorial iwwer wéi Dir Keycloak benotze kënnt fir Kubernetes mat Ärem LDAP Server ze verbannen an den Import vu Benotzer a Gruppen ze konfiguréieren. Dëst erlaabt Iech RBAC fir Är Benotzer ze konfiguréieren an Auth-Proxy ze benotzen fir Kubernetes Dashboard an aner Uwendungen ze schützen déi sech net kënnen authentifizéieren.

Keycloak Installatioun

Loosst eis unhuelen datt Dir schonn en LDAP Server hutt. Dëst kéint Active Directory, FreeIPA, OpenLDAP oder soss eppes sinn. Wann Dir keen LDAP-Server hutt, da kënnt Dir am Prinzip Benotzer direkt an der Keycloak-Interface erstellen, oder ëffentlech oidc-Provider benotzen (Google, Github, Gitlab), d'Resultat wäert bal d'selwecht sinn.

Éischtens, loosst eis Keycloak selwer installéieren.D'Installatioun kann separat oder direkt an e Kubernetes Cluster gemaach ginn.An der Regel, wann Dir e puer Kubernetes Cluster hutt, wier et méi einfach, se separat ze installéieren. Op der anerer Säit kënnt Dir ëmmer benotzen offiziell Helm Chart an installéiert et direkt an Äre Stärekoup.

Fir Keycloak Daten ze späicheren braucht Dir eng Datebank. Standard ass h2 (all Daten ginn lokal gespäichert), awer et ass och méiglech ze benotzen postgres, mysql oder mariadb.
Wann Dir nach ëmmer decidéiert Keycloak separat z'installéieren, fannt Dir méi detailléiert Instruktiounen an offiziell Dokumentatioun.

Federatioun Opstellung

Éischtens, loosst eis en neit Räich erstellen. Räich ass de Raum vun eiser Applikatioun. All Applikatioun kann säin eegene Räich mat verschiddene Benotzer an Autorisatiounsastellungen hunn. De Master Räich gëtt vum Keycloak selwer benotzt an et ass falsch et fir soss eppes ze benotzen.

Push Füügt Räich

Optioun
Wäert

Numm
kubernetes

Unzeigenumm
Kubernetes

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

Kubernetes iwwerpréift par défaut ob d'E-Mail vum Benotzer bestätegt ass oder net. Well mir eisen eegene LDAP-Server benotzen, kënnt dës Scheck bal ëmmer zréck false. Loosst eis d'Vertriedung vun dëser Optioun a Kubernetes deaktivéieren:

Client Ëmfang -> Email -> Mappers -> E-Mail verifizéiert (Läschen)

Loosst eis elo d'Federatioun opstellen; Fir dëst ze maachen, gitt op:

Benotzer Federatioun -> Füügt Provider ... -> ldap

Hei ass e Beispill vun Astellunge fir FreeIPA:

Optioun
Wäert

Konsol Display Numm
freeipa.example.org

Vendor
Red Hat Directory Server

UUID LDAP Attribut
ipauniqueid

Verbindung URL
ldaps://freeipa.example.org

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

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

Bindung Umeldungsinformatioun
<password>

Erlaabt Kerberos Authentifikatioun:
on

Kerberos Räich:
EXAMPLE.ORG

Server Principal:
HTTP/[email protected]

KeyTab:
/etc/krb5.keytab

Benotzer keycloak-svc muss am Viraus op eisem LDAP Server erstallt ginn.

Am Fall vun Active Directory musst Dir just wielen Verkeefer: Active Directory an déi néideg Astellunge ginn automatesch an d'Form agefouert.

Push spueren

Elo geet et weider:

Benotzer Federatioun -> freeipa.example.org -> Mappers -> Virnumm

Optioun
Wäert

Ldap Attribut
givenName

Loosst eis elo d'Gruppmapping aktivéieren:

Benotzer Federatioun -> freeipa.example.org -> Mappers -> schafen

Optioun
Wäert

Numm
groups

Mapper Typ
group-ldap-mapper

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

Benotzer Gruppen Retrieve Strategie
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

Elo datt d'Federatiounskonfiguratioun fäerdeg ass, loosst eis weidergoen fir de Client opzestellen.

Client Setup

Loosst eis en neie Client erstellen (eng Applikatioun déi Benotzer vu Keycloak kritt). Loosst eis weider goen:

Clienten -> schafen

Optioun
Wäert

Client ID
kubernetes

Zougang Typ
confidenrial

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

Gülteg Viruleedung URIs
http://kubernetes.example.org/*

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

Loosst eis och e Spillraum fir Gruppen erstellen:

Client Ëmfang -> schafen

Optioun
Wäert

Schabloun
No template

Numm
groups

Voll Grupp Wee
false

A setzt e Mapper fir si op:

Client Ëmfang -> Gruppen -> Mappers -> schafen

Optioun
Wäert

Numm
groups

Mapper Typ
Group membership

Token Fuerderung Numm
groups

Elo musse mir d'Mapping Grupp an eisem Client Ëmfang aktivéieren:

Clienten -> kubernetes -> Client Ëmfang -> Standard Client Ëmfang

Wielt Gruppen в Verfügbar Client Ëmfangklickt auszeschalten Add ausgewielt

Loosst eis elo d'Authentifikatioun vun eiser Applikatioun konfiguréieren, gitt op:

Clienten -> kubernetes

Optioun
Wäert

Autorisatioun aktivéiert
ON

Loosst eis drécken retten a mat dësem ass de Client Setup fäerdeg, elo op der Tab

Clienten -> kubernetes -> Règlementer

Dir kënnt kréien Geheim déi mir weider benotzen.

Kubernetes konfiguréieren

Kubernetes fir OIDC Autorisatioun opzestellen ass zimlech trivial an net ganz komplizéiert. Alles wat Dir maache musst ass de CA Zertifika vun Ärem OIDC Server anzesetzen /etc/kubernetes/pki/oidc-ca.pem a füügt déi néideg Optiounen fir kube-apiserver.
Fir dëst ze maachen, update /etc/kubernetes/manifests/kube-apiserver.yaml op all Är Hären:

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

Update och d'kubeadm Config am Cluster fir dës Astellungen net ze verléieren beim 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
...

Dëst fäerdeg de Kubernetes Setup. Dir kënnt dës Schrëtt iwwer all Är Kubernetes Cluster widderhuelen.

Éischt Autorisatioun

No dëse Schrëtt hutt Dir schonn e Kubernetes Cluster mat konfiguréierter OIDC Autorisatioun. Déi eenzeg Saach ass datt Är Benotzer nach kee konfiguréierte Client oder hiren eegene kubeconfig hunn. Fir dëse Problem ze léisen, musst Dir automatesch Verdeelung vu kubeconfig un d'Benotzer konfiguréieren no erfollegräicher Autorisatioun.

Fir dëst ze maachen, kënnt Dir speziell Webapplikatiounen benotzen, déi Iech erlaben de Benotzer ze authentifizéieren an dann de fäerdege Kubeconfig erofzelueden. Ee vun de bequemste ass Kuberos, et erlaabt Iech all Kubernetes Cluster an enger Konfiguratioun ze beschreiwen an einfach tëscht hinnen ze wiesselen.

Fir Kuberos ze konfiguréieren, beschreiwen just d'Schabloun fir kubeconfig a lafen se mat de folgende Parameteren:

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

Fir méi detailléiert Informatiounen gesinn Verwendung op Github.

Et ass och méiglech ze benotzen kubelogin wann Dir wëllt direkt op de Benotzer d'Computer autoriséiert. An dësem Fall wäert de Benotzer e Browser mat engem Autorisatiounsform op localhost opmaachen.

Déi resultéierend kubeconfig kann op der Websäit gepréift ginn jwt.io. Kopie Just de Wäert users[].user.auth-provider.config.id-token vun Ärem kubeconfig op de Formulaire op der Websäit a kritt direkt en Transkript.

Ariichten RBAC

Wann Dir RBAC konfiguréiert, kënnt Dir souwuel de Benotzernumm (Feld name am jwt Token), a pro Benotzergrupp (Feld groups an jwt token). Hei ass e Beispill fir Rechter fir eng Grupp opzestellen 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

Méi Beispiller fir RBAC fannt Dir an offiziell Kubernetes Dokumentatioun

Auth-Proxy astellen

Et gëtt e flotte Projet keycloak-gatekeeper, wat Iech erlaabt all Applikatioun ze schützen andeems Dir de Benotzer d'Fäegkeet gëtt fir den OIDC Server ze authentifizéieren. Ech weisen Iech wéi Dir et mat Kubernetes Dashboard als Beispill konfiguréiert:

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

Source: will.com

Setzt e Commentaire