🥇របៀបប្រើ kubectl កាន់តែមានប្រសិទ្ធភាព៖ ការណែនាំលំអិត

ប្រសិនបើអ្នកធ្វើការជាមួយ Kubernetes នោះ kubectl ប្រហែលជាឧបករណ៍ប្រើប្រាស់មួយដែលអ្នកប្រើច្រើនបំផុត។ ហើយនៅពេលណាដែលអ្នកចំណាយពេលច្រើនក្នុងការធ្វើការជាមួយឧបករណ៍ជាក់លាក់មួយ វាចំណាយដើម្បីសិក្សាវាឱ្យបានល្អ និងរៀនពីរបៀបប្រើប្រាស់វាឱ្យមានប្រសិទ្ធភាព។

ក្រុមការងារ Kubernetes aaS ពី Mail.ru បានបកប្រែអត្ថបទដោយ Daniel Weibel ដែលអ្នកនឹងរកឃើញគន្លឹះ និងល្បិចសម្រាប់ធ្វើការប្រកបដោយប្រសិទ្ធភាពជាមួយ kubectl។ វាក៏នឹងជួយអ្នកឱ្យយល់កាន់តែស៊ីជម្រៅអំពី Kubernetes ផងដែរ។

យោងតាមអ្នកនិពន្ធ គោលបំណងនៃអត្ថបទគឺដើម្បីធ្វើឱ្យការងារប្រចាំថ្ងៃរបស់អ្នកជាមួយ Kubernetes មិនត្រឹមតែមានប្រសិទ្ធភាពប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងរីករាយថែមទៀតផង!

សេចក្តីផ្តើម៖ តើ kubectl ជាអ្វី?

មុនពេលអ្នកអាចរៀនប្រើ kubectl ឱ្យកាន់តែមានប្រសិទ្ធភាព អ្នកត្រូវយល់ដឹងជាមូលដ្ឋានអំពីអ្វី និងរបៀបដែលវាដំណើរការ។

តាមទស្សនៈរបស់អ្នកប្រើ kubectl គឺជាផ្ទាំងបញ្ជាដែលអនុញ្ញាតឱ្យអ្នកអនុវត្តប្រតិបត្តិការ Kubernetes ។

និយាយតាមបច្ចេកទេស kubectl គឺជាម៉ាស៊ីនភ្ញៀវ Kubernetes API ។

Kubernetes API គឺជា HTTP REST API។ API នេះគឺជាចំណុចប្រទាក់អ្នកប្រើ Kubernetes ពិត ដែលតាមរយៈនោះវាត្រូវបានគ្រប់គ្រងទាំងស្រុង។ នេះមានន័យថារាល់ប្រតិបត្តិការ Kubernetes ត្រូវបានលាតត្រដាងជាចំណុចបញ្ចប់ API ហើយអាចត្រូវបានធ្វើឡើងដោយសំណើ HTTP ទៅកាន់ចំណុចបញ្ចប់នោះ។

ដូច្នេះ ការងារសំខាន់របស់ kubectl គឺធ្វើសំណើ HTTP ទៅកាន់ Kubernetes API៖

Kubernetes គឺជាប្រព័ន្ធតម្រង់ទិសធនធានទាំងស្រុង។ នេះមានន័យថាវារក្សាស្ថានភាពផ្ទៃក្នុងនៃធនធាន ហើយប្រតិបត្តិការ Kubernetes ទាំងអស់គឺជាប្រតិបត្តិការ CRUD ។

អ្នកស្ថិតក្នុងការគ្រប់គ្រងទាំងស្រុងរបស់ Kubernetes ដោយការគ្រប់គ្រងធនធានទាំងនេះ ហើយ Kubernetes ស្វែងយល់ពីអ្វីដែលត្រូវធ្វើដោយផ្អែកលើស្ថានភាពបច្ចុប្បន្ននៃធនធាន។ សម្រាប់ហេតុផលនេះ ឯកសារយោង Kubernetes API ត្រូវបានរៀបចំជាបញ្ជីនៃប្រភេទធនធានជាមួយនឹងប្រតិបត្តិការដែលពាក់ព័ន្ធរបស់ពួកគេ។

សូមក្រឡេកមើលឧទាហរណ៍មួយ។.

ចូរនិយាយថាអ្នកចង់បង្កើតធនធាន ReplicaSet ។ ដើម្បីធ្វើដូច្នេះ អ្នកពណ៌នាអំពីសំណុំចម្លងក្នុងឯកសារតាមឈ្មោះ replicaset.yamlបន្ទាប់មកដំណើរការពាក្យបញ្ជា៖

$ kubectl create -f replicaset.yaml

វានឹងបង្កើតធនធាន ReplicaSet ។ ប៉ុន្តែតើមានអ្វីកើតឡើងនៅពីក្រោយឆាក?

Kubernetes មានប្រតិបត្តិការបង្កើត ReplicaSet។ ដូចប្រតិបត្តិការផ្សេងទៀតដែរ វាត្រូវបានលាតត្រដាងជាចំណុចបញ្ចប់ API ។ ចំណុចបញ្ចប់ API ជាក់លាក់សម្រាប់ប្រតិបត្តិការនេះមើលទៅដូចនេះ៖

POST /apis/apps/v1/namespaces/{namespace}/replicasets

ចំណុចបញ្ចប់ API សម្រាប់ប្រតិបត្តិការ Kubernetes ទាំងអស់អាចរកបាននៅ ឯកសារយោង API (រួមទាំង ចំណុចបញ្ចប់ខាងលើ) ដើម្បីធ្វើការស្នើសុំពិតប្រាកដទៅកាន់ចំណុចបញ្ចប់ អ្នកត្រូវតែបន្ថែម URL របស់ម៉ាស៊ីនមេ API ទៅកាន់ផ្លូវបញ្ចប់ដែលត្រូវបានរាយក្នុងឯកសារយោង API ។

ដូច្នេះ នៅពេលអ្នកប្រតិបត្តិពាក្យបញ្ជាខាងលើ kubectl ផ្ញើសំណើ HTTP POST ទៅកាន់ចំណុចបញ្ចប់ API ខាងលើ។ និយមន័យ ReplicaSet ដែលអ្នកបានផ្តល់នៅក្នុងឯកសារ replicaset.yamlត្រូវបានផ្ញើនៅក្នុងតួនៃសំណើ។

នេះជារបៀបដែល kubectl ដំណើរការសម្រាប់ពាក្យបញ្ជាទាំងអស់ដែលមានអន្តរកម្មជាមួយចង្កោម Kubernetes ។ ក្នុងករណីទាំងអស់នេះ kubectl គ្រាន់តែធ្វើសំណើ HTTP ទៅកាន់ចំណុចបញ្ចប់ Kubernetes API ដែលសមរម្យ។

សូមចំណាំថាអ្នកអាចគ្រប់គ្រង Kubernetes យ៉ាងពេញលេញដោយប្រើឧបករណ៍ប្រើប្រាស់ដូចជា curlដោយការផ្ញើសំណើ HTTP ដោយដៃទៅ Kubernetes API ។ Kubectl ធ្វើឱ្យមានភាពងាយស្រួលក្នុងការប្រើប្រាស់ Kubernetes API ។

នេះគឺជាមូលដ្ឋាននៃអ្វីដែល kubectl និងរបៀបដែលវាដំណើរការ។ ប៉ុន្តែមានអ្វីផ្សេងទៀតអំពី Kubernetes API ដែលអ្នកប្រើប្រាស់ kubectl គ្រប់រូបគួរដឹង។ សូមក្រឡេកមើលពិភពខាងក្នុងរបស់ Kubernetes បន្តិច។

ពិភពខាងក្នុងនៃ Kubernetes

Kubernetes មានសំណុំនៃសមាសភាគឯករាជ្យដែលដំណើរការជាដំណើរការដាច់ដោយឡែកនៅលើថ្នាំងចង្កោម។ សមាសធាតុខ្លះដំណើរការលើថ្នាំងមេ ខ្លះទៀតនៅលើថ្នាំងកម្មករ សមាសធាតុនីមួយៗអនុវត្តភារកិច្ចជាក់លាក់របស់ខ្លួន។

នេះគឺជាសមាសធាតុសំខាន់បំផុតនៅលើថ្នាំងសំខាន់ៗ៖

ឃ្លាំង - រក្សាទុកនិយមន័យធនធាន (ជាធម្មតាវាជា ល។).
ម៉ាស៊ីនមេ API - ផ្តល់ API និងគ្រប់គ្រងការផ្ទុក។
អ្នកគ្រប់គ្រងឧបករណ៍បញ្ជា - ធានាថាស្ថានភាពធនធានអនុលោមតាមលក្ខណៈជាក់លាក់។
អ្នករៀបចំកាលវិភាគ - កំណត់កាលវិភាគ pods នៅលើថ្នាំងកម្មករ។

ហើយនេះគឺជាសមាសធាតុសំខាន់បំផុតមួយនៅលើថ្នាំងកម្មករ៖

គូបេឡេត - គ្រប់គ្រងការបើកដំណើរការកុងតឺន័រនៅលើថ្នាំងដែលកំពុងដំណើរការ។

ដើម្បីយល់ពីរបៀបដែលសមាសធាតុទាំងនេះដំណើរការជាមួយគ្នា សូមក្រឡេកមើលឧទាហរណ៍មួយ។

ឧបមាថាអ្នកទើបតែបានបញ្ចប់ kubectl create -f replicaset.yamlបន្ទាប់ពីនោះ kubectl បានធ្វើសំណើ HTTP POST ទៅ ReplicaSet API endpoint (ឆ្លងកាត់ការកំណត់ធនធាន ReplicaSet) ។

តើមានអ្វីកើតឡើងនៅក្នុងចង្កោម?

បន្ទាប់ពីធ្វើ kubectl create -f replicaset.yaml ម៉ាស៊ីនមេ API រក្សាទុកនិយមន័យធនធាន ReplicaSet របស់អ្នកនៅក្នុងការផ្ទុក៖
បន្ទាប់មក ឧបករណ៍បញ្ជា ReplicaSet ត្រូវបានបើកដំណើរការនៅក្នុងកម្មវិធីគ្រប់គ្រងឧបករណ៍បញ្ជា ដែលគ្រប់គ្រងការបង្កើត ការកែប្រែ និងការលុបធនធាន ReplicaSet៖
ឧបករណ៍បញ្ជា ReplicaSet បង្កើតនិយមន័យ pod សម្រាប់ការចម្លង ReplicaSet នីមួយៗ (យោងតាមគំរូ pod ក្នុងនិយមន័យ ReplicaSet) ហើយរក្សាទុកពួកវានៅក្នុងកន្លែងផ្ទុក៖
កម្មវិធីកំណត់ពេលត្រូវបានបើកដំណើរការ ដោយតាមដានផតថលដែលមិនទាន់ត្រូវបានចាត់ចែងទៅថ្នាំងកម្មករណាមួយ៖
អ្នកកំណត់ពេលជ្រើសរើសថ្នាំងកម្មករដែលសមរម្យសម្រាប់ផតនីមួយៗ ហើយបន្ថែមព័ត៌មាននេះទៅនិយមន័យផតនៅក្នុងហាង៖
នៅលើថ្នាំងកម្មករដែលផតត្រូវបានចាត់តាំង Kubelet ត្រូវបានបើកដំណើរការ វាតាមដានផតថលដែលបានកំណត់ទៅថ្នាំងនេះ៖
Kubelet អាននិយមន័យ pod ពីការផ្ទុក និងណែនាំរយៈពេលដំណើរការកុងតឺន័រ ដូចជា Docker ដើម្បីបើកដំណើរការកុងតឺន័រនៅលើថ្នាំង៖

ខាងក្រោមគឺជាកំណែអត្ថបទនៃការពណ៌នានេះ។

សំណើ API ទៅកាន់ចំណុចបញ្ចប់នៃការបង្កើត ReplicaSet ត្រូវបានដំណើរការដោយម៉ាស៊ីនមេ API ។ ម៉ាស៊ីនមេ API ផ្ទៀងផ្ទាត់សំណើ និងរក្សាទុកនិយមន័យធនធាន ReplicaSet នៅក្នុងការផ្ទុក។

ព្រឹត្តិការណ៍នេះចាប់ផ្តើមឧបករណ៍បញ្ជា ReplicaSet ដែលជាដំណើរការរងរបស់កម្មវិធីគ្រប់គ្រងឧបករណ៍បញ្ជា។ ឧបករណ៍បញ្ជា ReplicaSet ត្រួតពិនិត្យការបង្កើត ធ្វើបច្ចុប្បន្នភាព និងការលុបធនធាន ReplicaSet នៅក្នុងហាង ហើយទទួលបានការជូនដំណឹងអំពីព្រឹត្តិការណ៍នៅពេលដែលវាកើតឡើង។

ការងាររបស់ ReplicaSet controller គឺដើម្បីធានាថាចំនួន ReplicaSet pods ដែលត្រូវការ។ ក្នុងឧទាហរណ៍របស់យើង មិនទាន់មាន pods នៅឡើយទេ ដូច្នេះឧបករណ៍បញ្ជា ReplicaSet បង្កើតនិយមន័យ pod ទាំងនេះ (យោងតាមគំរូ pods ក្នុងនិយមន័យ ReplicaSet) ហើយរក្សាទុកវានៅក្នុងកន្លែងផ្ទុក។

ការបង្កើតផតថលថ្មីត្រូវបានបង្កឡើងដោយកម្មវិធីកំណត់ពេលដែលតាមដាននិយមន័យផតដែលមិនទាន់កំណត់ពេលសម្រាប់ថ្នាំងកម្មករ។ កម្មវិធីកំណត់ពេលជ្រើសរើសថ្នាំងកម្មករដែលសមរម្យសម្រាប់ផតនីមួយៗ ហើយធ្វើបច្ចុប្បន្នភាពនិយមន័យផតនៅក្នុងឃ្លាំង។

ចំណាំថារហូតមកដល់ចំណុចនេះ គ្មានកូដបន្ទុកការងារណាមួយកំពុងដំណើរការនៅកន្លែងណាមួយនៅក្នុងចង្កោមនោះទេ។ អ្វីគ្រប់យ៉ាងដែលបានធ្វើមកទល់ពេលនេះ។ - នេះគឺជាការបង្កើត និងធ្វើបច្ចុប្បន្នភាពធនធាននៅក្នុងឃ្លាំងនៅលើថ្នាំងមេ។

ព្រឹត្តិការណ៍ចុងក្រោយបង្កឱ្យមាន Kubelets ដែលត្រួតពិនិត្យ pods កំណត់ពេលសម្រាប់ថ្នាំងកម្មកររបស់ពួកគេ។ Kubelet នៃ node កម្មករដែលកម្មវិធី ReplicaSet pods របស់អ្នកត្រូវបានដំឡើងត្រូវតែណែនាំកុងតឺន័រដំណើរការដូចជា Docker ដើម្បីទាញយករូបភាពកុងតឺន័រដែលត្រូវការ ហើយដំណើរការវា។

នៅពេលនេះ កម្មវិធី ReplicaSet របស់អ្នកកំពុងដំណើរការហើយ!

តួនាទីរបស់ Kubernetes API

ដូចដែលអ្នកបានឃើញនៅក្នុងឧទាហរណ៍មុន សមាសធាតុ Kubernetes (លើកលែងតែម៉ាស៊ីនមេ API និងការផ្ទុក) មើលការផ្លាស់ប្តូរធនធាននៅក្នុងកន្លែងផ្ទុក និងផ្លាស់ប្តូរព័ត៌មានអំពីធនធាននៅក្នុងការផ្ទុក។

ជាការពិតណាស់ សមាសធាតុទាំងនេះមិនមានអន្តរកម្មជាមួយឧបករណ៍ផ្ទុកដោយផ្ទាល់ទេ ប៉ុន្តែតាមរយៈ Kubernetes API ប៉ុណ្ណោះ។

សូមពិចារណាឧទាហរណ៍ខាងក្រោម:

ឧបករណ៍បញ្ជា ReplicaSet ប្រើចំណុចបញ្ចប់ API បញ្ជីកម្មវិធីចម្លង ជាមួយប៉ារ៉ាម៉ែត្រ watch ដើម្បីតាមដានការផ្លាស់ប្តូរធនធាន ReplicaSet ។
ឧបករណ៍បញ្ជា ReplicaSet ប្រើចំណុចបញ្ចប់ API បង្កើត Pod (បង្កើតផត) ដើម្បីបង្កើតផត។
កម្មវិធីកំណត់ពេលប្រើចំណុចបញ្ចប់ API បន្ទះបំណះ (កែសម្រួលផត) ដើម្បីធ្វើបច្ចុប្បន្នភាពផតថលជាមួយនឹងព័ត៌មានអំពីថ្នាំងកម្មករដែលបានជ្រើសរើស។

ដូចដែលអ្នកអាចឃើញ នេះគឺជា API ដូចគ្នាដែល kubectl ចូលប្រើ។ ការប្រើប្រាស់ API ដូចគ្នាសម្រាប់សមាសភាគខាងក្នុង និងអ្នកប្រើប្រាស់ខាងក្រៅ គឺជាគំនិតជាមូលដ្ឋាននៅក្នុងការរចនា Kubernetes ។

ឥឡូវនេះយើងអាចសង្ខេបពីរបៀបដែល Kubernetes ដំណើរការ៖

កន្លែងផ្ទុកផ្ទុកទិន្នន័យ ពោលគឺធនធាន Kubernetes ។
ម៉ាស៊ីនមេ API ផ្តល់ចំណុចប្រទាក់ទៅនឹងកន្លែងផ្ទុកក្នុងទម្រង់នៃ Kubernetes API ។
សមាសធាតុ Kubernetes ផ្សេងទៀតទាំងអស់ និងអ្នកប្រើប្រាស់អាន សង្កេត និងរៀបចំស្ថានភាព Kubernetes (ធនធាន) តាមរយៈ API ។

ការដឹងពីគោលគំនិតទាំងនេះនឹងជួយអ្នកឱ្យយល់ពី kubectl កាន់តែប្រសើរ និងទទួលបានអត្ថប្រយោជន៍ច្រើនបំផុតពីវា។

ឥឡូវនេះ សូមក្រឡេកមើលគន្លឹះ និងល្បិចជាក់លាក់មួយចំនួន ដែលនឹងជួយបង្កើនផលិតភាពរបស់អ្នកជាមួយ kubectl។

1. បង្កើនល្បឿនការបញ្ចូលដោយប្រើការបំពេញពាក្យបញ្ជា

បច្ចេកទេសមួយក្នុងចំនោមមានប្រយោជន៍បំផុត ប៉ុន្តែជារឿយៗត្រូវបានគេមើលរំលង បច្ចេកទេសសម្រាប់កែលម្អការអនុវត្តជាមួយ kubectl គឺការបំពេញពាក្យបញ្ជា។

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

សូមមើលពីរបៀបដែលការបំពេញពាក្យបញ្ជា kubectl ដំណើរការ៖

ការបញ្ចប់ពាក្យបញ្ជាដំណើរការសម្រាប់សែល Bash និង Zsh ។

មគ្គុទ្ទេសក៍ផ្លូវការ មានការណែនាំលម្អិតសម្រាប់ការដំឡើងការបំពេញដោយស្វ័យប្រវត្តិ ប៉ុន្តែខាងក្រោមយើងនឹងផ្តល់នូវការដកស្រង់ខ្លីមួយ។

របៀបដែលការបំពេញពាក្យបញ្ជាដំណើរការ

ការបំពេញពាក្យបញ្ជាគឺជាមុខងារសែលដែលដំណើរការដោយប្រើស្គ្រីបបំពេញ។ ស្គ្រីបផ្នែកបន្ថែមគឺជាស្គ្រីបសែលដែលកំណត់ឥរិយាបថនៃផ្នែកបន្ថែមសម្រាប់ពាក្យបញ្ជាជាក់លាក់មួយ។

Kubectl បង្កើត និងបញ្ចេញស្គ្រីបផ្នែកបន្ថែមដោយស្វ័យប្រវត្តិសម្រាប់ Bash និង Zsh ដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ kubectl completion bash

ឬ:

$ kubectl completion zsh

តាមទ្រឹស្ដី វាគ្រប់គ្រាន់ដើម្បីភ្ជាប់លទ្ធផលនៃពាក្យបញ្ជាទាំងនេះទៅសែលពាក្យបញ្ជាដែលសមស្រប ដូច្នេះ kubectl អាចបំពេញពាក្យបញ្ជាបាន។

នៅក្នុងការអនុវត្ត វិធីសាស្ត្រតភ្ជាប់គឺខុសគ្នាសម្រាប់ Bash (រួមទាំងភាពខុសគ្នារវាង Linux និង MacOS) និង Zsh ។ ខាងក្រោមនេះយើងនឹងពិនិត្យមើលជម្រើសទាំងអស់នេះ។

Bash នៅលើលីនុច

ស្គ្រីបបញ្ចប់ Bash អាស្រ័យលើកញ្ចប់ការបំពេញ bash ដូច្នេះអ្នកត្រូវដំឡើងវាជាមុនសិន៖

$ sudo apt-get install bash-completion

ឬ:

$ yum install bash-completion

អ្នកអាចសាកល្បងថាកញ្ចប់ត្រូវបានដំឡើងដោយជោគជ័យដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ type _init_completion

ប្រសិនបើវាចេញកូដមុខងារសែល នោះការបំពេញ bash ត្រូវបានដំឡើងយ៉ាងត្រឹមត្រូវ។ ប្រសិនបើពាក្យបញ្ជាផ្តល់កំហុស "រកមិនឃើញ" អ្នកត្រូវបន្ថែមបន្ទាត់ខាងក្រោមទៅឯកសាររបស់អ្នក។ ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

តើវាចាំបាច់ដើម្បីបន្ថែមបន្ទាត់នេះទៅឯកសារ ~ / .bashrc ឬមិនអាស្រ័យលើកម្មវិធីគ្រប់គ្រងកញ្ចប់ដែលអ្នកធ្លាប់ដំឡើង bash-completion ។ នេះគឺចាំបាច់សម្រាប់ APT ប៉ុន្តែមិនមែនសម្រាប់ YUM ទេ។

បន្ទាប់ពីដំឡើង bash-completion អ្នកត្រូវកំណត់រចនាសម្ព័ន្ធអ្វីគ្រប់យ៉ាងដើម្បីឱ្យស្គ្រីបបញ្ចប់ kubectl ត្រូវបានបើកនៅក្នុងវគ្គសែលទាំងអស់។

វិធីមួយដើម្បីធ្វើដូច្នេះគឺត្រូវបន្ថែមបន្ទាត់ខាងក្រោមទៅឯកសារ ~ / .bashrc:

source <(kubectl completion bash)

វិធីមួយទៀតគឺត្រូវបន្ថែមស្គ្រីបផ្នែកបន្ថែម kubectl ទៅថត /etc/bash_completion.d (បង្កើតវាប្រសិនបើវាមិនមាន)៖

$ kubectl completion bash >/etc/bash_completion.d/kubectl

ស្គ្រីបបន្ថែមទាំងអស់នៅក្នុងកាតាឡុក /etc/bash_completion.d ត្រូវបានរួមបញ្ចូលដោយស្វ័យប្រវត្តិនៅក្នុងការបំពេញ bash ។

ជម្រើសទាំងពីរអាចអនុវត្តបានដូចគ្នា។

បន្ទាប់ពីចាប់ផ្តើមសែលឡើងវិញ ការបញ្ចប់ពាក្យបញ្ជា kubectl នឹងដំណើរការ។

Bash នៅលើ MacOS

នៅលើ MacOS ការដំឡើងមានភាពស្មុគស្មាញបន្តិច។ ការពិតគឺថាតាមលំនាំដើម MacOS ប្រើ Bash កំណែ 3.2 ហើយស្គ្រីបការបំពេញស្វ័យប្រវត្តិ kubectl ទាមទារកំណែ Bash យ៉ាងហោចណាស់ 4.1 ហើយមិនដំណើរការក្នុង Bash 3.2 ទេ។

មានបញ្ហាអាជ្ញាប័ណ្ណដែលទាក់ទងនឹងការប្រើកំណែហួសសម័យរបស់ Bash នៅលើ MacOS។ Bash កំណែ 4 មានអាជ្ញាប័ណ្ណក្រោម GPLv3 ដែលមិនត្រូវបានគាំទ្រដោយ Apple ។

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

មុនពេលបន្ត ត្រូវប្រាកដថាអ្នកកំពុងប្រើកំណែថ្មីរបស់ Bash (ពិនិត្យមើលលទ្ធផល bash --version).

ស្គ្រីបបញ្ចប់ Bash ប្រែប្រួលតាមគម្រោង ការបញ្ចប់ bashដូច្នេះអ្នកត្រូវដំឡើងវាជាមុនសិន។

អ្នកអាចដំឡើង bash-completion ដោយប្រើ Homebrew:

$ brew install bash-completion@2

វាគឺជាការ @2 តំណាងឱ្យ bash-completion កំណែ 2. ការបំពេញស្វ័យប្រវត្តិ kubectl ទាមទារ bash-completion v2 ហើយ bash-completion v2 ទាមទារអប្បបរមានៃកំណែ Bash 4.1 ។

លទ្ធផលពាក្យបញ្ជា brew-install មានផ្នែក Caveats ដែលបញ្ជាក់ពីអ្វីដែលត្រូវបន្ថែមទៅឯកសារ ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

ទោះយ៉ាងណាក៏ដោយ ខ្ញុំសូមណែនាំឱ្យបន្ថែមបន្ទាត់ទាំងនេះមិនឱ្យ ~/.bash_profileនិងក្នុង។ ~/.bashrc. ក្នុងករណីនេះ ការបំពេញដោយស្វ័យប្រវត្តិនឹងមានមិនត្រឹមតែនៅក្នុងមេប៉ុណ្ណោះទេ ប៉ុន្តែក៏មាននៅក្នុងសែលពាក្យបញ្ជារបស់កុមារផងដែរ។

បន្ទាប់ពីចាប់ផ្តើមសែលពាក្យបញ្ជាឡើងវិញ អ្នកអាចផ្ទៀងផ្ទាត់ការដំឡើងត្រឹមត្រូវដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ type _init_completion

ប្រសិនបើអ្នកឃើញមុខងារសែលនៅក្នុងលទ្ធផល នោះអ្វីៗទាំងអស់ត្រូវបានកំណត់រចនាសម្ព័ន្ធត្រឹមត្រូវ។

ឥឡូវនេះយើងត្រូវធានាថាការបំពេញដោយស្វ័យប្រវត្តិ kubectl ត្រូវបានបើកនៅក្នុងវគ្គទាំងអស់។

វិធីមួយគឺត្រូវបន្ថែមបន្ទាត់ខាងក្រោមទៅរបស់អ្នក។ ~/.bashrc:

source <(kubectl completion bash)

វិធីទីពីរគឺត្រូវបន្ថែមស្គ្រីបបំពេញស្វ័យប្រវត្តិទៅថតឯកសារ /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

វិធីសាស្រ្តនេះនឹងដំណើរការបានលុះត្រាតែអ្នកដំឡើង bash-completion ដោយប្រើ Homebrew ។ ក្នុងករណីនេះ bash-completion ផ្ទុកស្គ្រីបទាំងអស់ពីថតនេះ។

ប្រសិនបើអ្នកបានដំឡើង kubectl ដោយប្រើ Homebrewបន្ទាប់មកមិនចាំបាច់អនុវត្តជំហានមុនទេ ដោយសារស្គ្រីបបំពេញស្វ័យប្រវត្តិនឹងត្រូវបានដាក់ដោយស្វ័យប្រវត្តិនៅក្នុងថត /usr/local/etc/bash_completion.d កំឡុងពេលដំឡើង។ ក្នុងករណីនេះ ការបំពេញស្វ័យប្រវត្តិ kubectl នឹងចាប់ផ្តើមដំណើរការភ្លាមៗនៅពេលដែលអ្នកដំឡើង bash-completion។

ជាលទ្ធផលជម្រើសទាំងអស់នេះគឺសមមូល។

Zsh

ស្គ្រីបបំពេញដោយស្វ័យប្រវត្តិសម្រាប់ Zsh មិនតម្រូវឱ្យមានភាពអាស្រ័យណាមួយទេ។ អ្វីដែលអ្នកត្រូវធ្វើគឺបើកពួកវានៅពេលអ្នកផ្ទុកសែលពាក្យបញ្ជា។

អ្នកអាចធ្វើវាបានដោយបន្ថែមបន្ទាត់ទៅកាន់របស់អ្នក។ ~/.zshrc ឯកសារ៖

source <(kubectl completion zsh)

ប្រសិនបើអ្នកទទួលបានកំហុស not found: compdef បន្ទាប់ពីចាប់ផ្តើមសែលរបស់អ្នកឡើងវិញ អ្នកត្រូវបើកមុខងារដែលភ្ជាប់មកជាមួយ compdef. អ្នកអាចបើកវាដោយបន្ថែមវាទៅដើមឯកសាររបស់អ្នក។ ~/.zshrc ដូចខាងក្រោម:

autoload -Uz compinit
compinit

2. មើលយ៉ាងរហ័សនូវលក្ខណៈជាក់លាក់នៃធនធាន

នៅពេលអ្នកបង្កើតនិយមន័យធនធាន YAML អ្នកត្រូវដឹងពីវាល និងអត្ថន័យរបស់វាសម្រាប់ធនធានទាំងនោះ។ កន្លែងមួយដើម្បីស្វែងរកព័ត៌មាននេះគឺនៅក្នុងឯកសារយោង API ដែលមានលក្ខណៈពិសេសពេញលេញសម្រាប់ធនធានទាំងអស់។

ទោះយ៉ាងណាក៏ដោយ ការប្តូរទៅកម្មវិធីរុករកតាមអ៊ីនធឺណិតរាល់ពេលដែលអ្នកត្រូវការស្វែងរកអ្វីមួយគឺមានការរអាក់រអួល។ ដូច្នេះ kubectl ផ្តល់ពាក្យបញ្ជា kubectl explainដែលបង្ហាញពីលក្ខណៈជាក់លាក់នៃធនធានទាំងអស់នៅក្នុងស្ថានីយរបស់អ្នក។

ទម្រង់ពាក្យបញ្ជាមានដូចខាងក្រោម៖

$ kubectl explain resource[.field]...

ពាក្យបញ្ជានឹងបញ្ចេញការបញ្ជាក់នៃធនធាន ឬវាលដែលបានស្នើ។ ព័ត៌មានដែលបង្ហាញគឺដូចគ្នាបេះបិទទៅនឹងអ្វីដែលមាននៅក្នុងសៀវភៅណែនាំ API ។

តាមលំនាំដើម kubectl explain បង្ហាញតែកម្រិតទីមួយនៃការដាក់សំបុកនៃវាល។

មើលថាតើវាមើលទៅដូចអ្វី អាចនៅទីនេះ។.

អ្នកអាចបង្ហាញមែកធាងទាំងមូល ប្រសិនបើអ្នកបន្ថែមជម្រើស --recursive:

$ kubectl explain deployment.spec --recursive

ប្រសិនបើអ្នកមិនដឹងច្បាស់ថាធនធានណាដែលត្រូវការ អ្នកអាចបង្ហាញពួកវាទាំងអស់ដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ kubectl api-resources

ពាក្យបញ្ជានេះបង្ហាញឈ្មោះធនធានក្នុងទម្រង់ពហុវចនៈ ឧ. deployments ជំនួសឱ្យ។ deployment. ឧទាហរណ៍វាបង្ហាញឈ្មោះខ្លី deployសម្រាប់ធនធានទាំងនោះដែលមានវា។ កុំបារម្ភអំពីភាពខុសគ្នាទាំងនេះ។ ជម្រើសដាក់ឈ្មោះទាំងអស់នេះគឺសមមូលសម្រាប់ kubectl។ នោះគឺអ្នកអាចប្រើណាមួយនៃពួកវាសម្រាប់ kubectl explain.

ពាក្យបញ្ជាខាងក្រោមទាំងអស់គឺសមមូល៖

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. ប្រើទម្រង់លទ្ធផលជួរឈរផ្ទាល់ខ្លួន

ទម្រង់លទ្ធផលពាក្យបញ្ជាលំនាំដើម kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

ទម្រង់នេះងាយស្រួល ប៉ុន្តែវាមានព័ត៌មានចំនួនកំណត់។ បើប្រៀបធៀបទៅនឹងទម្រង់និយមន័យធនធានពេញលេញ មានតែវាលមួយចំនួនប៉ុណ្ណោះដែលត្រូវបានបង្ហាញនៅទីនេះ។

ក្នុងករណីនេះ អ្នកអាចប្រើទម្រង់លទ្ធផលជួរឈរផ្ទាល់ខ្លួន។ វាអនុញ្ញាតឱ្យអ្នកកំណត់ថាតើទិន្នន័យណាដែលត្រូវបញ្ចេញ។ អ្នកអាចបង្ហាញវាលធនធានណាមួយជាជួរឈរដាច់ដោយឡែក។

ការប្រើប្រាស់ទម្រង់ផ្ទាល់ខ្លួនត្រូវបានកំណត់ដោយប្រើជម្រើស៖

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

អ្នកអាចកំណត់ជួរឈរលទ្ធផលនីមួយៗជាគូ <header>:<jsonpath>ដែលជាកន្លែង <header> គឺជាឈ្មោះជួរឈរ និង <jsonpath> - កន្សោមដែលកំណត់វាលធនធាន។

តោះមើលឧទាហរណ៍សាមញ្ញមួយ៖

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

លទ្ធផលមានជួរឈរមួយដែលមានឈ្មោះរបស់ផត។

កន្សោមជម្រើស ជ្រើសរើសឈ្មោះផត ពីវាល metadata.name. នេះគឺដោយសារតែឈ្មោះរបស់ pod ត្រូវបានកំណត់នៅក្នុងវាលឈ្មោះកូន metadata នៅក្នុងការពិពណ៌នាធនធាននៃផតថល។ ព័ត៌មានលម្អិតបន្ថែមអាចរកបាននៅក្នុង ការណែនាំ API ឬវាយពាក្យបញ្ជា kubectl explain pod.metadata.name.

ឥឡូវសូមនិយាយថាអ្នកចង់បន្ថែមជួរឈរបន្ថែមមួយទៅលទ្ធផល ឧទាហរណ៍បង្ហាញថ្នាំងនីមួយៗកំពុងដំណើរការ។ ដើម្បីធ្វើដូច្នេះ អ្នកគ្រាន់តែអាចបន្ថែមការបញ្ជាក់ជួរឈរសមស្របទៅជម្រើសជួរឈរផ្ទាល់ខ្លួន៖

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

កន្សោមជ្រើសរើសឈ្មោះថ្នាំងពី spec.nodeName - នៅពេលដែលផតត្រូវបានចាត់តាំងទៅថ្នាំង ឈ្មោះរបស់វាត្រូវបានសរសេរនៅក្នុងវាល spec.nodeName ការបញ្ជាក់ធនធាន pod ។ ព័ត៌មានលម្អិតបន្ថែមអាចត្រូវបានរកឃើញនៅក្នុងលទ្ធផល kubectl explain pod.spec.nodeName.

សូមចំណាំថាវាលធនធាន Kubernetes គឺប្រកាន់អក្សរតូចធំ។

អ្នកអាចមើលវាលធនធានណាមួយជាជួរឈរ។ គ្រាន់តែពិនិត្យមើលការបញ្ជាក់ធនធានហើយសាកល្បងវាជាមួយនឹងវាលណាមួយដែលអ្នកចូលចិត្ត។

ប៉ុន្តែជាដំបូង សូមពិនិត្យមើលឱ្យកាន់តែដិតដល់នូវកន្សោមជ្រើសរើសវាល។

កន្សោម JSONPath

កន្សោមសម្រាប់ការជ្រើសរើសវាលធនធានគឺផ្អែកលើ JSONPath.

JSONPath គឺជាភាសាសម្រាប់ទាញយកទិន្នន័យពីឯកសារ JSON ។ ការជ្រើសរើសវាលតែមួយគឺជាករណីប្រើប្រាស់ដ៏សាមញ្ញបំផុតសម្រាប់ JSONPath ។ គាត់មានច្រើន។ លទ្ធភាពកាន់តែច្រើនរួមទាំងឧបករណ៍ជ្រើសរើស តម្រងជាដើម។

Kubectl ពន្យល់គាំទ្រចំនួនកំណត់នៃលក្ខណៈពិសេស JSONPath ។ លទ្ធភាព និងឧទាហរណ៍នៃការប្រើប្រាស់របស់ពួកគេត្រូវបានពិពណ៌នាដូចខាងក្រោម៖

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

ប្រតិបត្តិករ [] មានសារៈសំខាន់ជាពិសេស។ វាលធនធាន Kubernetes ជាច្រើនគឺជាបញ្ជី ហើយប្រតិបត្តិករនេះអនុញ្ញាតឱ្យអ្នកជ្រើសរើសសមាជិកនៃបញ្ជីទាំងនោះ។ វាត្រូវបានគេប្រើជាញឹកញាប់ជាមួយតួអក្សរជំនួសដូចជា [*] ដើម្បីជ្រើសរើសធាតុទាំងអស់នៃបញ្ជីមួយ។

ឧទាហរណ៍នៃកម្មវិធី

លទ្ធភាពសម្រាប់ការប្រើប្រាស់ទម្រង់លទ្ធផលជួរឈរផ្ទាល់ខ្លួនគឺគ្មានទីបញ្ចប់ទេ ព្រោះអ្នកអាចបង្ហាញវាលណាមួយ ឬការរួមបញ្ចូលគ្នានៃវាលធនធាននៅក្នុងលទ្ធផល។ នេះជាកម្មវិធីគំរូមួយចំនួន ប៉ុន្តែមានអារម្មណ៍សេរីក្នុងការស្វែងរកពួកវាដោយខ្លួនឯង ហើយស្វែងរកកម្មវិធីដែលដំណើរការសម្រាប់អ្នក។

បង្ហាញរូបភាពធុងសម្រាប់ផតៈ
```
$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

NAME                        IMAGES
engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
web-ui-6db964458-8pdw4      wordpress
```
ពាក្យបញ្ជានេះបង្ហាញឈ្មោះរូបភាពកុងតឺន័រសម្រាប់ផតនីមួយៗ។

សូមចងចាំថាផតអាចមានធុងជាច្រើន បន្ទាប់មកឈ្មោះរូបភាពនឹងត្រូវបានបង្ហាញនៅលើបន្ទាត់មួយ ដោយបំបែកដោយសញ្ញាក្បៀស។
បង្ហាញតំបន់ដែលមានថ្នាំង៖
```
$ kubectl get nodes 
  -o 
custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'

NAME                          ZONE
ip-10-0-118-34.ec2.internal   us-east-1b
ip-10-0-36-80.ec2.internal    us-east-1a
ip-10-0-80-67.ec2.internal    us-east-1b
```
ពាក្យបញ្ជានេះមានប្រយោជន៍ប្រសិនបើចង្កោមរបស់អ្នកត្រូវបានបង្ហោះនៅក្នុងពពកសាធារណៈ។ វាបង្ហាញតំបន់ដែលមានសម្រាប់ថ្នាំងនីមួយៗ។

Availability zone គឺជាគំនិតពពកដែលកំណត់តំបន់ចម្លងទៅតំបន់ភូមិសាស្រ្តមួយ។

តំបន់ដែលមានសម្រាប់ថ្នាំងនីមួយៗត្រូវបានទទួលតាមរយៈស្លាកពិសេស - failure-domain.beta.kubernetes.io/zone. ប្រសិនបើចង្កោមកំពុងដំណើរការក្នុងពពកសាធារណៈ ស្លាកនេះត្រូវបានបង្កើតដោយស្វ័យប្រវត្តិ និងបំពេញដោយឈ្មោះតំបន់ដែលមានសម្រាប់ថ្នាំងនីមួយៗ។

ស្លាកមិនមែនជាផ្នែកនៃការបញ្ជាក់ធនធាន Kubernetes ទេ ដូច្នេះអ្នកនឹងមិនស្វែងរកព័ត៌មានអំពីពួកវានៅក្នុងនោះទេ។ ការណែនាំ API. ទោះយ៉ាងណាក៏ដោយ ពួកគេអាចត្រូវបានគេមើលឃើញ (ដូចជាស្លាកផ្សេងទៀត) ប្រសិនបើអ្នកស្នើសុំព័ត៌មានអំពីថ្នាំងក្នុងទម្រង់ YAML ឬ JSON៖
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
នេះគឺជាវិធីដ៏ល្អមួយដើម្បីស្វែងយល់បន្ថែមអំពីធនធាន បន្ថែមពីលើការបញ្ជាក់អំពីធនធានសិក្សា។

4. ងាយស្រួលប្តូររវាងចង្កោម និងចន្លោះឈ្មោះ

នៅពេលដែល kubectl ធ្វើសំណើទៅកាន់ Kubernetes API ដំបូងវាអានឯកសារ kubeconfig ដើម្បីទទួលបានប៉ារ៉ាម៉ែត្រចាំបាច់ទាំងអស់សម្រាប់ការតភ្ជាប់។

តាមលំនាំដើម ឯកសារ kubeconfig គឺ ~/.kube/config. ជាធម្មតាឯកសារនេះត្រូវបានបង្កើត ឬធ្វើបច្ចុប្បន្នភាពដោយពាក្យបញ្ជាពិសេស។

នៅពេលអ្នកធ្វើការជាមួយចង្កោមច្រើន ឯកសារ kubeconfig របស់អ្នកមានការកំណត់សម្រាប់ភ្ជាប់ទៅគ្រប់ចង្កោមទាំងនោះ។ អ្នកត្រូវការវិធីមួយដើម្បីប្រាប់ពាក្យបញ្ជា kubectl ថាចង្កោមដែលអ្នកកំពុងធ្វើការជាមួយ។

នៅក្នុងចង្កោមមួយ អ្នកអាចបង្កើតចន្លោះឈ្មោះច្រើន—ប្រភេទនៃចង្កោមនិម្មិតនៅក្នុងចង្កោមរូបវន្ត។ Kubectl ក៏កំណត់ឈ្មោះលំហដែលត្រូវប្រើដោយផ្អែកលើឯកសារ kubeconfig ។ នេះមានន័យថាអ្នកក៏ត្រូវការវិធីមួយដើម្បីប្រាប់ពាក្យបញ្ជា kubectl នូវអ្វីដែល namespace ដើម្បីធ្វើការជាមួយ។

នៅក្នុងជំពូកនេះ យើងនឹងពន្យល់ពីរបៀបដែលវាដំណើរការ និងរបៀបធ្វើឱ្យវាដំណើរការប្រកបដោយប្រសិទ្ធភាព។

ចំណាំថាអ្នកអាចមានឯកសារ kubeconfig ជាច្រើនដែលបានរាយបញ្ជីនៅក្នុងអថេរបរិស្ថាន KUBECONFIG ។ ក្នុងករណីនេះ ឯកសារទាំងអស់នេះនឹងត្រូវបានរួមបញ្ចូលក្នុងការកំណត់រចនាសម្ព័ន្ធទូទៅមួយនៅពេលដំណើរការ។ អ្នកក៏អាចផ្លាស់ប្តូរឯកសារ kubeconfig លំនាំដើមដោយដំណើរការ kubectl ជាមួយប៉ារ៉ាម៉ែត្រ --kubeconfig. មើល ឯកសារផ្លូវការ.

ឯកសារ kubeconfig

តោះមើលថាតើឯកសារ kubeconfig មានអ្វីខ្លះ៖

ដូចដែលអ្នកអាចឃើញ ឯកសារ kubeconfig មានសំណុំបរិបទ។ បរិបទមានធាតុបី៖

ចង្កោម — API URL របស់ម៉ាស៊ីនមេចង្កោម។
អ្នកប្រើប្រាស់ - អត្តសញ្ញាណសម្គាល់ការផ្ទៀងផ្ទាត់អ្នកប្រើប្រាស់នៅក្នុងចង្កោម។
Namespace - ចន្លោះឈ្មោះដែលប្រើនៅពេលចូលរួមចង្កោម។

នៅក្នុងការអនុវត្ត ពួកគេច្រើនតែប្រើបរិបទមួយក្នុងមួយចង្កោមក្នុង kubeconfig របស់ពួកគេ។ ទោះយ៉ាងណាក៏ដោយ អ្នកអាចមានបរិបទច្រើនក្នុងមួយចង្កោម ដែលខុសគ្នាដោយអ្នកប្រើប្រាស់ ឬចន្លោះឈ្មោះ។ ទោះជាយ៉ាងណាក៏ដោយ ការកំណត់រចនាសម្ព័ន្ធពហុបរិបទនេះគឺមិនធម្មតាទេ ដូច្នេះជាធម្មតាមានការគូសផែនទីពីមួយទៅមួយរវាងចង្កោម និងបរិបទ។

នៅពេលណាមួយ បរិបទមួយក្នុងចំណោមបរិបទគឺបច្ចុប្បន្ន៖

នៅពេល kubectl អានឯកសារកំណត់រចនាសម្ព័ន្ធ វាតែងតែយកព័ត៌មានពីបរិបទបច្ចុប្បន្ន។ ក្នុងឧទាហរណ៍ខាងលើ kubectl នឹងភ្ជាប់ទៅក្រុម Hare ។

ដូច្នោះហើយ ដើម្បីប្តូរទៅចង្កោមមួយផ្សេងទៀត អ្នកត្រូវផ្លាស់ប្តូរបរិបទបច្ចុប្បន្ននៅក្នុងឯកសារ kubeconfig៖

ឥឡូវនេះ kubectl នឹងភ្ជាប់ទៅចង្កោម Fox ។

ដើម្បីប្តូរទៅលំហឈ្មោះផ្សេងនៅក្នុងចង្កោមតែមួយ អ្នកត្រូវផ្លាស់ប្តូរតម្លៃនៃធាតុ namespace សម្រាប់បរិបទបច្ចុប្បន្ន៖

ក្នុងឧទាហរណ៍ខាងលើ kubectl នឹងប្រើ Prod namespace របស់ Fox cluster (ពីមុន Test namespace ត្រូវបានកំណត់)។

ចំណាំថា kubectl ក៏ផ្តល់ជម្រើសផងដែរ។ --cluster, --user, --namespace и --contextដែលអនុញ្ញាតឱ្យអ្នកសរសេរជាន់លើធាតុនីមួយៗ និងបរិបទបច្ចុប្បន្នដោយខ្លួនឯង ដោយមិនគិតពីអ្វីដែលត្រូវបានកំណត់នៅក្នុង kubeconfig។ មើល kubectl options.

តាមទ្រឹស្តី អ្នកអាចផ្លាស់ប្តូរការកំណត់ដោយដៃនៅក្នុង kubeconfig ។ ប៉ុន្តែវាជាការមិនស្រួល។ ដើម្បីសម្រួលប្រតិបត្តិការទាំងនេះ មានឧបករណ៍ប្រើប្រាស់ផ្សេងៗដែលអនុញ្ញាតឱ្យអ្នកផ្លាស់ប្តូរប៉ារ៉ាម៉ែត្រដោយស្វ័យប្រវត្តិ។

ប្រើ kubectx

ឧបករណ៍ប្រើប្រាស់ដ៏ពេញនិយមសម្រាប់ប្តូររវាងចង្កោម និងចន្លោះឈ្មោះ។

ឧបករណ៍ប្រើប្រាស់ផ្តល់នូវពាក្យបញ្ជា kubectx и kubens ដើម្បីផ្លាស់ប្តូរបរិបទបច្ចុប្បន្ន និងលំហឈ្មោះរៀងៗខ្លួន។

ដូចដែលបានរៀបរាប់រួចហើយ ការផ្លាស់ប្តូរបរិបទបច្ចុប្បន្នមានន័យថាផ្លាស់ប្តូរចង្កោម ប្រសិនបើអ្នកមានបរិបទតែមួយក្នុងមួយចង្កោម។

នេះគឺជាឧទាហរណ៍នៃការដំណើរការពាក្យបញ្ជាទាំងនេះ៖

សំខាន់ ពាក្យបញ្ជាទាំងនេះគ្រាន់តែកែសម្រួលឯកសារ kubeconfig ដូចដែលបានពិពណ៌នាខាងលើ។

ដើម្បីដំឡើង kubectxអនុវត្តតាមការណែនាំនៅលើ Github ។

ពាក្យបញ្ជាទាំងពីរគាំទ្រការបំពេញដោយស្វ័យប្រវត្តិនៃបរិបទ និងឈ្មោះចន្លោះដែលលុបបំបាត់តម្រូវការក្នុងការវាយបញ្ចូលទាំងស្រុង។ ការណែនាំសម្រាប់ការដំឡើងការបំពេញដោយស្វ័យប្រវត្តិ នៅទីនេះ.

មុខងារមានប្រយោជន៍មួយទៀត kubectx វាគឺជាការ របៀបអន្តរកម្ម. វាដំណើរការដោយភ្ជាប់ជាមួយឧបករណ៍ប្រើប្រាស់ fzfដែលត្រូវតែដំឡើងដោយឡែកពីគ្នា។ ការដំឡើង fzf ដោយស្វ័យប្រវត្តិធ្វើឱ្យរបៀបអន្តរកម្មមាននៅក្នុង kubectx. អន្តរកម្ម អ្នកអាចជ្រើសរើសបរិបទ និងចន្លោះឈ្មោះតាមរយៈចំណុចប្រទាក់ស្វែងរកឥតគិតថ្លៃអន្តរកម្មដែលផ្តល់ដោយ fzf ។

ការប្រើឈ្មោះក្លែងក្លាយសែល

អ្នកមិនត្រូវការឧបករណ៍ដាច់ដោយឡែកដើម្បីផ្លាស់ប្តូរបរិបទបច្ចុប្បន្ននិង namespace ព្រោះ kubectl ក៏ផ្តល់នូវពាក្យបញ្ជាសម្រាប់វា។ បាទ ក្រុម kubectl config ផ្តល់នូវពាក្យបញ្ជារងសម្រាប់កែសម្រួលឯកសារ kubeconfig ។

នេះគឺមួយចំនួននៃពួកគេ:

kubectl config get-contexts៖ បង្ហាញបរិបទទាំងអស់;
kubectl config current-context៖ ទទួលបានបរិបទបច្ចុប្បន្ន;
kubectl config use-context៖ ផ្លាស់ប្តូរបរិបទបច្ចុប្បន្ន;
kubectl config set-context៖ ផ្លាស់ប្តូរធាតុបរិបទ។

ទោះជាយ៉ាងណាក៏ដោយការប្រើពាក្យបញ្ជាទាំងនេះដោយផ្ទាល់គឺមិនងាយស្រួលទេព្រោះវាមានរយៈពេលយូរ។ អ្នកអាចបង្កើតឈ្មោះក្លែងក្លាយសែលសម្រាប់ពួកវាដែលងាយស្រួលប្រតិបត្តិ។

ខ្ញុំបានបង្កើតសំណុំនៃឈ្មោះក្លែងក្លាយដោយផ្អែកលើពាក្យបញ្ជាទាំងនេះដែលផ្តល់មុខងារស្រដៀងទៅនឹង kubectx។ នៅទីនេះអ្នកអាចមើលឃើញពួកគេនៅក្នុងសកម្មភាព៖

ចំណាំថាឈ្មោះក្លែងក្លាយប្រើ fzf ដើម្បីផ្តល់នូវចំណុចប្រទាក់រកមើលដោយឥតគិតថ្លៃអន្តរកម្ម (ដូចជារបៀបអន្តរកម្មរបស់ kubectx) ។ នេះមានន័យថាអ្នកត្រូវការ ដំឡើង fzfដើម្បីប្រើឈ្មោះក្លែងក្លាយទាំងនេះ។

នេះគឺជានិយមន័យនៃឈ្មោះក្លែងក្លាយខ្លួនឯង៖

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

ដើម្បីកំណត់ឈ្មោះក្លែងក្លាយទាំងនេះ អ្នកត្រូវបន្ថែមនិយមន័យខាងលើទៅក្នុងឯកសាររបស់អ្នក។ ~/.bashrc ឬ ~/.zshrc ហើយចាប់ផ្ដើមសែលរបស់អ្នកឡើងវិញ។

ការប្រើប្រាស់កម្មវិធីជំនួយ

Kubectl អនុញ្ញាតឱ្យអ្នកផ្ទុកកម្មវិធីជំនួយដែលត្រូវបានប្រតិបត្តិតាមរបៀបដូចគ្នានឹងពាក្យបញ្ជាមូលដ្ឋាន។ ឧទាហរណ៍ អ្នកអាចដំឡើងកម្មវិធីជំនួយ kubectl-foo ហើយដំណើរការវាដោយប្រតិបត្តិពាក្យបញ្ជា kubectl foo.

វានឹងមានភាពងាយស្រួលក្នុងការផ្លាស់ប្តូរបរិបទ និងចន្លោះឈ្មោះតាមវិធីនេះ ឧទាហរណ៍ដោយការរត់ kubectl ctx ដើម្បីផ្លាស់ប្តូរបរិបទ និង kubectl ns ដើម្បីផ្លាស់ប្តូរឈ្មោះ។

ខ្ញុំបានសរសេរកម្មវិធីជំនួយពីរដែលធ្វើដូចនេះ៖

ការងាររបស់កម្មវិធីជំនួយគឺផ្អែកលើឈ្មោះក្លែងក្លាយពីផ្នែកមុន។

នេះជារបៀបដែលពួកគេធ្វើការ៖

ចំណាំថាកម្មវិធីជំនួយប្រើ fzf ដើម្បីផ្តល់នូវចំណុចប្រទាក់ស្វែងរកដោយឥតគិតថ្លៃអន្តរកម្ម (ដូចជារបៀបអន្តរកម្មរបស់ kubectx) ។ នេះមានន័យថាអ្នកត្រូវការ ដំឡើង fzfដើម្បីប្រើឈ្មោះក្លែងក្លាយទាំងនេះ។

ដើម្បីដំឡើងកម្មវិធីជំនួយ អ្នកត្រូវទាញយកស្គ្រីបសែលដែលមានឈ្មោះ kubectl-ctx и kubectl-ns ទៅកាន់ថតណាមួយនៅក្នុងអថេរ PATH របស់អ្នក ហើយធ្វើឱ្យពួកវាអាចប្រតិបត្តិបានជាមួយ ឧ. chmod +x. ភ្លាមៗបន្ទាប់ពីនេះអ្នកនឹងអាចប្រើបាន។ kubectl ctx и kubectl ns.

5. កាត់បន្ថយការបញ្ចូលជាមួយ autoaliases

ឈ្មោះក្លែងក្លាយ Shell គឺជាវិធីល្អដើម្បីបង្កើនល្បឿនការបញ្ចូល។ គម្រោង kubectl-aliases មានផ្លូវកាត់ប្រហែល 800 សម្រាប់ពាក្យបញ្ជា kubectl មូលដ្ឋាន។

អ្នកប្រហែលជាឆ្ងល់ - តើអ្នកចងចាំឈ្មោះក្លែងក្លាយ 800 យ៉ាងដូចម្តេច? ប៉ុន្តែអ្នកមិនចាំបាច់ចាំវាទាំងអស់នោះទេ ព្រោះវាត្រូវបានបង្កើតឡើងតាមគ្រោងការណ៍ដ៏សាមញ្ញមួយដែលមានដូចខាងក្រោម៖

ឧទាហរណ៍:

kgpooyaml - kubectl ទទួលបាន pods oyaml
ksysgsvcw — kubectl -n kube-system ទទួលបាន svc w
ksysrmcm -kubectl -n kube-ប្រព័ន្ធ rm cm
kgdepallsl - kubectl ទទួលបានការដាក់ពង្រាយ sl

ដូចដែលអ្នកអាចឃើញឈ្មោះក្លែងក្លាយត្រូវបានបង្កើតឡើងដោយសមាសធាតុដែលនីមួយៗតំណាងឱ្យធាតុជាក់លាក់នៃពាក្យបញ្ជា kubectl ។ ឈ្មោះក្លែងក្លាយនីមួយៗអាចមានសមាសភាគមួយសម្រាប់ពាក្យបញ្ជាមូលដ្ឋាន ប្រតិបត្តិការ និងធនធាន និងសមាសធាតុជាច្រើនសម្រាប់ប៉ារ៉ាម៉ែត្រ។ អ្នកគ្រាន់តែ "បញ្ចូល" សមាសធាតុទាំងនេះពីឆ្វេងទៅស្តាំ យោងតាមដ្យាក្រាមខាងលើ។

ដ្យាក្រាមលម្អិតបច្ចុប្បន្នគឺនៅ GitHub. នៅទីនោះអ្នកក៏អាចរកឃើញផងដែរ។ បញ្ជីឈ្មោះក្លែងក្លាយពេញលេញ.

ឧទាហរណ៍ ឈ្មោះហៅក្រៅ kgpooyamlall គឺស្មើនឹងពាក្យបញ្ជា kubectl get pods -o yaml --all-namespaces.

លំដាប់ដែលទាក់ទងនៃជម្រើសគឺមិនសំខាន់ទេ៖ ពាក្យបញ្ជា kgpooyamlall គឺស្មើនឹងពាក្យបញ្ជា kgpoalloyaml.

អ្នកមិនចាំបាច់ប្រើសមាសធាតុទាំងអស់ជាឈ្មោះក្លែងក្លាយទេ។ ឧទាហរណ៍ k, kg, klo, ksys, kgpo ក៏អាចប្រើបានដែរ។ លើសពីនេះទៅទៀត អ្នកអាចផ្សំឈ្មោះក្លែងក្លាយ និងពាក្យបញ្ជាធម្មតា ឬជម្រើសនៅលើបន្ទាត់ពាក្យបញ្ជា៖

ឧទាហរណ៍:

ជំនួស។ kubectl proxy អ្នកអាចសរសេរបាន។ k proxy.
ជំនួស។ kubectl get roles អ្នកអាចសរសេរបាន។ kg roles (បច្ចុប្បន្នមិនមានឈ្មោះក្លែងក្លាយសម្រាប់ធនធានតួនាទីទេ)។
ដើម្បីទទួលបានទិន្នន័យសម្រាប់ផតជាក់លាក់ អ្នកអាចប្រើពាក្យបញ្ជា kgpo my-pod — kubectl get pod my-pod.

សូមចំណាំថាឈ្មោះក្លែងក្លាយមួយចំនួនតម្រូវឱ្យមានអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជា។ ឧទាហរណ៍ឈ្មោះក្លែងក្លាយ kgpol មធ្យោបាយ kubectl get pods -l. ជម្រើស -l ទាមទារអាគុយម៉ង់ - ការបញ្ជាក់ស្លាក។ ប្រសិនបើអ្នកប្រើឈ្មោះក្លែងក្លាយ វានឹងមើលទៅដូច kgpol app=ui.

ដោយសារតែឈ្មោះក្លែងក្លាយមួយចំនួនតម្រូវឱ្យមានអាគុយម៉ង់ ឈ្មោះក្លែងក្លាយ a, f និង l ត្រូវតែប្រើចុងក្រោយ។

ជាទូទៅ នៅពេលដែលអ្នកទទួលបានការព្យួរនៃគ្រោងការណ៍នេះ អ្នកអាចទាញយកឈ្មោះក្លែងក្លាយដោយវិចារណញាណពីពាក្យបញ្ជាដែលអ្នកចង់ប្រតិបត្តិ និងសន្សំសំចៃពេលវេលាវាយច្រើន។

ការដំឡើង។

ដើម្បីដំឡើង kubectl-aliases អ្នកត្រូវទាញយកឯកសារ .kubectl_aliases ពី GitHub ហើយបញ្ចូលវាទៅក្នុងឯកសារ ~/.bashrc ឬ ~/.zshrc:

source ~/.kubectl_aliases

ការបំពេញដោយស្វ័យប្រវត្តិ

ដូចដែលយើងបាននិយាយពីមុន អ្នកតែងតែបន្ថែមពាក្យបន្ថែមទៅឈ្មោះក្លែងក្លាយនៅលើបន្ទាត់ពាក្យបញ្ជា។ ឧទាហរណ៍:

$ kgpooyaml test-pod-d4b77b989

ប្រសិនបើអ្នកប្រើការបំពេញពាក្យបញ្ជា kubectl អ្នកប្រហែលជាបានប្រើការបំពេញដោយស្វ័យប្រវត្តិសម្រាប់អ្វីៗដូចជាឈ្មោះធនធាន។ ប៉ុន្តែតើនេះអាចត្រូវបានធ្វើនៅពេលដែលឈ្មោះក្លែងក្លាយត្រូវបានប្រើ?

នេះជាសំណួរសំខាន់ណាស់ ព្រោះប្រសិនបើការបំពេញដោយស្វ័យប្រវត្តិមិនដំណើរការ អ្នកនឹងបាត់បង់អត្ថប្រយោជន៍មួយចំនួននៃឈ្មោះក្លែងក្លាយ។

ចម្លើយគឺអាស្រ័យទៅលើសំបកមួយណាដែលអ្នកកំពុងប្រើ៖

សម្រាប់ Zsh ការបំពេញឈ្មោះក្លែងក្លាយដំណើរការចេញពីប្រអប់។
សម្រាប់ Bash ជាអកុសល ការងារមួយចំនួនត្រូវបានទាមទារដើម្បីទទួលបានការបំពេញដោយស្វ័យប្រវត្តិដើម្បីដំណើរការ។

បើកដំណើរការការបំពេញដោយស្វ័យប្រវត្តិសម្រាប់ឈ្មោះក្លែងក្លាយនៅក្នុង Bash

បញ្ហាជាមួយ Bash គឺថាវាព្យាយាមបញ្ចប់ (រាល់ពេលដែលអ្នកចុច Tab) ឈ្មោះក្លែងក្លាយ មិនមែនជាពាក្យបញ្ជាដែលឈ្មោះក្លែងក្លាយសំដៅលើ (ដូចដែល Zsh ធ្វើ ជាឧទាហរណ៍)។ ដោយសារអ្នកមិនមានស្គ្រីបបំពេញសម្រាប់ឈ្មោះក្លែងក្លាយទាំងអស់ 800 ការបំពេញដោយស្វ័យប្រវត្តិមិនដំណើរការទេ។

គម្រោង ឈ្មោះក្លែងក្លាយពេញលេញ ផ្តល់ដំណោះស្រាយទូទៅចំពោះបញ្ហានេះ។ វាភ្ជាប់ទៅយន្តការបំពេញសម្រាប់ឈ្មោះក្លែងក្លាយ ពង្រីកខាងក្នុងឈ្មោះក្លែងក្លាយទៅជាពាក្យបញ្ជា ហើយត្រឡប់ជម្រើសបំពេញសម្រាប់ពាក្យបញ្ជាដែលបានបញ្ចប់។ នេះមានន័យថា padding សម្រាប់ alias ដំណើរការដូចគ្នាទៅនឹងពាក្យបញ្ជាពេញលេញ។

ខាងក្រោមនេះ ជាដំបូង ខ្ញុំនឹងពន្យល់ពីរបៀបដំឡើងឈ្មោះពេញលេញ ហើយបន្ទាប់មកកំណត់រចនាសម្ព័ន្ធវា ដើម្បីបើកការបំពេញសម្រាប់ឈ្មោះក្លែងក្លាយ kubectl ទាំងអស់។

ការដំឡើងឈ្មោះក្លែងក្លាយពេញលេញ

ជាដំបូង សម្មតិនាមពេញលេញអាស្រ័យលើ ការបញ្ចប់ bash. ដូច្នេះមុននឹងដំឡើងឈ្មោះពេញលេញ អ្នកត្រូវប្រាកដថាការដំឡើង bash-completion ត្រូវបានដំឡើង។ ការណែនាំអំពីការដំឡើងត្រូវបានផ្តល់ជូនពីមុនសម្រាប់ Linux និង MacOS ។

ចំណាំសំខាន់សម្រាប់អ្នកប្រើប្រាស់ macOS៖ ដូចជាស្គ្រីបការបំពេញស្វ័យប្រវត្តិ kubectl ឈ្មោះក្លែងក្លាយពេញលេញមិនដំណើរការជាមួយ Bash 3.2 ដែលជាលំនាំដើមនៅលើ MacOS ទេ។ ជាពិសេស ឈ្មោះក្លែងក្លាយពេញលេញគឺអាស្រ័យលើ bash-completion v2 (brew install bash-completion@2) ដែលទាមទារយ៉ាងហោចណាស់ Bash 4.1 ។ នេះមានន័យថា ដើម្បីប្រើឈ្មោះក្លែងក្លាយពេញលេញនៅលើ MacOS អ្នកត្រូវដំឡើងកំណែថ្មីនៃ Bash ។

អ្នកត្រូវទាញយកស្គ្រីប bash_completion.sh ពី ឃ្លាំង GitHub ហើយបញ្ចូលវាទៅក្នុងឯកសាររបស់អ្នក។ ~/.bashrc:

source ~/bash_completion.sh

បន្ទាប់ពីចាប់ផ្តើមសែលឡើងវិញ នាមត្រកូលពេញលេញនឹងត្រូវបានដំឡើងយ៉ាងពេញលេញ។

បើកដំណើរការការបំពេញដោយស្វ័យប្រវត្តិសម្រាប់ឈ្មោះក្លែងក្លាយ kubectl

បច្ចេកទេសពេញលេញ - ឈ្មោះក្លែងក្លាយផ្តល់នូវមុខងាររុំ _complete_alias. មុខងារនេះពិនិត្យឈ្មោះក្លែងក្លាយ និងត្រឡប់ព័ត៌មានជំនួយសម្រាប់ការបំពេញពាក្យបញ្ជា។

ដើម្បីភ្ជាប់មុខងារជាមួយឈ្មោះក្លែងក្លាយជាក់លាក់មួយ អ្នកត្រូវប្រើយន្តការ Bash ដែលមានស្រាប់ បានបញ្ចប់, ដើម្បីដំឡើង _complete_alias ជាមុខងារបំពេញឈ្មោះក្លែងក្លាយ។

ជាឧទាហរណ៍ ចូរយើងយកឈ្មោះក្លែងក្លាយ k ដែលតំណាងឱ្យពាក្យបញ្ជា kubectl ។ ដើម្បីដំឡើង _complete_alias ជាមុខងារបំពេញបន្ថែមសម្រាប់ឈ្មោះក្លែងក្លាយនេះ អ្នកគួរតែដំណើរការពាក្យបញ្ជាខាងក្រោម៖

$ complete -F _complete_alias k

លទ្ធផលនៃការនេះគឺថា នៅពេលណាដែលអ្នកបំពេញឈ្មោះក្លែងក្លាយ k ដោយស្វ័យប្រវត្តិ មុខងារត្រូវបានហៅ _complete_aliasដែលពិនិត្យឈ្មោះក្លែងក្លាយ និងត្រឡប់ព័ត៌មានជំនួយសម្រាប់ការបំពេញពាក្យបញ្ជា kubectl.

ជាឧទាហរណ៍ទីពីរ ចូរយើងយកឈ្មោះក្លែងក្លាយ kgដែលតំណាងឱ្យ kubectl get:

$ complete -F _complete_alias kg

ដូចក្នុងឧទាហរណ៍មុនដែរ ពេលអ្នកបំពេញដោយស្វ័យប្រវត្តិ kg អ្នកនឹងទទួលបានព័ត៌មានជំនួយការបញ្ចប់ដូចគ្នាដែលអ្នកនឹងទទួលបាន kubectl get.

ចំណាំថាអ្នកអាចប្រើឈ្មោះក្លែងក្លាយពេញលេញសម្រាប់ឈ្មោះក្លែងក្លាយណាមួយនៅលើប្រព័ន្ធរបស់អ្នក។

ដូច្នេះ ដើម្បីបើកការបំពេញដោយស្វ័យប្រវត្តិសម្រាប់ឈ្មោះក្លែងក្លាយ kubectl ទាំងអស់ អ្នកត្រូវដំណើរការពាក្យបញ្ជាខាងលើសម្រាប់ពួកវានីមួយៗ។ អត្ថបទខ្លីៗខាងក្រោមធ្វើយ៉ាងពិតប្រាកដនេះ ផ្តល់ជូនអ្នកបានកំណត់ kubectl-aliases ទៅ ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

បំណែកនៃកូដនេះត្រូវតែដាក់នៅក្នុងរបស់អ្នក។ ~/.bashrcចាប់ផ្តើមសែលពាក្យបញ្ជាឡើងវិញ ហើយការបំពេញដោយស្វ័យប្រវត្តិនឹងមានសម្រាប់ឈ្មោះក្លែងក្លាយ 800 kubectl ទាំងអស់។

6. ពង្រីក kubectl ជាមួយកម្មវិធីជំនួយ

ចាប់ផ្តើមពី កំណែ 1.12, kubectl គាំទ្រ យន្តការកម្មវិធីជំនួយដែលអនុញ្ញាតឱ្យអ្នកពង្រីកមុខងាររបស់វាជាមួយនឹងពាក្យបញ្ជាបន្ថែម។

ប្រសិនបើអ្នកធ្លាប់ស្គាល់ យន្តការកម្មវិធីជំនួយ Gitបន្ទាប់មកកម្មវិធីជំនួយ kubectl ត្រូវបានបង្កើតឡើងនៅលើគោលការណ៍ដូចគ្នា។

នៅក្នុងជំពូកនេះ យើងនឹងរៀបរាប់អំពីរបៀបដំឡើងកម្មវិធីជំនួយ កន្លែងដែលត្រូវស្វែងរកពួកវា និងរបៀបបង្កើតកម្មវិធីជំនួយផ្ទាល់ខ្លួនរបស់អ្នក។

ការដំឡើងកម្មវិធីជំនួយ

កម្មវិធីជំនួយ Kubectl ត្រូវបានចែកចាយជាឯកសារដែលអាចប្រតិបត្តិបានសាមញ្ញដែលមានឈ្មោះដូចជា kubectl-x. បុព្វបទ kubectl- ត្រូវបានទាមទារ បន្តដោយពាក្យបញ្ជារង kubectl ថ្មីដែលអនុញ្ញាតឱ្យអ្នកហៅកម្មវិធីជំនួយ។

ឧទាហរណ៍ កម្មវិធីជំនួយ Hello នឹងត្រូវបានចែកចាយជាឯកសារដែលហៅថា kubectl-hello.

ដើម្បីដំឡើងកម្មវិធីជំនួយ អ្នកត្រូវចម្លងឯកសារ kubectl-x ទៅកាន់ថតណាមួយនៅក្នុង PATH របស់អ្នក ហើយធ្វើឱ្យវាអាចប្រតិបត្តិបាន ឧទាហរណ៍ជាមួយ chmod +x. ភ្លាមៗបន្ទាប់ពីនេះអ្នកអាចហៅកម្មវិធីជំនួយជាមួយ kubectl x.

អ្នកអាចប្រើពាក្យបញ្ជាខាងក្រោមដើម្បីរាយបញ្ជីកម្មវិធីជំនួយទាំងអស់ដែលត្រូវបានដំឡើងបច្ចុប្បន្ននៅលើប្រព័ន្ធរបស់អ្នក៖

$ kubectl plugin list

ពាក្យបញ្ជានេះក៏នឹងបង្ហាញការព្រមានផងដែរ ប្រសិនបើអ្នកមានកម្មវិធីជំនួយច្រើនដែលមានឈ្មោះដូចគ្នា ឬប្រសិនបើមានឯកសារកម្មវិធីជំនួយដែលមិនអាចប្រតិបត្តិបាន។

ស្វែងរក និងដំឡើងកម្មវិធីជំនួយដោយប្រើ Krew

កម្មវិធីជំនួយ Kubectl អាចត្រូវបានចែករំលែក ឬប្រើឡើងវិញដូចជាកញ្ចប់កម្មវិធី។ ប៉ុន្តែតើអ្នកអាចស្វែងរកកម្មវិធីជំនួយដែលអ្នកផ្សេងទៀតបានចែករំលែកនៅឯណា?

គម្រោង Krew មានគោលបំណងផ្តល់នូវដំណោះស្រាយបង្រួបបង្រួមសម្រាប់ការចែករំលែក ស្វែងរក ដំឡើង និងគ្រប់គ្រងកម្មវិធីជំនួយ kubectl។ គម្រោងនេះហៅខ្លួនវាថាជា "កម្មវិធីគ្រប់គ្រងកញ្ចប់សម្រាប់កម្មវិធីជំនួយ kubectl" (Krew គឺស្រដៀងទៅនឹង ញ៉ាំ).

Krew គឺជាបញ្ជីកម្មវិធីជំនួយ kubectl ដែលអ្នកអាចជ្រើសរើស និងដំឡើងបាន។ ក្នុងពេលជាមួយគ្នានេះ Krew ក៏ជាកម្មវិធីជំនួយសម្រាប់ kubectl ផងដែរ។

នេះមានន័យថាការដំឡើង Krew ដំណើរការសំខាន់ដូចជាការដំឡើងកម្មវិធីជំនួយ kubectl ផ្សេងទៀត។ អ្នកអាចស្វែងរកការណែនាំលម្អិតនៅ ទំព័រ GitHub.

ពាក្យបញ្ជា Krew សំខាន់បំផុតគឺ៖

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

សូមចំណាំថាការដំឡើងកម្មវិធីជំនួយដោយប្រើ Krew មិនរំខានដល់ការដំឡើងកម្មវិធីជំនួយដោយប្រើវិធីសាស្ត្រស្តង់ដារដែលបានពិពណ៌នាខាងលើទេ។

សូមចំណាំថាពាក្យបញ្ជា kubectl krew list បង្ហាញតែកម្មវិធីជំនួយដែលត្រូវបានដំឡើងដោយប្រើ Krew ចំណែកពាក្យបញ្ជា kubectl plugin list រាយបញ្ជីកម្មវិធីជំនួយទាំងអស់ ពោលគឺអ្នកដែលដំឡើងដោយប្រើប្រាស់ Krew និងកម្មវិធីដែលត្រូវបានដំឡើងដោយវិធីសាស្រ្តផ្សេងទៀត។

ស្វែងរកកម្មវិធីជំនួយនៅកន្លែងផ្សេង

Krew គឺជាគម្រោងវ័យក្មេង ដែលបច្ចុប្បន្នកំពុងស្ថិតក្នុងគម្រោងរបស់ខ្លួន បញ្ជី កម្មវិធីជំនួយប្រហែល 30 ប៉ុណ្ណោះ។ ប្រសិនបើអ្នកមិនអាចស្វែងរកអ្វីដែលអ្នកត្រូវការ អ្នកអាចស្វែងរកកម្មវិធីជំនួយនៅកន្លែងផ្សេងទៀតដូចជា GitHub ជាដើម។

ខ្ញុំសូមណែនាំឱ្យមើលផ្នែក GitHub kubectl-កម្មវិធីជំនួយ. នៅទីនោះអ្នកនឹងឃើញកម្មវិធីជំនួយដែលអាចប្រើបានរាប់សិបដែលមានតម្លៃពិនិត្យមើល។

សរសេរកម្មវិធីជំនួយផ្ទាល់ខ្លួនរបស់អ្នក។

អ្នកអាចដោយខ្លួនឯង។ បង្កើតកម្មវិធីជំនួយ - វាមិនពិបាកទេ។ អ្នកត្រូវបង្កើតកម្មវិធីប្រតិបត្តិដែលធ្វើអ្វីដែលអ្នកត្រូវការឈ្មោះវាដូចជា kubectl-x ហើយដំឡើងដូចបានរៀបរាប់ខាងលើ។

ឯកសារអាចជាស្គ្រីប bash ស្គ្រីប python ឬកម្មវិធី GO ដែលបានចងក្រង - វាមិនមានបញ្ហាទេ។ លក្ខខណ្ឌតែមួយគត់គឺថាវាអាចត្រូវបានប្រតិបត្តិដោយផ្ទាល់នៅក្នុងប្រព័ន្ធប្រតិបត្តិការ។

តោះបង្កើតកម្មវិធីជំនួយឧទាហរណ៍ឥឡូវនេះ។ នៅក្នុងផ្នែកមុន អ្នកបានប្រើពាក្យបញ្ជា kubectl ដើម្បីរាយបញ្ជីធុងសម្រាប់ផតនីមួយៗ។ វាងាយស្រួលក្នុងការបង្វែរពាក្យបញ្ជានេះទៅជាកម្មវិធីជំនួយដែលអ្នកអាចហៅជាមួយ ឧ. kubectl img.

បង្កើតឯកសារ kubectl-img ខ្លឹមសារខាងក្រោម៖

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

ឥឡូវនេះធ្វើឱ្យឯកសារអាចប្រតិបត្តិបានជាមួយ chmod +x kubectl-img ហើយផ្លាស់ទីវាទៅថតណាមួយនៅក្នុង PATH របស់អ្នក។ ភ្លាមៗបន្ទាប់ពីនេះអ្នកអាចប្រើកម្មវិធីជំនួយ kubectl img.

ដូចដែលបានរៀបរាប់រួច កម្មវិធីជំនួយ kubectl អាចត្រូវបានសរសេរជាភាសាសរសេរកម្មវិធី ឬស្គ្រីបណាមួយ។ ប្រសិនបើអ្នកកំពុងប្រើស្គ្រីបសែល អត្ថប្រយោជន៍នៃការអាចហៅទៅ kubectl យ៉ាងងាយស្រួលពីក្នុងកម្មវិធីជំនួយ។ ទោះយ៉ាងណាក៏ដោយ អ្នកអាចសរសេរកម្មវិធីជំនួយស្មុគស្មាញបន្ថែមទៀតនៅក្នុងភាសាសរសេរកម្មវិធីពិតប្រាកដដោយប្រើ បណ្ណាល័យអតិថិជន Kubernetes. ប្រសិនបើអ្នកកំពុងប្រើ Go អ្នកក៏អាចប្រើផងដែរ។ បណ្ណាល័យ cli-runtimeដែលមានជាពិសេសសម្រាប់ការសរសេរកម្មវិធីជំនួយ kubectl។

របៀបចែករំលែកកម្មវិធីជំនួយរបស់អ្នក។

ប្រសិនបើអ្នកគិតថាកម្មវិធីជំនួយរបស់អ្នកអាចមានប្រយោជន៍សម្រាប់អ្នកដទៃ សូមចែករំលែកវានៅលើ GitHub ដោយសេរី។ ត្រូវប្រាកដថាបន្ថែមពួកវាទៅក្នុងប្រធានបទ kubectl-កម្មវិធីជំនួយ.

អ្នកក៏អាចស្នើសុំឱ្យបន្ថែមកម្មវិធីជំនួយរបស់អ្នកទៅ បញ្ជី Krew. ការណែនាំអំពីរបៀបធ្វើវាមាននៅក្នុង ឃ្លាំង GitHub.

ការបញ្ចប់ពាក្យបញ្ជា

បច្ចុប្បន្នកម្មវិធីជំនួយមិនគាំទ្រការបំពេញដោយស្វ័យប្រវត្តិទេ។ នោះគឺអ្នកត្រូវតែបញ្ចូលឈ្មោះពេញរបស់កម្មវិធីជំនួយ និងឈ្មោះពេញនៃអាគុយម៉ង់។

ឃ្លាំង GitHub kubectl សម្រាប់មុខងារនេះមាន សំណើបើកចំហ. ដូច្នេះវាអាចទៅរួចដែលថាមុខងារនេះនឹងត្រូវបានអនុវត្តនៅពេលណាមួយនាពេលអនាគត។

សំណាងល្អ!!!

តើមានអ្វីទៀតដែលត្រូវអានលើប្រធានបទ:

ប្រភព: www.habr.com

របៀបប្រើ kubectl កាន់តែមានប្រសិទ្ធភាព៖ ការណែនាំលម្អិត