ការណែនាំអំពីការអនុញ្ញាត Kubernetes របស់កុងស៊ុល Hashicorp

នោះហើយជាត្រឹមត្រូវបន្ទាប់ពីការចេញផ្សាយ កុងស៊ុល Hashicorp 1.5.0 នៅដើមខែឧសភា ឆ្នាំ 2019 នៅក្នុងកុងស៊ុល អ្នកអាចអនុញ្ញាតកម្មវិធី និងសេវាកម្មដែលដំណើរការនៅក្នុង Kubernetes ដើមកំណើត។

នៅក្នុងមេរៀននេះ យើងនឹងបង្កើតជាជំហានៗ ភីអូ។ (Proof of concept, PoC) ដែលបង្ហាញពីមុខងារថ្មីនេះ។ អ្នកត្រូវបានគេរំពឹងថានឹងមានចំណេះដឹងជាមូលដ្ឋានអំពី Kubernetes និង Consul របស់ Hashicorp។ ខណៈពេលដែលអ្នកអាចប្រើ cloud platform ឬបរិស្ថាននៅក្នុងបរិវេណណាមួយ នៅក្នុងការបង្រៀននេះ យើងនឹងប្រើ Cloud Platform របស់ Google ។

ទិដ្ឋភាពទូទៅ

ប្រសិនបើយើងទៅ ឯកសារកុងស៊ុលលើវិធីសាស្រ្តអនុញ្ញាតរបស់ខ្លួន។យើងនឹងទទួលបានទិដ្ឋភាពទូទៅរហ័សនៃគោលបំណង និងករណីប្រើប្រាស់របស់វា ក៏ដូចជាព័ត៌មានលម្អិតបច្ចេកទេសមួយចំនួន និងទិដ្ឋភាពទូទៅនៃតក្កវិជ្ជា។ ខ្ញុំសូមផ្តល់អនុសាសន៍ឱ្យអានវាយ៉ាងហោចណាស់ម្តងមុនពេលបន្ត ព្រោះឥឡូវនេះខ្ញុំនឹងពន្យល់ និងទំពារវាទាំងអស់។

ដ្យាក្រាម 1: ទិដ្ឋភាពទូទៅជាផ្លូវការនៃវិធីសាស្ត្រអនុញ្ញាតកុងស៊ុល

តោះចូលមើល ឯកសារសម្រាប់វិធីសាស្ត្រអនុញ្ញាត Kubernetes ជាក់លាក់.

ប្រាកដណាស់ មានព័ត៌មានមានប្រយោជន៍នៅទីនោះ ប៉ុន្តែមិនមានការណែនាំអំពីរបៀបប្រើប្រាស់វាទាំងអស់នោះទេ។ ដូច្នេះ ដូច​ជា​មនុស្ស​ដែល​មាន​ចិត្ត​ល្អ​ណា​មួយ អ្នក​មើល​អ៊ីនធឺណិត​សម្រាប់​ការ​ណែនាំ។ ហើយបន្ទាប់មក... អ្នកបរាជ័យ។ វា​កើតឡើង។ តោះជួសជុលរឿងនេះ។

មុនពេលយើងបន្តទៅការបង្កើត POC របស់យើង សូមត្រលប់ទៅទិដ្ឋភាពទូទៅនៃវិធីសាស្រ្តអនុញ្ញាតរបស់កុងស៊ុល (ដ្យាក្រាម 1) ហើយកែលម្អវានៅក្នុងបរិបទរបស់ Kubernetes ។

ស្ថាបត្យកម្ម

នៅក្នុងមេរៀននេះ យើងនឹងបង្កើតម៉ាស៊ីនមេកុងស៊ុលនៅលើម៉ាស៊ីនដាច់ដោយឡែកដែលនឹងទាក់ទងជាមួយចង្កោម Kubernetes ជាមួយនឹងម៉ាស៊ីនភ្ញៀវកុងស៊ុលដែលបានដំឡើង។ បន្ទាប់មកយើងនឹងបង្កើតកម្មវិធីអត់ចេះសោះរបស់យើងនៅក្នុងផត ហើយប្រើវិធីសាស្ត្រអនុញ្ញាតដែលបានកំណត់រចនាសម្ព័ន្ធរបស់យើងដើម្បីអានពីកុងស៊ុលសោ/តម្លៃហាងរបស់យើង។

ដ្យាក្រាមខាងក្រោមរៀបរាប់លម្អិតអំពីស្ថាបត្យកម្មដែលយើងកំពុងបង្កើតនៅក្នុងមេរៀននេះ ក៏ដូចជាតក្កវិជ្ជានៅពីក្រោយវិធីសាស្ត្រអនុញ្ញាត ដែលនឹងត្រូវបានពន្យល់នៅពេលក្រោយ។

ដ្យាក្រាមទី 2៖ ទិដ្ឋភាពទូទៅនៃវិធីសាស្ត្រអនុញ្ញាត Kubernetes

កំណត់ចំណាំរហ័ស៖ ម៉ាស៊ីនមេកុងស៊ុលមិនចាំបាច់រស់នៅក្រៅចង្កោម Kubernetes ដើម្បីឱ្យវាដំណើរការនោះទេ។ ប៉ុន្តែ​បាទ គាត់​អាច​ធ្វើ​វា​តាម​វិធី​នេះ និង​បែប​នោះ។

ដូច្នេះ ដោយយកដ្យាក្រាមទិដ្ឋភាពទូទៅកុងស៊ុល (ដ្យាក្រាម 1) ហើយអនុវត្ត Kubernetes ទៅវា យើងទទួលបានដ្យាក្រាមខាងលើ (ដ្យាក្រាម 2) ហើយតក្កវិជ្ជានៅទីនេះមានដូចខាងក្រោម៖

1. ផតនីមួយៗនឹងមានគណនីសេវាកម្មភ្ជាប់ជាមួយវាដែលមាននិមិត្តសញ្ញា JWT ដែលបង្កើត និងស្គាល់ដោយ Kubernetes ។ សញ្ញាសម្ងាត់នេះក៏ត្រូវបានបញ្ចូលទៅក្នុង pod តាមលំនាំដើមផងដែរ។
2. កម្មវិធី ឬសេវាកម្មរបស់យើងនៅខាងក្នុងផត ចាប់ផ្តើមពាក្យបញ្ជាចូលទៅកាន់អតិថិជនកុងស៊ុលរបស់យើង។ សំណើចូលក៏នឹងរួមបញ្ចូលនិមិត្តសញ្ញា និងឈ្មោះរបស់យើងផងដែរ។ បង្កើតជាពិសេស វិធីសាស្រ្តអនុញ្ញាត (ប្រភេទ Kubernetes) ។ ជំហានទី 2 នេះត្រូវនឹងជំហានទី 1 នៃដ្យាក្រាមកុងស៊ុល (គ្រោងការណ៍ទី 1) ។
3. អតិថិជនកុងស៊ុលរបស់យើងនឹងបញ្ជូនសំណើនេះទៅម៉ាស៊ីនមេកុងស៊ុលរបស់យើង។
4. វេទមន្ត! នេះគឺជាកន្លែងដែលម៉ាស៊ីនមេកុងស៊ុលផ្ទៀងផ្ទាត់ភាពត្រឹមត្រូវនៃសំណើ ប្រមូលព័ត៌មានអំពីអត្តសញ្ញាណនៃសំណើ និងប្រៀបធៀបវាជាមួយនឹងច្បាប់ដែលបានកំណត់ជាមុនដែលពាក់ព័ន្ធ។ ខាងក្រោម​នេះ​ជា​ដ្យាក្រាម​មួយ​ទៀត​ដើម្បី​បង្ហាញ​ពី​រឿង​នេះ។ ជំហាននេះត្រូវនឹងជំហានទី 3, 4 និង 5 នៃដ្យាក្រាមទិដ្ឋភាពទូទៅកុងស៊ុល (ដ្យាក្រាម 1) ។
5. ម៉ាស៊ីនមេកុងស៊ុលរបស់យើងបង្កើតនិមិត្តសញ្ញាកុងស៊ុលជាមួយនឹងការអនុញ្ញាតដោយយោងទៅតាមច្បាប់នៃវិធីសាស្ត្រអនុញ្ញាតដែលបានបញ្ជាក់របស់យើង (ដែលយើងបានកំណត់) ទាក់ទងនឹងអត្តសញ្ញាណរបស់អ្នកស្នើសុំ។ បន្ទាប់មកវានឹងបញ្ជូនសញ្ញាសម្ងាត់នោះមកវិញ។ នេះត្រូវនឹងជំហានទី 6 នៃដ្យាក្រាមកុងស៊ុល (ដ្យាក្រាមទី 1) ។
6. អតិថិជនកុងស៊ុលរបស់យើងបញ្ជូនសញ្ញាសម្ងាត់ទៅកាន់កម្មវិធី ឬសេវាកម្មដែលស្នើសុំ។

កម្មវិធី ឬសេវាកម្មរបស់យើងឥឡូវនេះអាចប្រើនិមិត្តសញ្ញាកុងស៊ុលនេះ ដើម្បីទំនាក់ទំនងជាមួយទិន្នន័យកុងស៊ុលរបស់យើង ដូចដែលបានកំណត់ដោយសិទ្ធិរបស់សញ្ញាសម្ងាត់។

វេទមន្តត្រូវបានបង្ហាញ!

សម្រាប់​អ្នក​ដែល​មិន​សប្បាយ​ចិត្ត​ដោយ​គ្រាន់​តែ​ទន្សាយ​ចេញ​មួក ហើយ​ចង់​ដឹង​ថា​វា​ដំណើរ​ការ​យ៉ាង​ណា... ឲ្យ​ខ្ញុំ​ដឹង​ថា​ស៊ី​ជម្រៅ​ប៉ុណ្ណា។ រន្ធទន្សាយ"។

ដូចដែលបានរៀបរាប់ពីមុន ជំហាន "វេទមន្ត" របស់យើង (រូបភាពទី 2: ជំហានទី 4) គឺជាកន្លែងដែលម៉ាស៊ីនមេកុងស៊ុលផ្ទៀងផ្ទាត់សំណើ ប្រមូលព័ត៌មានអំពីសំណើ និងប្រៀបធៀបវាទៅនឹងច្បាប់ដែលបានកំណត់ជាមុនដែលពាក់ព័ន្ធ។ ជំហាននេះត្រូវនឹងជំហានទី 3, 4 និង 5 នៃដ្យាក្រាមទិដ្ឋភាពទូទៅកុងស៊ុល (ដ្យាក្រាម 1) ។ ខាងក្រោមនេះជាដ្យាក្រាម (ដ្យាក្រាមទី៣) គោលបំណងបង្ហាញយ៉ាងច្បាស់នូវអ្វីដែលកំពុងកើតឡើង នៅក្រោមក្រណាត់ វិធីសាស្រ្តអនុញ្ញាត Kubernetes ជាក់លាក់។

ដ្យាក្រាមទី ៣៖ វេទមន្តត្រូវបានបង្ហាញ!

1. ជាចំណុចចាប់ផ្តើម អតិថិជនកុងស៊ុលរបស់យើងបញ្ជូនសំណើចូលទៅកាន់ម៉ាស៊ីនមេកុងស៊ុលរបស់យើងជាមួយនឹងនិមិត្តសញ្ញាគណនី Kubernetes និងឈ្មោះឧទាហរណ៍ជាក់លាក់នៃវិធីសាស្ត្រអនុញ្ញាតដែលត្រូវបានបង្កើតមុននេះ។ ជំហាននេះត្រូវគ្នាទៅនឹងជំហានទី 3 នៅក្នុងការពន្យល់អំពីសៀគ្វីមុន។
2. ឥឡូវនេះម៉ាស៊ីនមេកុងស៊ុល (ឬអ្នកដឹកនាំ) ត្រូវការផ្ទៀងផ្ទាត់ភាពត្រឹមត្រូវនៃសញ្ញាសម្ងាត់ដែលទទួលបាន។ ដូច្នេះ វានឹងពិគ្រោះជាមួយក្រុម Kubernetes (តាមរយៈម៉ាស៊ីនភ្ញៀវកុងស៊ុល) ហើយដោយមានការអនុញ្ញាតសមរម្យ យើងនឹងស្វែងយល់ថាតើនិមិត្តសញ្ញានោះជារបស់ពិតប្រាកដ និងជាកម្មសិទ្ធិរបស់អ្នកណា។
3. បន្ទាប់មកសំណើដែលមានសុពលភាពត្រូវបានប្រគល់ជូនប្រធានកុងស៊ុល ហើយម៉ាស៊ីនមេកុងស៊ុលរកមើលឧទាហរណ៍វិធីសាស្ត្រអនុញ្ញាតដែលមានឈ្មោះដែលបានបញ្ជាក់ពីការស្នើសុំចូល (និងប្រភេទ Kubernetes)។
4. មេដឹកនាំកុងស៊ុលកំណត់អត្តសញ្ញាណវិធីសាស្ត្រអនុញ្ញាតដែលបានបញ្ជាក់ (ប្រសិនបើរកឃើញ) ហើយអានសំណុំនៃច្បាប់ចងដែលត្រូវបានភ្ជាប់ជាមួយវា។ បន្ទាប់មកវាអានច្បាប់ទាំងនេះ ហើយប្រៀបធៀបពួកវាទៅនឹងលក្ខណៈអត្តសញ្ញាណដែលបានផ្ទៀងផ្ទាត់។
5. តា-ដា! ចូរបន្តទៅជំហានទី 5 នៅក្នុងការពន្យល់អំពីសៀគ្វីមុន។

ដំណើរការ Consul-server នៅលើម៉ាស៊ីននិម្មិតធម្មតា។

ចាប់ពីពេលនេះតទៅ ភាគច្រើនខ្ញុំនឹងផ្តល់ការណែនាំអំពីរបៀបបង្កើត POC នេះ ជាញឹកញាប់នៅក្នុងចំណុចចំណុច ដោយគ្មានការពន្យល់ពេញលេញ។ ដូចគ្នានេះដែរ ដូចដែលបានកត់សម្គាល់ពីមុន ខ្ញុំនឹងប្រើ GCP ដើម្បីបង្កើតហេដ្ឋារចនាសម្ព័ន្ធទាំងអស់ ប៉ុន្តែអ្នកអាចបង្កើតហេដ្ឋារចនាសម្ព័ន្ធដូចគ្នានៅកន្លែងផ្សេង។

• ចាប់ផ្តើមម៉ាស៊ីននិម្មិត (ឧទាហរណ៍/ម៉ាស៊ីនមេ)។

• បង្កើតច្បាប់សម្រាប់ជញ្ជាំងភ្លើង (ក្រុមសុវត្ថិភាពក្នុង AWS)៖
• ខ្ញុំចូលចិត្តកំណត់ឈ្មោះម៉ាស៊ីនដូចគ្នាទាំងច្បាប់ និងស្លាកបណ្តាញ ក្នុងករណីនេះ "skywiz-consul-server-poc" ។
• ស្វែងរកអាសយដ្ឋាន IP របស់កុំព្យូទ័រក្នុងតំបន់របស់អ្នក ហើយបន្ថែមវាទៅក្នុងបញ្ជីអាសយដ្ឋាន IP ប្រភព ដូច្នេះយើងអាចចូលប្រើចំណុចប្រទាក់អ្នកប្រើ (UI) ។
• បើកច្រក 8500 សម្រាប់ UI ។ ចុចបង្កើត។ យើងនឹងផ្លាស់ប្តូរជញ្ជាំងភ្លើងនេះម្តងទៀតក្នុងពេលឆាប់ៗនេះ [តំណ].
• បន្ថែមច្បាប់ជញ្ជាំងភ្លើងទៅវត្ថុ។ ត្រលប់ទៅផ្ទាំងគ្រប់គ្រង VM នៅលើម៉ាស៊ីនមេកុងស៊ុល ហើយបន្ថែម "skywiz-consul-server-poc" ទៅក្នុងវាលស្លាកបណ្តាញ។ ចុចរក្សាទុក។

• ដំឡើងកុងស៊ុលនៅលើម៉ាស៊ីននិម្មិត សូមពិនិត្យមើលនៅទីនេះ។ ចងចាំថាអ្នកត្រូវការកំណែកុងស៊ុល≥ 1.5 [តំណភ្ជាប់]
• តោះបង្កើត Node Consul តែមួយ - ការកំណត់មានដូចខាងក្រោម។

groupadd --system consul
useradd -s /sbin/nologin --system -g consul consul
mkdir -p /var/lib/consul
chown -R consul:consul /var/lib/consul
chmod -R 775 /var/lib/consul
mkdir /etc/consul.d
chown -R consul:consul /etc/consul.d

• សម្រាប់ការណែនាំលម្អិតបន្ថែមអំពីការដំឡើងកុងស៊ុល និងការដំឡើងចង្កោមនៃ 3 nodes សូមមើល នៅទីនេះ.
• បង្កើតឯកសារ /etc/consul.d/agent.json ដូចខាងក្រោម [តំណ]:

### /etc/consul.d/agent.json
{
 "acl" : {
 "enabled": true,
 "default_policy": "deny",
 "enable_token_persistence": true
 }
}

• ចាប់ផ្តើមម៉ាស៊ីនមេកុងស៊ុលរបស់យើង៖

consul agent 
-server 
-ui 
-client 0.0.0.0 
-data-dir=/var/lib/consul 
-bootstrap-expect=1 
-config-dir=/etc/consul.d

• អ្នក​គួរ​តែ​ឃើញ​លទ្ធផល​ជា​ច្រើន ហើយ​បញ្ចប់​ដោយ "... អាប់ដេត​ដែល​បាន​ទប់ស្កាត់​ដោយ ACLs ។"
• ស្វែងរកអាសយដ្ឋាន IP ខាងក្រៅរបស់ម៉ាស៊ីនមេកុងស៊ុល ហើយបើកកម្មវិធីរុករកតាមអ៊ីនធឺណិតដែលមានអាសយដ្ឋាន IP នេះនៅលើច្រក 8500។ សូមប្រាកដថា UI បើក។
• ព្យាយាមបន្ថែមគូសោ/តម្លៃ។ ត្រូវតែមានកំហុស។ នេះគឺដោយសារតែយើងបានផ្ទុកម៉ាស៊ីនមេកុងស៊ុលជាមួយ ACL ហើយបានបិទច្បាប់ទាំងអស់។
• ត្រលប់ទៅសែលរបស់អ្នកនៅលើម៉ាស៊ីនមេកុងស៊ុល ហើយចាប់ផ្តើមដំណើរការក្នុងផ្ទៃខាងក្រោយ ឬវិធីផ្សេងទៀតដើម្បីឱ្យវាដំណើរការ ហើយបញ្ចូលដូចខាងក្រោម៖

consul acl bootstrap

• ស្វែងរកតម្លៃ "SecretID" ហើយត្រឡប់ទៅ UI វិញ។ នៅក្នុងផ្ទាំង ACL សូមបញ្ចូលលេខសម្គាល់សម្ងាត់នៃសញ្ញាសម្ងាត់ដែលអ្នកទើបតែចម្លង។ ចម្លង SecretID នៅកន្លែងផ្សេង យើងនឹងត្រូវការវានៅពេលក្រោយ។
• ឥឡូវនេះបន្ថែមគូសោ/តម្លៃ។ សម្រាប់ POC នេះ សូមបន្ថែមដូចខាងក្រោម៖ គន្លឹះ៖ “custom-ns/test_key” តម្លៃ៖ “ខ្ញុំនៅក្នុងថត custom-ns!”

ការបើកដំណើរការក្រុម Kubernetes សម្រាប់កម្មវិធីរបស់យើងជាមួយនឹងអតិថិជន Consul ជា Daemonset

• បង្កើតចង្កោម K8s (Kubernetes) ។ យើង​នឹង​បង្កើត​វា​នៅ​ក្នុង​តំបន់​ដូច​គ្នា​នឹង​ម៉ាស៊ីន​មេ​សម្រាប់​ការ​ចូល​ដំណើរការ​លឿន​ជាង​មុន ដូច្នេះ​ហើយ​យើង​អាច​ប្រើ​បណ្ដាញ​រង​ដូចគ្នា​ដើម្បី​ងាយស្រួល​ភ្ជាប់​ជាមួយ​អាសយដ្ឋាន IP ខាងក្នុង។ យើងនឹងហៅវាថា "skywiz-app-with-consul-client-poc" ។

• ជាការកត់សម្គាល់ នេះគឺជាការបង្រៀនដ៏ល្អដែលខ្ញុំបានឆ្លងកាត់នៅពេលរៀបចំក្រុមកុងស៊ុល POC ជាមួយកុងស៊ុល Connect ។
• យើងក៏នឹងកំពុងប្រើតារាងមួកសុវត្ថិភាព Hashicorp ជាមួយនឹងឯកសារតម្លៃបន្ថែម។
• ដំឡើង និងកំណត់រចនាសម្ព័ន្ធ Helm ។ ជំហានកំណត់រចនាសម្ព័ន្ធ៖

kubectl create serviceaccount tiller --namespace kube-system
kubectl create clusterrolebinding tiller-admin-binding 
   --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
./helm init --service-account=tiller
./helm update

• គំនូសតាងមួកសុវត្ថិភាព៖ https://www.consul.io/docs/platform/k8s/helm.html
• ប្រើឯកសារតម្លៃខាងក្រោម (ចំណាំដែលខ្ញុំបានបិទភាគច្រើន)៖

### poc-helm-consul-values.yaml
global:
 enabled: false
 image: "consul:latest"
# Expose the Consul UI through this LoadBalancer
ui:
 enabled: false
# Allow Consul to inject the Connect proxy into Kubernetes containers
connectInject:
 enabled: false
# Configure a Consul client on Kubernetes nodes. GRPC listener is required for Connect.
client:
 enabled: true
 join: ["<PRIVATE_IP_CONSUL_SERVER>"]
 extraConfig: |
{
  "acl" : {
 "enabled": true,   
 "default_policy": "deny",   
 "enable_token_persistence": true 
  }
}
# Minimal Consul configuration. Not suitable for production.
server:
 enabled: false
# Sync Kubernetes and Consul services
syncCatalog:
 enabled: false

• អនុវត្តតារាងមួកសុវត្ថិភាព៖

./helm install -f poc-helm-consul-values.yaml ./consul-helm - name skywiz-app-with-consul-client-poc

• នៅពេលដែលវាព្យាយាមដំណើរការ វានឹងត្រូវការការអនុញ្ញាតសម្រាប់ម៉ាស៊ីនមេកុងស៊ុល ដូច្នេះសូមបន្ថែមពួកវា។
• ចំណាំ "ជួរអាសយដ្ឋាន Pod" ដែលមានទីតាំងនៅលើផ្ទាំងគ្រប់គ្រងចង្កោម ហើយយោងទៅច្បាប់ជញ្ជាំងភ្លើង "skywiz-consul-server-poc" របស់យើង។
• បន្ថែមជួរអាសយដ្ឋានសម្រាប់ផតទៅក្នុងបញ្ជីអាសយដ្ឋាន IP និងច្រកបើក 8301 និង 8300។

• ចូលទៅកាន់ Consul UI ហើយបន្ទាប់ពីពីរបីនាទីអ្នកនឹងឃើញចង្កោមរបស់យើងលេចឡើងនៅក្នុងផ្ទាំងថ្នាំង។

កំណត់រចនាសម្ព័ន្ធវិធីសាស្រ្តអនុញ្ញាតដោយរួមបញ្ចូលកុងស៊ុលជាមួយ Kubernetes

• ត្រលប់ទៅ Consul server shell ហើយនាំចេញ token ដែលអ្នកបានរក្សាទុកមុននេះ៖

export CONSUL_HTTP_TOKEN=<SecretID>

• យើងនឹងត្រូវការព័ត៌មានពីក្រុម Kubernetes របស់យើងដើម្បីបង្កើតឧទាហរណ៍នៃវិធីសាស្ត្រផ្ទៀងផ្ទាត់៖
• kubernetes-host

kubectl get endpoints | grep kubernetes

• kubernetes-service-account-jwt

kubectl get sa <helm_deployment_name>-consul-client -o yaml | grep "- name:"
kubectl get secret <secret_name_from_prev_command> -o yaml | grep token:

• និមិត្តសញ្ញានេះត្រូវបានអ៊ិនកូដ base64 ដូច្នេះឌិគ្រីបវាដោយប្រើឧបករណ៍ដែលអ្នកចូលចិត្ត [តំណ]
• kubernetes-ca-cert

kubectl get secret <secret_name_from_prev_command> -o yaml | grep ca.crt:

• យកវិញ្ញាបនបត្រ "ca.crt" (បន្ទាប់ពីការឌិកូដ base64) ហើយសរសេរវាទៅក្នុងឯកសារ "ca.crt" ។
• ឥឡូវ​ធ្វើ​វិធីសាស្ត្រ​ផ្ទៀងផ្ទាត់​ភ្លាមៗ ដោយ​ជំនួស​កន្លែង​ដាក់​ជាមួយ​តម្លៃ​ដែល​អ្នក​ទើប​តែ​បាន​ទទួល។

consul acl auth-method create 
-type "kubernetes" 
-name "auth-method-skywiz-consul-poc" 
-description "This is an auth method using kubernetes for the cluster skywiz-app-with-consul-client-poc" 
-kubernetes-host "<k8s_endpoint_retrieved earlier>" 
[email protected] 
-kubernetes-service-account-
jwt="<decoded_token_retrieved_earlier>"

• បន្ទាប់មកយើងត្រូវបង្កើតច្បាប់ ហើយភ្ជាប់វាទៅនឹងតួនាទីថ្មី។ សម្រាប់ផ្នែកនេះអ្នកអាចប្រើ Consul UI ប៉ុន្តែយើងនឹងប្រើបន្ទាត់ពាក្យបញ្ជា។
• សរសេរច្បាប់

### kv-custom-ns-policy.hcl
key_prefix "custom-ns/" {
 policy = "write"
}

• អនុវត្តច្បាប់

consul acl policy create 
-name kv-custom-ns-policy 
-description "This is an example policy for kv at custom-ns/" 
-rules @kv-custom-ns-policy.hcl

• ស្វែងរកលេខសម្គាល់នៃច្បាប់ដែលអ្នកទើបតែបង្កើតចេញពីលទ្ធផល។
• បង្កើតតួនាទីជាមួយច្បាប់ថ្មី។

consul acl role create 
-name "custom-ns-role" 
-description "This is an example role for custom-ns namespace" 
-policy-id <policy_id>

• ឥឡូវនេះយើងនឹងភ្ជាប់តួនាទីថ្មីរបស់យើងជាមួយឧទាហរណ៍វិធីសាស្ត្រផ្ទៀងផ្ទាត់។ ចំណាំថាទង់ "អ្នកជ្រើសរើស" កំណត់ថាតើសំណើចូលរបស់យើងនឹងទទួលបានតួនាទីនេះឬអត់។ សូមពិនិត្យមើលនៅទីនេះសម្រាប់ជម្រើសឧបករណ៍ជ្រើសរើសផ្សេងទៀត៖ https://www.consul.io/docs/acl/auth-methods/kubernetes.html#trusted-identity-attributes

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='custom-ns-role' 
-selector='serviceaccount.namespace=="custom-ns"'

ការកំណត់រចនាសម្ព័ន្ធចុងក្រោយ

សិទ្ធិទទួលបាន

• បង្កើតសិទ្ធិចូលប្រើ។ យើងត្រូវផ្តល់ការអនុញ្ញាតឱ្យកុងស៊ុលដើម្បីផ្ទៀងផ្ទាត់ និងកំណត់អត្តសញ្ញាណនៃសញ្ញាសម្ងាត់គណនីសេវាកម្ម K8s ។
• សរសេរខាងក្រោមទៅក្នុងឯកសារ [តំណភ្ជាប់]:

###skywiz-poc-consul-server_rbac.yaml
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: review-tokens
 namespace: default
subjects:
- kind: ServiceAccount
 name: skywiz-app-with-consul-client-poc-consul-client
 namespace: default
roleRef:
 kind: ClusterRole
 name: system:auth-delegator
 apiGroup: rbac.authorization.k8s.io
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: service-account-getter
 namespace: default
rules:
- apiGroups: [""]
 resources: ["serviceaccounts"]
 verbs: ["get"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: get-service-accounts
 namespace: default
subjects:
- kind: ServiceAccount
 name: skywiz-app-with-consul-client-poc-consul-client
 namespace: default
roleRef:
 kind: ClusterRole
 name: service-account-getter
 apiGroup: rbac.authorization.k8s.io

• តោះបង្កើតសិទ្ធិចូលប្រើ

kubectl create -f skywiz-poc-consul-server_rbac.yaml

ការភ្ជាប់ទៅអតិថិជនកុងស៊ុល

• ដូចដែលបានកត់សម្គាល់ នៅទីនេះមានជម្រើសជាច្រើនសម្រាប់ភ្ជាប់ទៅ daemonset ប៉ុន្តែយើងនឹងបន្តទៅដំណោះស្រាយសាមញ្ញដូចខាងក្រោម៖
• អនុវត្តឯកសារខាងក្រោម [តំណ].

### poc-consul-client-ds-svc.yaml
apiVersion: v1
kind: Service
metadata:
 name: consul-ds-client
spec:
 selector:
   app: consul
   chart: consul-helm
   component: client
   hasDNS: "true"
   release: skywiz-app-with-consul-client-poc
 ports:
 - protocol: TCP
   port: 80
   targetPort: 8500

• បន្ទាប់មកប្រើពាក្យបញ្ជា builtin ខាងក្រោមដើម្បីបង្កើត configmap [តំណ] សូមចំណាំថាយើងកំពុងសំដៅលើឈ្មោះសេវាកម្មរបស់យើង ជំនួសវាប្រសិនបើចាំបាច់។

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
 labels:
   addonmanager.kubernetes.io/mode: EnsureExists
 name: kube-dns
 namespace: kube-system
data:
 stubDomains: |
   {"consul": ["$(kubectl get svc consul-ds-client -o jsonpath='{.spec.clusterIP}')"]}
EOF

សាកល្បងវិធីសាស្ត្រផ្ទៀងផ្ទាត់

តោះមកមើលសកម្មភាពវេទមន្ត!

• បង្កើតថតឯកសារសំខាន់ៗមួយចំនួនទៀតដោយប្រើសោកម្រិតកំពូលដូចគ្នា (ឧ. /sample_key) និងតម្លៃនៃជម្រើសរបស់អ្នក។ បង្កើតគោលនយោបាយ និងតួនាទីសមស្របសម្រាប់ផ្លូវគន្លឹះថ្មីៗ។ យើង​នឹង​ធ្វើ​ការ​ចង​នៅ​ពេល​ក្រោយ។

ការធ្វើតេស្តលំហឈ្មោះផ្ទាល់ខ្លួន៖

• តោះបង្កើតឈ្មោះផ្ទាល់ខ្លួនរបស់យើង៖

kubectl create namespace custom-ns

• តោះបង្កើតផតនៅក្នុង namespace ថ្មីរបស់យើង។ សរសេរការកំណត់រចនាសម្ព័ន្ធសម្រាប់ផត។

###poc-ubuntu-custom-ns.yaml
apiVersion: v1
kind: Pod
metadata:
 name: poc-ubuntu-custom-ns
 namespace: custom-ns
spec:
 containers:
 - name: poc-ubuntu-custom-ns
   image: ubuntu
   command: ["/bin/bash", "-ec", "sleep infinity"]
 restartPolicy: Never

• បង្កើតនៅក្រោម៖

kubectl create -f poc-ubuntu-custom-ns.yaml

• នៅពេលដែលកុងតឺន័រកំពុងដំណើរការ សូមចូលទៅទីនោះ ហើយដំឡើង curl ។

kubectl exec poc-ubuntu-custom-ns -n custom-ns -it /bin/bash
apt-get update && apt-get install curl -y

• ឥឡូវនេះយើងនឹងផ្ញើសំណើចូលទៅកាន់កុងស៊ុលដោយប្រើវិធីអនុញ្ញាតដែលយើងបានបង្កើតមុន [តំណ].
• ដើម្បីមើលនិមិត្តសញ្ញាដែលបានបញ្ចូលពីគណនីសេវាកម្មរបស់អ្នក៖

cat /run/secrets/kubernetes.io/serviceaccount/token

• សរសេរខាងក្រោមទៅឯកសារមួយនៅខាងក្នុងធុង៖

### payload.json
{
 "AuthMethod": "auth-method-test",
 "BearerToken": "<jwt_token>"
}

• ចូល!

curl 
--request POST 
--data @payload.json 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• ដើម្បីបញ្ចប់ជំហានខាងលើក្នុងមួយជួរ (ចាប់តាំងពីយើងនឹងដំណើរការការធ្វើតេស្តជាច្រើន) អ្នកអាចធ្វើដូចខាងក្រោមៈ

echo "{ 
"AuthMethod": "auth-method-skywiz-consul-poc", 
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)" 
}" 
| curl 
--request POST 
--data @- 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• ធ្វើការ! យ៉ាងហោចណាស់វាគួរតែ។ ឥឡូវនេះយក SecretID ហើយព្យាយាមចូលប្រើសោ/តម្លៃដែលយើងគួរមានសិទ្ធិចូលប្រើ។

curl 
consul-ds-client.default.svc.cluster.local/v1/kv/custom-ns/test_key --header “X-Consul-Token: <SecretID_from_prev_response>”

• អ្នកអាចឌិកូដ "តម្លៃ" base64 ហើយឃើញថាវាត្រូវគ្នានឹងតម្លៃនៅក្នុង custom-ns/test_key ក្នុង UI ។ ប្រសិនបើអ្នកបានប្រើតម្លៃដូចគ្នាខាងលើនៅក្នុងមេរៀននេះ តម្លៃដែលបានអ៊ិនកូដរបស់អ្នកនឹងជា IkknbSBpbiB0aGUgY3VzdG9tLW5zIGZvbGRlciEi ។

តេស្តគណនីសេវាកម្មអ្នកប្រើប្រាស់៖

• បង្កើតគណនី ServiceAccount ផ្ទាល់ខ្លួនដោយប្រើពាក្យបញ្ជាខាងក្រោម [តំណ].

kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
 name: custom-sa
EOF

• បង្កើតឯកសារកំណត់រចនាសម្ព័ន្ធថ្មីសម្រាប់ផត។ សូមចំណាំថាខ្ញុំបានរួមបញ្ចូលការដំឡើង curl ដើម្បីសន្សំកម្លាំងពលកម្ម :)

###poc-ubuntu-custom-sa.yaml
apiVersion: v1
kind: Pod
metadata:
 name: poc-ubuntu-custom-sa
 namespace: default
spec:
 serviceAccountName: custom-sa
 containers:
 - name: poc-ubuntu-custom-sa
   image: ubuntu
   command: ["/bin/bash","-ec"]
   args: ["apt-get update && apt-get install curl -y; sleep infinity"]
 restartPolicy: Never

• បន្ទាប់ពីនោះ ដំណើរការសំបកមួយនៅខាងក្នុងធុង។

kubectl exec -it poc-ubuntu-custom-sa /bin/bash

• ចូល!

echo "{ 
"AuthMethod": "auth-method-skywiz-consul-poc", 
"BearerToken": "$(cat /run/secrets/kubernetes.io/serviceaccount/token)" 
}" 
| curl 
--request POST 
--data @- 
consul-ds-client.default.svc.cluster.local/v1/acl/login

• ការអនុញ្ញាតត្រូវបានបដិសេធ។ អូ យើង​ភ្លេច​បន្ថែម​ច្បាប់​ថ្មី​ដែល​ភ្ជាប់​ជាមួយ​ការអនុញ្ញាត​សមរម្យ​ តោះ​ធ្វើ​វា​ឥឡូវ​នេះ។

ធ្វើម្តងទៀតនូវជំហានមុនខាងលើ៖
ក) បង្កើតគោលការណ៍ដូចគ្នាសម្រាប់បុព្វបទ “custom-sa/” ។
ខ) បង្កើតតួនាទី ហៅវាថា "តួនាទីផ្ទាល់ខ្លួន"
គ) ភ្ជាប់គោលនយោបាយទៅនឹងតួនាទី។

• បង្កើត Rule-Binding (អាចធ្វើទៅបានតែពី cli/api)។ ចំណាំអត្ថន័យផ្សេងគ្នានៃទង់អ្នកជ្រើសរើស។

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='custom-sa-role' 
-selector='serviceaccount.name=="custom-sa"'

• ចូលម្តងទៀតពីកុងតឺន័រ "poc-ubuntu-custom-sa" ។ ជោគជ័យ!
• សូមពិនិត្យមើលការចូលដំណើរការរបស់យើងទៅកាន់ផ្លូវផ្ទាល់ខ្លួន-sa/គន្លឹះ។

curl 
consul-ds-client.default.svc.cluster.local/v1/kv/custom-sa/test_key --header “X-Consul-Token: <SecretID>”

• អ្នកក៏អាចប្រាកដថាសញ្ញាសម្ងាត់នេះមិនផ្តល់សិទ្ធិចូលប្រើ kv នៅក្នុង "custom-ns/" ទេ។ គ្រាន់តែធ្វើតាមពាក្យបញ្ជាខាងលើបន្ទាប់ពីជំនួស "custom-sa" ជាមួយបុព្វបទ "custom-ns" ។
  ការអនុញ្ញាតត្រូវបានបដិសេធ។

ឧទាហរណ៍​នៃ​ការ​ត្រួត​គ្នា​:

• វាគួរឱ្យកត់សម្គាល់ថាការគូសវាសការចងច្បាប់ទាំងអស់នឹងត្រូវបានបន្ថែមទៅនិមិត្តសញ្ញាដែលមានសិទ្ធិទាំងនេះ។
• កុងតឺន័ររបស់យើង "poc-ubuntu-custom-sa" គឺស្ថិតនៅក្នុងចន្លោះឈ្មោះលំនាំដើម ដូច្នេះសូមប្រើវាសម្រាប់ការចងច្បាប់ផ្សេង។
• ធ្វើជំហានមុនម្តងទៀត៖
  ក) បង្កើតគោលការណ៍ដូចគ្នាសម្រាប់បុព្វបទគន្លឹះ "លំនាំដើម/" ។
  ខ) បង្កើតតួនាទីមួយ ដាក់ឈ្មោះវាថា "default-ns-role"
  គ) ភ្ជាប់គោលនយោបាយទៅនឹងតួនាទី។
• បង្កើត Rule-Binding (អាចធ្វើទៅបានតែពី cli/api)

consul acl binding-rule create 
-method=auth-method-skywiz-consul-poc 
-bind-type=role 
-bind-name='default-ns-role' 
-selector='serviceaccount.namespace=="default"'

• ត្រលប់ទៅកុងតឺន័រ "poc-ubuntu-custom-sa" របស់យើង ហើយព្យាយាមចូលប្រើផ្លូវ "default/" kv ។
• ការអនុញ្ញាតត្រូវបានបដិសេធ។
  អ្នកអាចមើលព័ត៌មានសម្ងាត់ដែលបានបញ្ជាក់សម្រាប់និមិត្តសញ្ញានីមួយៗនៅក្នុង UI នៅក្រោម ACL > Tokens។ ដូចដែលអ្នកអាចមើលឃើញ និមិត្តសញ្ញាបច្ចុប្បន្នរបស់យើងមាន "តួនាទីផ្ទាល់ខ្លួន" តែមួយគត់ដែលភ្ជាប់ជាមួយវា។ សញ្ញាសម្ងាត់ដែលយើងកំពុងប្រើបច្ចុប្បន្នត្រូវបានបង្កើតនៅពេលយើងចូល ហើយមានច្បាប់ចងតែមួយប៉ុណ្ណោះដែលត្រូវនឹងពេលនោះ។ យើងត្រូវចូលម្តងទៀត ហើយប្រើសញ្ញាសម្ងាត់ថ្មី។
• សូមប្រាកដថាអ្នកអាចអានបានទាំងផ្លូវ "custom-sa/" និង "default/" kv។
  ជោគជ័យ!
  នេះគឺដោយសារតែ “poc-ubuntu-custom-sa” របស់យើងត្រូវគ្នានឹងការចងច្បាប់ “custom-sa” និង “default-ns”។

សេចក្តីសន្និដ្ឋាន

សញ្ញាសម្ងាត់ TTL mgmt?

នៅពេលសរសេរនេះ មិនមានវិធីរួមបញ្ចូលគ្នាដើម្បីកំណត់ TTL សម្រាប់សញ្ញាសម្ងាត់ដែលបង្កើតដោយវិធីសាស្ត្រអនុញ្ញាតនេះទេ។ វានឹងក្លាយជាឱកាសដ៏អស្ចារ្យមួយក្នុងការផ្តល់នូវស្វ័យប្រវត្តិកម្មសុវត្ថិភាពនៃការអនុញ្ញាតកុងស៊ុល។

មានជម្រើសដើម្បីបង្កើតនិមិត្តសញ្ញាដោយដៃជាមួយ TTL៖

• https://www.consul.io/docs/acl/acl-system.html#acl-tokens
  ពេលវេលាផុតកំណត់ - ពេលវេលាដែលសញ្ញាសម្ងាត់នេះនឹងត្រូវបានដកហូត។ (ស្រេចចិត្ត បន្ថែមក្នុងកុងស៊ុល 1.5.0)
• មានសម្រាប់តែការបង្កើត/ធ្វើបច្ចុប្បន្នភាពដោយដៃប៉ុណ្ណោះ។ https://www.consul.io/api/acl/tokens.html#expirationtime

សង្ឃឹមថានៅពេលអនាគតដ៏ខ្លីនេះ យើងនឹងអាចគ្រប់គ្រងពីរបៀបដែលសញ្ញាសម្ងាត់ត្រូវបានបង្កើត (តាមវិធាន ឬវិធីសាស្ត្រអនុញ្ញាត) និងបន្ថែម TTL ។

រហូតមកដល់ពេលនោះ វាត្រូវបានស្នើឱ្យអ្នកប្រើចំណុចបញ្ចប់នៃការចាកចេញនៅក្នុងតក្កវិជ្ជារបស់អ្នក។

• https://www.consul.io/api/acl/acl.html#logout-from-auth-method
• https://www.consul.io/docs/acl/acl-auth-methods.html#overall-login-process

សូមអានអត្ថបទផ្សេងទៀតនៅលើប្លក់របស់យើងផងដែរ៖

• តើការធ្វើចំណាកស្រុកពី ClickHouse ដោយគ្មានការអនុញ្ញាតទៅ ClickHouse ជាមួយនឹងការអនុញ្ញាតនាំទៅរកអ្វី?
• របៀបដំណើរការបំពង់ច្រើនដោយប្រើ GitLab CI/CD
• ល្បិចសាមញ្ញចំនួនបីដើម្បីបង្រួមរូបភាព Docker
• Traefik ជាឧបករណ៍បញ្ជា Ingress សម្រាប់ K8S
• ការ​បម្រុង​ទុក​នៃ​គម្រោង​បណ្ដាញ​ខុស​គ្នា​មួយ​ចំនួន​ធំ
• Telegram bot សម្រាប់ Redmine ។ វិធីធ្វើឱ្យជីវិតសាមញ្ញសម្រាប់ខ្លួនអ្នក និងអ្នកដទៃ

ប្រភព: www.habr.com