Dex के साथ कुबेरनेट्स में प्रमाणीकरण: LDAP को तेज करें

1. OpenLDAP स्थापित करें और उस पर STARTTLS समर्थन कॉन्फ़िगर करें। 
2. हम अपने संगठन की LDAP निर्देशिका की संरचना का वर्णन करते हैं ।
3. क्यूब-एपीआई सर्वर पर ओआईडीसी (ओपेनआईडी कनेक्ट) सपोर्ट सक्षम करें ।
   
4. उन डोमेन के लिए SAN प्रमाणपत्र प्राप्त करें जिनका उपयोग Dex करेगा ।
5. Dex और Dex-स्थापित करें, जहां हम LDAP निर्देशिका और स्थिर उपयोगकर्ताओं का वर्णन करते हैं । 
6. हम क्लस्टर के साथ काम करने के लिए अपने उपयोगकर्ता के kubeconfig उत्पन्न करेंगे ।
7. क्लस्टर में समूहों और उपयोगकर्ताओं के लिए RBAC प्रमाणीकरण सेट करें ।

OpenLDAP सर्वर को स्थापित और कॉन्फ़िगर करें

1. हम सर्वर से जुड़े हैं और हम OpenLDAP की स्थापना शुरू करते हैं। स्थापना के दौरान, हमें एक पासवर्ड सेट करने के लिए प्रेरित किया जाएगा:
   
   

   sudo apt update 
   sudo apt install slapd ldap-utils
   

   
   
2. हमारे डोमेन के लिए OpenLDAP को फिर से कॉन्फ़िगर करना:
   
   

   sudo dpkg-reconfigure slapd 
   

   
   
3. नहीं चुनें :
   
   
   
4. डोमेन नाम दर्ज करें:
   
   
   
5. संगठन का नाम दर्ज करें:
   
   
   
6. पासवर्ड प्रविष्टि दोहराएँ:
   
   
   
7. हम STARTTLS के लिए समर्थन शामिल करते हैं। हम आवश्यक पैकेज:
   
   

   sudo apt install gnutls-bin ssl-cert
   

   
   
8. CA-:
   
   

   sudo sh -c "certtool --generate-privkey > /etc/ssl/private/cakey.pem"
   

   
   
9. /etc/ssl/ca.info:
   
   

   cn = DTLN Company
   ca
   cert_signing_key
   

   
   
10. CA-a , :
    
    

    sudo certtool --generate-self-signed --load-privkey /etc/ssl/private/cakey.pem --template /etc/ssl/ca.info --outfile /etc/ssl/certs/cacert.pem
    sudo certtool --generate-privkey --bits 1024 --outfile /etc/ssl/private/openldap_key.pem
    

    
    
11. /etc/ssl/openldap.info:
    
    

    organization = DTLN Company
    cn = openldap.dtln.cloud
    tls_www_server
    encryption_key
    signing_key
    expiration_days = 3650
    

    
    
12. :
    
    

    sudo certtool --generate-certificate --load-privkey /etc/ssl/private/openldap_key.pem --load-ca-certificate /etc/ssl/certs/cacert.pem --load-ca-privkey /etc/ssl/private/cakey.pem --template /etc/ssl/openldap.info --outfile /etc/ssl/certs/openldap.pem
    

    
    
13. OpenLDAP STARTTLS. certinfo.dif:
    
    

    dn: cn=config
    add: olcTLSCACertificateFile
    olcTLSCACertificateFile: /etc/ssl/certs/cacert.pem
    -
    add: olcTLSCertificateFile
    olcTLSCertificateFile: /etc/ssl/certs/openldap.pem
    -
    add: olcTLSCertificateKeyFile
    olcTLSCertificateKeyFile: /etc/ssl/private/openldap_key.pem
    

    
    
14. :
    
    

    sudo ldapmodify -Y EXTERNAL -H ldapi:/// -f certinfo.dif
    

    
    
15. :
    
    

    sudo chgrp openldap /etc/ssl/private/openldap_key.pem
    sudo chmod 0640 /etc/ssl/private/openldap_key.pem
    sudo gpasswd -a openldap ssl-cert
    sudo systemctl restart slapd.service
    

    
    
16. , /etc/ldap/ldap.conf :
    
    

    TLS_CACERT /etc/ssl/certs/cacert.pem
    

    
    
17. STARTTLS:
    
    

    ldapwhoami -H ldap://openldap.dtln.cloud -x -ZZ
    

    
    :
    
    
    
    :
    
    

LDAP-

1. , x , Kubernetes. content.ldif:
   
   

   dn: ou=People,dc=openldap,dc=dtln,dc=cloud
   objectClass: organizationalUnit
   ou: People
   dn: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud
   objectClass: person
   objectClass: inetOrgPerson
   sn: doe
   cn: jane
   mail: janedoe@openldap.dtln.cloud
   userpassword: foo_password
   
   dn: cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud
   objectClass: person
   objectClass: inetOrgPerson
   sn: doe
   cn: john
   mail: johndoe@openldap.dtln.cloud
   userpassword: bar_password
   
   # Group definitions.
   
   dn: ou=Groups,dc=openldap,dc=dtln,dc=cloud
   objectClass: organizationalUnit
   ou: Groups
   
   dn: cn=admins,ou=Groups,dc=openldap,dc=dtln,dc=cloud
   objectClass: groupOfNames
   cn: admins
   member: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud
   
   dn: cn=developers,ou=Groups,dc=openldap,dc=dtln,dc=cloud
   objectClass: groupOfNames
   cn: developers
   member: cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud
   member: cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud
   

   
   
2. कमांड के साथ वर्णित संरचना का विस्तार करें:
   
   

   ldapadd -x -D cn=admin,dc=openldap,dc=dtln,dc=cloud -W -f content.ldif
   

   
   
3. सुनिश्चित करें कि हमारे उपयोगकर्ता निर्देशिका में हैं:
   
   

   ldapwhoami -vvv -h openldap.dtln.cloud -p 389 -D cn=john,ou=People,dc=openldap,dc=dtln,dc=cloud -x -w bar_password -ZZ
   ldapwhoami -vvv -h openldap.dtln.cloud -p 389 -D cn=jane,ou=People,dc=openldap,dc=dtln,dc=cloud -x -w foo_password -ZZ
   

हम OpenID कनेक्ट के लिए समर्थन कनेक्ट करते हैं

1. हम इकाई /etc/systemd/system/kube-apiserver.service संपादित करते हैं और ExecStart अनुभाग में स्टार्टअप पैरामीटर जोड़ते हैं :
   
   

   --oidc-client-id=dex-k8s-authenticator \
   --oidc-groups-claim=groups \
   --oidc-username-claim=email \
   --oidc-issuer-url=https://dex.ash.dtln.cloud/ \
   

2. हम अपने एपीआई को फिर से शुरू करते हैं, जांचें कि वे बढ़ गए हैं:
   
   

   sudo systemctl daemon-reload
   sudo systemctl restart kube-apiserver
   sudo systemctl status kube-apiserver
   

एक मल्टी-डोमेन प्रमाणपत्र बनाएं

1. हम हेल्म का उपयोग करके प्रमाण-प्रबंधक स्थापित करते हैं: 
   
   

   helm repo add jetstack https://charts.jetstack.io
   helm repo update
   helm install cert-manager --namespace kube-system jetstack/cert-manager --version v0.13.0
   

   
   
2. हम हमारे डोमेन के लिए SAN प्रमाणपत्र के लिए अनुरोध का वर्णन कर रहे हैं।
   
   

   ---
   apiVersion: cert-manager.io/v1alpha2
   kind: ClusterIssuer
   metadata:
     name: letsencrypt-dex
   spec:
     acme:
       email: kubernetes@dataline.ru
       server: https://acme-v02.api.letsencrypt.org/directory
       privateKeySecretRef:
         name: letsencrypt-key-dex
       solvers:
       - http01:
           ingress:
             class: nginx
   ---
   apiVersion: cert-manager.io/v1alpha2
   kind: Certificate
   metadata:
     name: auth-dex
     namespace: kube-system
   spec:
     secretName: cert-auth-dex
     issuerRef:
       kind: ClusterIssuer
       name: letsencrypt-dex
     commonName: dex.ash.dtln.cloud
     dnsNames:
     - dex.ash.dtln.cloud
     - login.ash.dtln.cloud
   

   
   
3. हम कमांड निष्पादित करते हैं:
   
   

   kubectl apply -f cert.yaml
   

   
   
4. अब हम निम्नलिखित आदेशों के साथ अपने प्रमाणपत्र अनुरोध की स्थिति को देखते हैं: 
   
   

   kubectl get certificates --all-namespaces
   kubectl get challenges --all-namespaces
   

   
   
5. हम पुष्टि की प्रतीक्षा कर रहे हैं, इस प्रक्रिया में कुछ समय लग सकता है:
   
   
   

डेक्स स्थापित करें

1. डीएक्स-प्रामाणिक स्रोतों को डाउनलोड करें और निर्देशिका में जाएं:
   
   

   git clone git@github.com:mintel/dex-k8s-authenticator.git
   cd dex-k8s-authenticator/
   

   
   
2. हम डेक्स-ऑर्ट के लिए कॉन्फ़िगरेशन तैयार करते हैं, पहले से कॉपी किए गए ca.crt की सामग्री को पेस्ट करते हैं, इंडेंटेशन का निरीक्षण करना महत्वपूर्ण है:
   
   

   ---
   global:
     deployEnv: prod
   dexK8sAuthenticator:
     clusters:
       - name: 'ash.dtln.cloud'
         short_description: "k8s cluster"
         description: "Kubernetes cluster"
         issuer: https://dex.ash.dtln.cloud/
         k8s_master_uri: https://kubernetes.dtln.cloud:6443 # url or ip
         client_id: dex-k8s-authenticator
         static_context_name: false
         client_secret: acDEgDEcIg7RX0U7A9hlW2pGGraHDuMAZ4qFEKg2fUHHxr8
         redirect_uri: https://login.ash.dtln.cloud/callback
         k8s_ca_pem: |
           -----BEGIN CERTIFICATE-----
           #   ca.crt
           -----END CERTIFICATE-----
   ingress:
     enabled: true
     annotations:
       kubernetes.io/ingress.class: nginx
       kubernetes.io/tls-acme: "true"
     path: /
     hosts:
       - login.ash.dtln.cloud
     tls:
       - secretName: cert-auth-dex
         hosts:
           - login.ash.dtln.cloud
   
   

   
   
3. हम इसे कॉन्फ़िगर करने के लिए cacert.pem की सामग्री को base64 में अनुवाद करते हैं:
   
   

   cacert.pem | base64
   

   
   
4. Dex, . staticPasswords bcrypt:
   
   

   ---
   global:
     deployEnv: prod
   tls:
     certificate: |-
       -----BEGIN CERTIFICATE-----
       # ca.crt
       -----END CERTIFICATE-----
     key: |-
       -----BEGIN RSA PRIVATE KEY-----
       # ca.key
       -----END RSA PRIVATE KEY-----
   ingress:
     enabled: true
     annotations:
       kubernetes.io/ingress.class: nginx
       kubernetes.io/tls-acme: "true"
     path: /
     hosts:
       - dex.ash.dtln.cloud
     tls:
       - secretName: cert-auth-dex
         hosts:
           - dex.ash.dtln.cloud
   serviceAccount:
     create: true
     name: dex-auth-sa
   config:
     issuer: https://dex.ash.dtln.cloud/
     storage:
       type: kubernetes
       config:
         inCluster: true
     web:
       http: 0.0.0.0:5556
     frontend:
       theme: "coreos"
       issuer: "kube-dtln"
       issuerUrl: "https://login.ash.dtln.cloud"
     expiry:
       signingKeys: "6h"
       idTokens: "24h"
     logger:
       level: debug
       format: json
     oauth2:
       responseTypes: ["code", "token", "id_token"]
       skipApprovalScreen: true
   
     connectors:
     - type: ldap
       id: ldap
       name: LDAP
       config:
         insecureNoSSL: false
         insecureSkipVerify: false
         startTLS: true #   
         rootCAData: |-
           # cacert.pem  base64 
           # 
        
         host: openldap.dtln.cloud:389
         usernamePrompt: Email Address
         userSearch:
           baseDN: ou=People,dc=openldap,dc=dtln,dc=cloud
           filter: "(objectClass=person)"
           username: mail
           idAttr: DN
           emailAttr: mail
           nameAttr: cn
         groupSearch:
           baseDN: ou=Groups,dc=openldap,dc=dtln,dc=cloud
           filter: "(objectClass=groupOfNames)"
   
           userMatchers:
           - userAttr: DN
             groupAttr: member
   
           nameAttr: cn
   
     staticClients:
     - id: dex-k8s-authenticator
       name: Kubernetes Dev Cluster
       secret: 'acDEgDEcIg7RX0U7A9hlW2pGGraHDuMAZ4qFEKg2fUHHxr8'
       redirectURIs:
         - https://login.ash.dtln.cloud/callback
   
     enablePasswordDB: True
   
     staticPasswords:
       #       base64
     - email: "admin@dtln.cloud"
       # bcrypt hash of the string "password"
       hash: "$2a$10$2b2cU8CPhOTaGrs1HRQuAueS7JTT5ZHsHSzYiFPm1leZck7Mc8T4W"
       username: "admin"
       userID: "08a8684b-db88-4b73-90a9-3cd1661f5466"
   
   

   
   
5. dex dex-auth- :
   
   

   helm install dex --namespace kube-system --values dex.yaml charts/dex
   helm install dex-auth --namespace kube-system --values dex-auth.yml charts/dex-k8s-authenticator
   

   
   

kubeconfig

1. , pod’. login.ash.dtln.cloud. , mail- . 
   
   static- mail:
   
   
   
2.  Dex-auth. C kubeconfig-. :
   
   
   
3. अब क्लस्टर तक पहुँचने और एक त्रुटि प्राप्त करने का प्रयास करें। यह सही है, हमारे उपयोगकर्ता के पास अधिकार नहीं हैं, इसलिए हम RBAC की स्थापना के लिए आगे बढ़ते हैं।
   
   
   

हम RBAC प्राधिकरण को कॉन्फ़िगर करते हैं

1. उदाहरण के लिए, हम क्लस्टर-एडमिन सिस्टम भूमिका के लिए स्थैतिक उपयोगकर्ता को असाइन करते हैं , और डेवलपर्स समूह के उपयोगकर्ताओं को दृश्य भूमिका के लिए, जो सभी संसाधन देखने की अनुमति देता है। तब crb.yml फ़ाइल की सामग्री इस तरह होनी चाहिए:
   
   

   ---
   apiVersion: rbac.authorization.k8s.io/v1beta1
   kind: ClusterRoleBinding
   metadata:
     name: dex-admin
     namespace: kube-system
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: cluster-admin
   subjects:
   - kind: User
     name: "admin@dtln.cloud"
   
   ---
   apiVersion: rbac.authorization.k8s.io/v1beta1
   kind: ClusterRoleBinding
   metadata:
     name: dex-developers
     namespace: kube-system
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: view
   subjects:
   - kind: Group
     name: "developers"
   

   
   
2. मुख्य संदर्भ पर स्विच करें और निर्मित याम्ल फ़ाइल को क्लस्टर पर लागू करें:
   
   

   kubectl config set-context default
   kubectl apply -f crb.yml
   

   
   
3. हम उपलब्ध संदर्भों को देखते हैं और अपने उपयोगकर्ता पर वापस जाते हैं:
   
   

   kubectl config get-contexts
   kubectl config set-context johndoe-ash.dtln.cloud
   

• यदि समस्याएँ उत्पन्न होती हैं, तो जाँच करने के लिए पहली बात यह है कि yaml फ़ाइलों का स्वरूपण और इंडेंटेशन पर ध्यान दें। 
  
• पतों में स्लैश उदाहरणों से मेल खाना चाहिए। 
  
• pod’ Dex, Dex-auth, kube-api .