ჩვენ ვამაგრებთ LDAP ავტორიზაციას Kubernetes-ზე

მოკლე გაკვეთილი იმის შესახებ, თუ როგორ შეგიძლიათ გამოიყენოთ Keycloak Kubernetes-ის თქვენს LDAP სერვერთან დასაკავშირებლად და მომხმარებლებისა და ჯგუფების იმპორტის კონფიგურაციისთვის. ეს საშუალებას მოგცემთ დააკონფიგურიროთ RBAC თქვენი მომხმარებლებისთვის და გამოიყენოთ auth-proxy Kubernetes Dashboard და სხვა აპლიკაციების დასაცავად, რომლებსაც არ შეუძლიათ საკუთარი თავის ავტორიზაცია.

Keycloak ინსტალაცია

დავუშვათ, რომ თქვენ უკვე გაქვთ LDAP სერვერი. ეს შეიძლება იყოს Active Directory, FreeIPA, OpenLDAP ან რაიმე სხვა. თუ თქვენ არ გაქვთ LDAP სერვერი, მაშინ პრინციპში შეგიძლიათ შექმნათ მომხმარებლები პირდაპირ Keycloak ინტერფეისში, ან გამოიყენოთ საჯარო oidc პროვაიდერები (Google, Github, Gitlab), შედეგი თითქმის იგივე იქნება.

უპირველეს ყოვლისა, მოდით დავაინსტალიროთ თავად Keycloak. ინსტალაცია შეიძლება განხორციელდეს ცალკე ან პირდაპირ Kubernetes კლასტერში. როგორც წესი, თუ თქვენ გაქვთ რამდენიმე Kubernetes კლასტერი, უფრო ადვილი იქნება მისი ცალკე დაყენება. მეორეს მხრივ, ყოველთვის შეგიძლიათ გამოიყენოთ საჭის ოფიციალური სქემა და დააინსტალირეთ იგი პირდაპირ თქვენს კლასტერში.

Keycloak მონაცემების შესანახად დაგჭირდებათ მონაცემთა ბაზა. ნაგულისხმევია h2 (ყველა მონაცემი ინახება ადგილობრივად), მაგრამ მისი გამოყენებაც შესაძლებელია postgres, mysql ან mariadb.
თუ მაინც გადაწყვეტთ Keycloak-ის ცალკე დაყენებას, უფრო დეტალურ ინსტრუქციებს იხილავთ აქ ოფიციალური დოკუმენტაცია.

ფედერაციის დაყენება

უპირველეს ყოვლისა, მოდით შევქმნათ ახალი სფერო. Realm არის ჩვენი განაცხადის სივრცე. თითოეულ აპლიკაციას შეიძლება ჰქონდეს საკუთარი სფერო სხვადასხვა მომხმარებლებით და ავტორიზაციის პარამეტრებით. სამაგისტრო სფეროს იყენებს თავად Keycloak და არასწორია მისი გამოყენება სხვა რამეში.

დააწკაპუნეთ აქ დაამატეთ სფერო

არჩევანი
ღირებულება

სახელი
kubernetes

ჩვენების სახელი
Kubernetes

HTML საჩვენებელი სახელი
<img src="https://kubernetes.io/images/nav_logo.svg" width="400" >

Kubernetes ნაგულისხმევად ამოწმებს მომხმარებლის ელფოსტა დადასტურებულია თუ არა. ვინაიდან ჩვენ ვიყენებთ საკუთარ LDAP სერვერს, ეს შემოწმება თითქმის ყოველთვის ბრუნდება false. მოდით გამორთოთ ამ ვარიანტის წარმოდგენა Kubernetes-ში:

კლიენტის ფარგლები -> Email -> მაპერები -> ელფოსტა დადასტურებულია (წაშლა)

ახლა მოდით შევქმნათ ფედერაცია; ამისათვის გადადით:

მომხმარებელთა ფედერაცია -> პროვაიდერის დამატება… -> Ldap

აქ მოცემულია FreeIPA-ს პარამეტრების მაგალითი:

არჩევანი
ღირებულება

კონსოლის საჩვენებელი სახელი
freeipa.example.org

Vendor
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]

Key Tab:
/etc/krb5.keytab

მომხმარებელი keycloak-svc უნდა შეიქმნას წინასწარ ჩვენს LDAP სერვერზე.

Active Directory-ის შემთხვევაში, თქვენ უბრალოდ უნდა აირჩიოთ გამყიდველი: Active Directory და საჭირო პარამეტრები ავტომატურად შეიტანება ფორმაში.

დააწკაპუნეთ აქ გადარჩენა

ახლა გადავიდეთ:

მომხმარებელთა ფედერაცია -> freeipa.example.org -> მაპერები -> First Name

არჩევანი
ღირებულება

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

ახლა, როდესაც ფედერაციის დაყენება დასრულდა, მოდით გადავიდეთ კლიენტის დაყენებაზე.

კლიენტის დაყენება

მოდით შევქმნათ ახალი კლიენტი (აპლიკაცია, რომელიც მიიღებს მომხმარებლებს Keycloak-დან). მოდით გადავიდეთ:

კლიენტები -> შექმნა

არჩევანი
ღირებულება

კლიენტის 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

დავაჭიროთ გადარჩენა და ამით კლიენტის დაყენება დასრულდა, ახლა ჩანართზე

კლიენტები -> კუბერნეტები -> რწმუნებათა სიგელების გადაცემის

შენ შეგიძლია მიიღო საიდუმლო რომელსაც შემდგომ გამოვიყენებთ.

Kubernetes-ის კონფიგურაცია

Kubernetes-ის დაყენება OIDC ავტორიზაციისთვის საკმაოდ ტრივიალურია და არც ისე რთული. ყველაფერი რაც თქვენ უნდა გააკეთოთ არის თქვენი 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
...

ეს ასრულებს Kubernetes-ის კონფიგურაციას. შეგიძლიათ გაიმეოროთ ეს ნაბიჯები თქვენს Kubernetes-ის ყველა კლასტერში.

თავდაპირველი ავტორიზაცია

ამ ნაბიჯების შემდეგ, თქვენ უკვე გექნებათ Kubernetes კლასტერი კონფიგურირებული OIDC ავტორიზაციით. ერთადერთი ის არის, რომ თქვენს მომხმარებლებს ჯერ არ აქვთ კონფიგურირებული კლიენტი ან საკუთარი kubeconfig. ამ პრობლემის გადასაჭრელად, თქვენ უნდა დააკონფიგურიროთ kubeconfig-ის ავტომატური განაწილება მომხმარებლებზე წარმატებული ავტორიზაციის შემდეგ.

ამისათვის შეგიძლიათ გამოიყენოთ სპეციალური ვებ აპლიკაციები, რომლებიც საშუალებას გაძლევთ დაადასტუროთ მომხმარებლის ავტორიზაცია და შემდეგ ჩამოტვირთოთ მზა kubeconfig. ერთ-ერთი ყველაზე მოსახერხებელია კუბეროსი, ის საშუალებას გაძლევთ აღწეროთ Kubernetes-ის ყველა კლასტერი ერთ კონფიგურაციაში და მარტივად გადახვიდეთ მათ შორის.

Kuberos-ის კონფიგურაციისთვის, უბრალოდ აღწერეთ kubeconfig-ის შაბლონი და გაუშვით იგი შემდეგი პარამეტრებით:

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

უფრო დეტალური ინფორმაციისთვის იხ გამოყენება Github-ზე.

მისი გამოყენებაც შესაძლებელია კუბელოგინი თუ გსურთ ავტორიზაცია პირდაპირ მომხმარებლის კომპიუტერზე. ამ შემთხვევაში, მომხმარებელი გახსნის ბრაუზერს ავტორიზაციის ფორმით ლოკალჰოსტზე.

შედეგად მიღებული 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-ის მეტი მაგალითები შეგიძლიათ იხილოთ აქ ოფიციალური Kubernetes დოკუმენტაცია

ავტორიზაციის პროქსის დაყენება

მშვენიერი პროექტია კლავიატურა-კარიბჭე, რომელიც საშუალებას გაძლევთ დაიცვათ ნებისმიერი აპლიკაცია მომხმარებლისთვის OIDC სერვერზე ავთენტიფიკაციის შესაძლებლობით. მე გაჩვენებთ, თუ როგორ უნდა დააკონფიგურიროთ იგი 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=<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