ഞങ്ങൾ കുബെർനെറ്റസിലേക്ക് LDAP അംഗീകാരം ഉറപ്പിക്കുന്നു

നിങ്ങളുടെ LDAP സെർവറിലേക്ക് Kubernetes ബന്ധിപ്പിക്കുന്നതിനും ഉപയോക്താക്കളുടെയും ഗ്രൂപ്പുകളുടെയും ഇറക്കുമതി സജ്ജീകരിക്കുന്നതിനും Keycloak എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചുള്ള ഒരു ചെറിയ ട്യൂട്ടോറിയൽ. ഇത് നിങ്ങളുടെ ഉപയോക്താക്കൾക്കായി RBAC സജ്ജീകരിക്കാനും Kubernetes ഡാഷ്‌ബോർഡും സ്വയം എങ്ങനെ അംഗീകരിക്കണമെന്ന് അറിയാത്ത മറ്റ് ആപ്ലിക്കേഷനുകളും പരിരക്ഷിക്കുന്നതിന് auth-proxy ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കും.

കീക്ലോക്ക് ഇൻസ്റ്റാളേഷൻ

നിങ്ങൾക്ക് ഇതിനകം ഒരു LDAP സെർവർ ഉണ്ടെന്ന് കരുതുക. അത് ആക്റ്റീവ് ഡയറക്ടറി, ഫ്രീഐപിഎ, ഓപ്പൺഎൽഡിഎപി അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും ആകാം. നിങ്ങൾക്ക് ഒരു LDAP സെർവർ ഇല്ലെങ്കിൽ, തത്വത്തിൽ നിങ്ങൾക്ക് Keycloak ഇന്റർഫേസിൽ നേരിട്ട് ഉപയോക്താക്കളെ സൃഷ്ടിക്കാം, അല്ലെങ്കിൽ പൊതു oidc ദാതാക്കളെ (Google, Github, Gitlab) ഉപയോഗിക്കാം, ഫലം ഏതാണ്ട് സമാനമായിരിക്കും.

ഒന്നാമതായി, നമുക്ക് കീക്ലോക്ക് തന്നെ ഇൻസ്റ്റാൾ ചെയ്യാം, ഇൻസ്റ്റാളേഷൻ പ്രത്യേകം അല്ലെങ്കിൽ നേരിട്ട് കുബർനെറ്റ്സ് ക്ലസ്റ്ററിലേക്ക് നടത്താം, ഒരു ചട്ടം പോലെ, നിങ്ങൾക്ക് നിരവധി കുബർനെറ്റ്സ് ക്ലസ്റ്ററുകൾ ഉണ്ടെങ്കിൽ, അത് വെവ്വേറെ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് എളുപ്പമായിരിക്കും. മറുവശത്ത്, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉപയോഗിക്കാം ഔദ്യോഗിക തല ചാർട്ട് നിങ്ങളുടെ ക്ലസ്റ്ററിലേക്ക് നേരിട്ട് ഇൻസ്റ്റാൾ ചെയ്യുക.

കീക്ലോക്ക് ഡാറ്റ സംഭരിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു ഡാറ്റാബേസ് ആവശ്യമാണ്. സ്ഥിരസ്ഥിതിയാണ് h2 (എല്ലാ ഡാറ്റയും പ്രാദേശികമായി സംഭരിച്ചിരിക്കുന്നു), എന്നാൽ ഇത് ഉപയോഗിക്കാനും സാധ്യമാണ് postgres, mysql അഥവാ mariadb.
നിങ്ങൾ ഇപ്പോഴും കീക്ലോക്ക് വെവ്വേറെ ഇൻസ്റ്റാൾ ചെയ്യാൻ തീരുമാനിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് കൂടുതൽ വിശദമായ നിർദ്ദേശങ്ങൾ കണ്ടെത്താനാകും ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ.

ഫെഡറേഷൻ ക്രമീകരണം

ഒന്നാമതായി, നമുക്ക് ഒരു പുതിയ മണ്ഡലം സൃഷ്ടിക്കാം. ഞങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ഇടമാണ് രാജ്യം. ഓരോ ആപ്ലിക്കേഷനും വ്യത്യസ്‌ത ഉപയോക്താക്കളും അംഗീകാര ക്രമീകരണങ്ങളും ഉള്ള സ്വന്തം മേഖല ഉണ്ടായിരിക്കാം. പ്രധാന മണ്ഡലം കീക്ലോക്ക് തന്നെ ഉപയോഗിക്കുന്നു, അത് മറ്റെന്തിനും ഉപയോഗിക്കുന്നത് തെറ്റാണ്.

പുഷ് മണ്ഡലം ചേർക്കുക

ഓപ്ഷൻ
വില

പേര്
kubernetes

പ്രദർശന നാമം
Kubernetes

HTML ഡിസ്പ്ലേ നാമം
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

ഉപയോക്താവിന്റെ ഇമെയിൽ സ്ഥിരീകരിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന് സ്ഥിരസ്ഥിതിയായി Kubernetes പരിശോധിക്കുന്നു. ഞങ്ങൾ ഞങ്ങളുടെ സ്വന്തം LDAP സെർവർ ഉപയോഗിക്കുന്നതിനാൽ, ഈ ചെക്ക് മിക്കവാറും എല്ലായ്‌പ്പോഴും മടങ്ങിവരും false. Kubernetes-ൽ ഈ ക്രമീകരണത്തിന്റെ പ്രാതിനിധ്യം പ്രവർത്തനരഹിതമാക്കാം:

ക്ലയന്റ് സ്കോപ്പുകൾ -> ഇമെയിൽ -> മാപ്പർമാർ -> ഇമെയിൽ പരിശോധിച്ചു (ഇല്ലാതാക്കുക)

ഇനി നമുക്ക് ഫെഡറേഷൻ സജ്ജീകരിക്കാം, ഇതിനായി നമ്മൾ പോകുന്നു:

യൂസർ ഫെഡറേഷൻ -> ദാതാവിനെ ചേർക്കുക... -> ldap

FreeIPA-യ്ക്കുള്ള ഒരു ഉദാഹരണ സജ്ജീകരണം ഇതാ:

ഓപ്ഷൻ
വില

കൺസോൾ ഡിസ്പ്ലേ പേര്
freeipa.example.org

വെണ്ടർ
Red Hat Directory Server

UUID LDAP ആട്രിബ്യൂട്ട്
ipauniqueid

കണക്ഷൻ URL
ldaps://freeipa.example.org

ഉപയോക്താവ് DN
cn=users,cn=accounts,dc=example,dc=org

DN ബൈൻഡ് ചെയ്യുക
uid=keycloak-svc,cn=users,cn=accounts,dc=example,dc=org

ക്രെഡൻഷ്യൽ ബൈൻഡ് ചെയ്യുക
<password>

Kerberos പ്രാമാണീകരണം അനുവദിക്കുക:
on

കെർബറോസ് സാമ്രാജ്യം:
EXAMPLE.ORG

സെർവർ പ്രിൻസിപ്പൽ:
HTTP/[email protected]

കീ ടാബ്:
/etc/krb5.keytab

ഉപയോക്താവ് keycloak-svc ഞങ്ങളുടെ LDAP സെർവറിൽ മുൻകൂട്ടി സൃഷ്ടിച്ചിരിക്കണം.

സജീവ ഡയറക്ടറിയുടെ കാര്യത്തിൽ, ലളിതമായി തിരഞ്ഞെടുക്കുക വെണ്ടർ: സജീവ ഡയറക്ടറി ആവശ്യമായ ക്രമീകരണങ്ങൾ സ്വയമേവ ഫോമിൽ ചേർക്കും.

പുഷ് രക്ഷിക്കും

ഇനി നമുക്ക് മുന്നോട്ട് പോകാം:

യൂസർ ഫെഡറേഷൻ -> freeipa.example.org -> മാപ്പർമാർ -> പേരിന്റെ ആദ്യഭാഗം

ഓപ്ഷൻ
വില

Ldap ആട്രിബ്യൂട്ടുകൾ
givenName

ഇപ്പോൾ ഗ്രൂപ്പ് മാപ്പിംഗ് പ്രവർത്തനക്ഷമമാക്കുക:

യൂസർ ഫെഡറേഷൻ -> freeipa.example.org -> മാപ്പർമാർ -> സൃഷ്ടിക്കാൻ

ഓപ്ഷൻ
വില

പേര്
groups

മാപ്പർ തരം
group-ldap-mapper

LDAP ഗ്രൂപ്പുകൾ DN
cn=groups,cn=accounts,dc=example,dc=org

ഉപയോക്തൃ ഗ്രൂപ്പ് വീണ്ടെടുക്കൽ തന്ത്രം
GET_GROUPS_FROM_USER_MEMBEROF_ATTRIBUTE

ഇത് ഫെഡറേഷൻ സജ്ജീകരണം പൂർത്തിയാക്കുന്നു, നമുക്ക് ക്ലയന്റ് സജ്ജീകരിക്കുന്നതിലേക്ക് പോകാം.

ക്ലയന്റ് സജ്ജീകരണം

നമുക്ക് ഒരു പുതിയ ക്ലയന്റ് സൃഷ്ടിക്കാം (കീക്ലോക്കിൽ നിന്ന് ഉപയോക്താക്കളെ സ്വീകരിക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ). നമുക്ക് പോകാം:

ക്ലയന്റുകൾ -> സൃഷ്ടിക്കാൻ

ഓപ്ഷൻ
വില

ക്ലയന്റ് ഐഡി
kubernetes

പ്രവേശന തരം
confidenrial

റൂട്ട് URL
http://kubernetes.example.org/

സാധുവായ റീഡയറക്‌ട് യുആർഐകൾ
http://kubernetes.example.org/*

അഡ്‌മിൻ URL
http://kubernetes.example.org/

ഗ്രൂപ്പുകൾക്കായി ഞങ്ങൾ ഒരു സ്കോപ്പും സൃഷ്ടിക്കും:

ക്ലയന്റ് സ്കോപ്പുകൾ -> സൃഷ്ടിക്കാൻ

ഓപ്ഷൻ
വില

ഫലകം
No template

പേര്
groups

മുഴുവൻ ഗ്രൂപ്പ് പാത
false

അവർക്കായി ഒരു മാപ്പർ സജ്ജമാക്കുക:

ക്ലയന്റ് സ്കോപ്പുകൾ -> ഗ്രൂപ്പുകൾ -> മാപ്പർമാർ -> സൃഷ്ടിക്കാൻ

ഓപ്ഷൻ
വില

പേര്
groups

മാപ്പർ തരം
Group membership

ടോക്കൺ ക്ലെയിം പേര്
groups

ഇപ്പോൾ ഞങ്ങളുടെ ക്ലയന്റ് സ്കോപ്പിൽ ഗ്രൂപ്പ് മാപ്പിംഗ് പ്രവർത്തനക്ഷമമാക്കേണ്ടതുണ്ട്:

ക്ലയന്റുകൾ -> കുബേർനെറ്റ്സ് -> ക്ലയന്റ് സ്കോപ്പുകൾ -> ഡിഫോൾട്ട് ക്ലയന്റ് സ്കോപ്പുകൾ

തിരഞ്ഞെടുക്കുക ഗ്രൂപ്പുകൾ в ലഭ്യമായ ക്ലയന്റ് സ്കോപ്പുകൾക്ലിക്കുചെയ്യുക തിരഞ്ഞെടുത്തത് ചേർക്കുക

ഇനി നമുക്ക് നമ്മുടെ ആപ്ലിക്കേഷന്റെ ആധികാരികത സജ്ജീകരിക്കാം, ഇതിലേക്ക് പോകുക:

ക്ലയന്റുകൾ -> കുബേർനെറ്റ്സ്

ഓപ്ഷൻ
വില

അംഗീകാരം പ്രവർത്തനക്ഷമമാക്കി
ON

നമുക്ക് തള്ളാം സംരക്ഷിക്കുക ഇത് ക്ലയന്റ് സജ്ജീകരണം പൂർത്തിയാക്കുന്നു, ഇപ്പോൾ ടാബിൽ

ക്ലയന്റുകൾ -> കുബേർനെറ്റ്സ് -> ക്രെഡൻഷ്യൽ

നിങ്ങൾക്ക് കിട്ടാം സീക്രട്ട് അത് ഞങ്ങൾ പിന്നീട് ഉപയോഗിക്കും.

കുബർനെറ്റസ് കോൺഫിഗർ ചെയ്യുന്നു

OIDC അംഗീകാരത്തിനായി Kubernetes സജ്ജീകരിക്കുന്നത് വളരെ നിസ്സാരമാണ്, വളരെ സങ്കീർണ്ണമായ ഒന്നല്ല. നിങ്ങളുടെ OIDC സെർവറിന്റെ CA സർട്ടിഫിക്കറ്റ് ഇടുക മാത്രമാണ് നിങ്ങൾ ചെയ്യേണ്ടത് /etc/kubernetes/pki/oidc-ca.pem കൂടാതെ kube-apiserver-ന് ആവശ്യമായ ഓപ്ഷനുകൾ ചേർക്കുക.
ഇത് ചെയ്യുന്നതിന്, അപ്ഡേറ്റ് ചെയ്യുക /etc/kubernetes/manifests/kube-apiserver.yaml നിങ്ങളുടെ എല്ലാ യജമാനന്മാരിലും:

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

അപ്‌ഡേറ്റ് സമയത്ത് ഈ ക്രമീകരണങ്ങൾ നഷ്‌ടപ്പെടാതിരിക്കാൻ ക്ലസ്റ്ററിലെ kubeadm കോൺഫിഗറേഷനും അപ്‌ഡേറ്റ് ചെയ്യുക:

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

ഇത് കുബർനെറ്റസ് സജ്ജീകരണം പൂർത്തിയാക്കുന്നു. നിങ്ങളുടെ എല്ലാ കുബർനെറ്റസ് ക്ലസ്റ്ററുകളിലുടനീളം നിങ്ങൾക്ക് ഈ ഘട്ടങ്ങൾ ആവർത്തിക്കാം.

പ്രാരംഭ അംഗീകാരം

ഈ ഘട്ടങ്ങൾക്ക് ശേഷം, നിങ്ങൾക്ക് ഇതിനകം തന്നെ OIDC അംഗീകാരമുള്ള ഒരു കുബർനെറ്റസ് ക്ലസ്റ്റർ ഉണ്ടായിരിക്കും. നിങ്ങളുടെ ഉപയോക്താക്കൾക്ക് ഇതുവരെ ഒരു ക്ലയന്റും അവരുടെ സ്വന്തം kubeconfig-ഉം കോൺഫിഗർ ചെയ്തിട്ടില്ല എന്നതാണ് ഏക കാര്യം. ഈ പ്രശ്നം പരിഹരിക്കുന്നതിന്, വിജയകരമായ അംഗീകാരത്തിന് ശേഷം ഉപയോക്താക്കൾക്ക് kubeconfig-ന്റെ സ്വയമേവ ഇഷ്യൂ ചെയ്യുന്നത് നിങ്ങൾ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്.

ഇത് ചെയ്യുന്നതിന്, ഉപയോക്താവിനെ ആധികാരികമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന പ്രത്യേക വെബ് ആപ്ലിക്കേഷനുകൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം, തുടർന്ന് പൂർത്തിയായ kubeconfig ഡൗൺലോഡ് ചെയ്യുക. ഏറ്റവും സൗകര്യപ്രദമായ ഒന്നാണ് കുബേരോസ്, എല്ലാ കുബർനെറ്റസ് ക്ലസ്റ്ററുകളും ഒരു കോൺഫിഗറിൽ വിവരിക്കാനും അവയ്ക്കിടയിൽ എളുപ്പത്തിൽ മാറാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

Kuberos കോൺഫിഗർ ചെയ്യുന്നതിന്, kubeconfig-നുള്ള ടെംപ്ലേറ്റ് വിവരിച്ച് ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് പ്രവർത്തിപ്പിച്ചാൽ മതിയാകും:

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

കൂടുതൽ വിവരങ്ങൾക്ക് കാണുക ഉപയോഗം Github-ൽ.

ഉപയോഗിക്കാനും സാധിക്കും kubelogin നിങ്ങൾക്ക് ഉപയോക്താവിന്റെ കമ്പ്യൂട്ടറിൽ നേരിട്ട് അംഗീകാരം നൽകണമെങ്കിൽ. ഈ സാഹചര്യത്തിൽ, ഉപയോക്താവ് ലോക്കൽ ഹോസ്റ്റിൽ ഒരു അംഗീകാര ഫോം ഉള്ള ഒരു ബ്രൗസർ തുറക്കും.

തത്ഫലമായുണ്ടാകുന്ന kubeconfig സൈറ്റിൽ പരിശോധിക്കാവുന്നതാണ് jwt.io. മൂല്യം പകർത്തിയാൽ മതി users[].user.auth-provider.config.id-token നിങ്ങളുടെ kubeconfig-ൽ നിന്ന് സൈറ്റിലെ ഒരു ഫോമിലേക്ക് ഉടൻ തന്നെ ട്രാൻസ്ക്രിപ്റ്റ് നേടുക.

RBAC സജ്ജീകരണം

RBAC കോൺഫിഗർ ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് രണ്ട് ഉപയോക്തൃനാമവും (ഫീൽഡ് name jwt ടോക്കണിലും ഒരു കൂട്ടം ഉപയോക്താക്കൾക്കും (ഫീൽഡ് groups jwt ടോക്കണിൽ). ഒരു ഗ്രൂപ്പിനുള്ള അനുമതികൾ ക്രമീകരിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ 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

RBAC-യുടെ കൂടുതൽ ഉദാഹരണങ്ങൾ ഇതിൽ കാണാം ഔദ്യോഗിക കുബർനെറ്റസ് ഡോക്യുമെന്റേഷൻ

auth-proxy സജ്ജീകരിക്കുന്നു

അതിശയകരമായ ഒരു പദ്ധതിയുണ്ട് കീക്ലോക്ക്-ഗേറ്റ്കീപ്പർ, OIDC സെർവറിലേക്ക് ആധികാരികത ഉറപ്പാക്കാൻ ഉപയോക്താവിനെ അനുവദിച്ചുകൊണ്ട് ഏത് ആപ്ലിക്കേഷനും സുരക്ഷിതമാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു ഉദാഹരണമായി കുബർനെറ്റസ് ഡാഷ്‌ബോർഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് എങ്ങനെ സജ്ജീകരിക്കാമെന്ന് ഞാൻ കാണിച്ചുതരാം:

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

അവലംബം: www.habr.com