ನಾವು ಕುಬರ್ನೆಟ್ಸ್ಗೆ LDAP ಅಧಿಕಾರವನ್ನು ಜೋಡಿಸುತ್ತೇವೆ

ನಿಮ್ಮ LDAP ಸರ್ವರ್‌ಗೆ Kubernetes ಅನ್ನು ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಬಳಕೆದಾರರು ಮತ್ತು ಗುಂಪುಗಳ ಆಮದನ್ನು ಹೊಂದಿಸಲು ಕೀಕ್ಲೋಕ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ಒಂದು ಸಣ್ಣ ಟ್ಯುಟೋರಿಯಲ್. ಇದು ನಿಮ್ಮ ಬಳಕೆದಾರರಿಗೆ RBAC ಅನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಮತ್ತು ತಮ್ಮನ್ನು ಹೇಗೆ ಅಧಿಕೃತಗೊಳಿಸಬೇಕೆಂದು ತಿಳಿದಿಲ್ಲದ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಕ್ಷಿಸಲು ದೃಢೀಕರಣ-ಪ್ರಾಕ್ಸಿಯನ್ನು ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಕೀಕ್ಲೋಕ್ ಸ್ಥಾಪನೆ

ನೀವು ಈಗಾಗಲೇ LDAP ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿರುವಿರಿ ಎಂದು ಭಾವಿಸೋಣ. ಇದು ಸಕ್ರಿಯ ಡೈರೆಕ್ಟರಿ, ಫ್ರೀಐಪಿಎ, ಓಪನ್‌ಎಲ್‌ಡಿಎಪಿ ಅಥವಾ ಯಾವುದಾದರೂ ಆಗಿರಬಹುದು. ನೀವು LDAP ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ತಾತ್ವಿಕವಾಗಿ ನೀವು ಕೀಕ್ಲೋಕ್ ಇಂಟರ್ಫೇಸ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಬಹುದು ಅಥವಾ ಸಾರ್ವಜನಿಕ 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. ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಈ ಸೆಟ್ಟಿಂಗ್‌ನ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸೋಣ:

ಗ್ರಾಹಕ ವ್ಯಾಪ್ತಿಗಳು -> ಮಿಂಚಂಚೆ -> ನಕ್ಷೆಗಳು -> ಇಮೇಲ್ ಪರಿಶೀಲಿಸಲಾಗಿದೆ (ಅಳಿಸಿ)

ಈಗ ನಾವು ಒಕ್ಕೂಟವನ್ನು ಸ್ಥಾಪಿಸೋಣ, ಇದಕ್ಕಾಗಿ ನಾವು ಹೋಗುತ್ತೇವೆ:

ಬಳಕೆದಾರರ ಒಕ್ಕೂಟ -> ಒದಗಿಸುವವರನ್ನು ಸೇರಿಸಿ... -> 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

ಬೈಂಡ್ ಡಿಎನ್
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

ಇದು ಫೆಡರೇಶನ್ ಸೆಟಪ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ, ಕ್ಲೈಂಟ್ ಅನ್ನು ಹೊಂದಿಸಲು ನಾವು ಹೋಗೋಣ.

ಕ್ಲೈಂಟ್ ಸೆಟಪ್

ಹೊಸ ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸೋಣ (ಕೀಕ್ಲೋಕ್‌ನಿಂದ ಬಳಕೆದಾರರನ್ನು ಸ್ವೀಕರಿಸುವ ಅಪ್ಲಿಕೇಶನ್). ಹೋಗೋಣ:

ಗ್ರಾಹಕರು -> ರಚಿಸಿ

ಆಯ್ಕೆ
ಮೌಲ್ಯ

ಗ್ರಾಹಕ ID
kubernetes

ಪ್ರವೇಶ ಪ್ರಕಾರ
confidenrial

ಮೂಲ URL
http://kubernetes.example.org/

ಮಾನ್ಯ ಮರುನಿರ್ದೇಶನ URI ಗಳು
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

ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ ನೋಡಿ ಬಳಕೆ ಗಿಥಬ್ ಮೇಲೆ.

ಬಳಸಲು ಸಹ ಸಾಧ್ಯವಿದೆ 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 ಗಾಗಿ ಹೆಚ್ಚಿನ ಉದಾಹರಣೆಗಳನ್ನು ಕಾಣಬಹುದು ಅಧಿಕೃತ ಕುಬರ್ನೆಟ್ಸ್ ದಸ್ತಾವೇಜನ್ನು

ದೃಢೀಕರಣ-ಪ್ರಾಕ್ಸಿಯನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಅದ್ಭುತ ಯೋಜನೆ ಇದೆ ಕೀಕ್ಲಾಕ್-ಗೇಟ್ ಕೀಪರ್, ಇದು OIDC ಸರ್ವರ್‌ಗೆ ದೃಢೀಕರಿಸಲು ಬಳಕೆದಾರರನ್ನು ಅನುಮತಿಸುವ ಮೂಲಕ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಕುಬರ್ನೆಟ್ಸ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಿಕೊಂಡು ನೀವು ಅದನ್ನು ಹೇಗೆ ಹೊಂದಿಸಬಹುದು ಎಂಬುದನ್ನು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ:

ಡ್ಯಾಶ್‌ಬೋರ್ಡ್-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