ល្បិច និងគន្លឹះ Kubernetes កំពូលទាំង 10

មានអក្សរសិល្ប៍យោងជាច្រើននៅលើអ៊ីនធឺណិត ប៉ុន្តែពេលខ្លះដំបូន្មានដ៏សាមញ្ញបំផុតគឺមានតម្លៃបំផុត។ ក្រុម Kubernetes aaS ពី Mail.ru បកប្រែ ជម្រើសនៃល្បិចនិងគន្លឹះដប់ដែលអ្នកនិពន្ធអត្ថបទប្រមូលបានបន្ទាប់ពីធ្វើការជាមួយ Kubernetes មួយឆ្នាំ។ គន្លឹះ​មិន​ត្រូវ​បាន​តម្រៀប​តាម​សារៈសំខាន់​ទេ ប៉ុន្តែ​យើង​គិត​ថា​អ្នក​រាល់​គ្នា​នឹង​រក​ឃើញ​អ្វី​ដែល​មាន​ប្រយោជន៍​សម្រាប់​ខ្លួន​គេ។

ពាក្យបញ្ជាសាមញ្ញបំផុតដើម្បីធ្វើការជាមួយ Kubernetes

ដើម្បីចាប់ផ្តើម ប្រហែលជាសកម្មភាពសាមញ្ញបំផុត និងមានប្រយោជន៍បំផុតក្នុងការធ្វើការជាមួយ Kubernetes ។ ពាក្យបញ្ជាខាងក្រោមបើកការបំពេញពាក្យបញ្ជា kubectl នៅក្នុងសែល bash:

echo "source <(kubectl completion bash)" >> ~/.bashrc

បំពេញស្វ័យប្រវត្តិ kubectl នឹងត្រូវបានសរសេរទៅឯកសារ .bashrc ហើយនឹងត្រូវបានធ្វើឱ្យសកម្មដោយស្វ័យប្រវត្តិរាល់ពេលដែលសែលត្រូវបានចាប់ផ្តើម។ វាបង្កើនល្បឿនវាយពាក្យបញ្ជាវែងៗ និងប៉ារ៉ាម៉ែត្រដូចជា all-namespaces. ព័ត៌មានលម្អិតបន្ថែមនៅក្នុង Kubernetes ជំនួយ bash.

ការកំណត់អង្គចងចាំលំនាំដើម និងស៊ីភីយូក្នុងចន្លោះឈ្មោះ

ឧទាហរណ៍ ប្រសិនបើកម្មវិធីត្រូវបានសរសេរមិនត្រឹមត្រូវ វាបើកការភ្ជាប់ថ្មីទៅកាន់មូលដ្ឋានទិន្នន័យរៀងរាល់វិនាទី ប៉ុន្តែមិនដែលបិទវាទេ នោះចង្កោមមានការលេចធ្លាយអង្គចងចាំ។ ហើយប្រសិនបើកម្មវិធីមិនមានដែនកំណត់អង្គចងចាំដែលបានកំណត់កំឡុងពេលដាក់ពង្រាយទេ នេះអាចនាំឱ្យថ្នាំងបរាជ័យ។

ដើម្បីទប់ស្កាត់បញ្ហានេះ Kubernetes អនុញ្ញាតឱ្យអ្នកកំណត់ការរឹតបន្តឹងលំនាំដើមនៅលើមូលដ្ឋានឈ្មោះនីមួយៗ។ ពួកវាត្រូវបានសរសេរនៅក្នុងឯកសារ yaml សម្រាប់ namespace ជាក់លាក់មួយ។ នេះគឺជាឧទាហរណ៍នៃឯកសារបែបនេះ៖

apiVersion: v1
kind: LimitRange
metadata:
  name: mem-limit-range
spec:
  limits:
  - default:
      memory: 512Mi
    defaultRequest:
      memory: 256Mi
    type: Container

បង្កើត yaml បែបនេះ ហើយអនុវត្តទៅកន្លែងដាក់ឈ្មោះណាមួយ។ ឧទាហរណ៍ទៅកន្លែងឈ្មោះ limit-example. ឥឡូវនេះ កុងតឺន័រណាដែលដាក់ពង្រាយក្នុង namespace នេះនឹងមានដែនកំណត់ 512Mi លើកលែងតែដែនកំណត់បុគ្គលផ្សេងទៀតត្រូវបានកំណត់បន្ថែមសម្រាប់កុងតឺន័រនេះ។

ការប្រមូលសំរាមនៅក្នុងកំណែចាស់របស់ Kubernetes

Kubelet តាមលំនាំដើមចាប់ផ្តើមប្រមូលសំរាមនៅពេលណា var/lib/docker កាន់កាប់ 90% នៃទំហំថាសដែលមាន។ ទោះយ៉ាងណាក៏ដោយ នេះគឺអស្ចារ្យណាស់ រហូតដល់ Kubernetes 1.7 មិនមានការកំណត់លំនាំដើមលើចំនួន inodes ដែលបានប្រើ ដែលត្រូវនឹងចំនួនឯកសារនៅក្នុងប្រព័ន្ធឯកសារ។

សក្តានុពលនៃធុងរបស់អ្នក។ var/lib/docker អាចប្រើត្រឹមតែ 50% នៃទំហំថាស ប៉ុន្តែអាចអស់អ៊ីណូដ ដែលនឹងបង្កបញ្ហាដល់កម្មករ។

នៅក្នុងកំណែចាស់របស់ kubelet ពី 1.4 ទៅ 1.6 អ្នកនឹងត្រូវបន្ថែមទង់នេះ៖

--eviction-hard
=memory.available<100Mi,nodefs.available<10%,nodefs.inodesFree<5%

នៅក្នុងកំណែ 1.7 និងក្រោយនេះ ទង់នេះត្រូវបានកំណត់តាមលំនាំដើម។ ទោះយ៉ាងណាក៏ដោយ កំណែមុនៗមិនត្រួតពិនិត្យដែនកំណត់ inode ទេ។

Minikube... តូច ប៉ុន្តែមានថាមពល Kubernetes ក្នុងស្រុក

Minikube គឺជាមធ្យោបាយងាយស្រួលបំផុតដើម្បីដំណើរការចង្កោម Kubernetes ក្នុងតំបន់។ វា​ត្រូវ​បាន​ចាប់​ផ្តើ​ម​ជាមួយ​នឹង​ពាក្យ​បញ្ជា​សាមញ្ញ​មួយ​:

minikube start

ការដំណើរការពាក្យបញ្ជានេះបណ្តាលឱ្យមានចង្កោម Kubernetes ពិតប្រាកដដែលកំពុងដំណើរការនៅលើម៉ាស៊ីនរបស់អ្នក។

ប្រភពរូបភាព

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

ដើម្បីបង្ខំ Docker ឱ្យរុញរូបភាពទៅចង្កោម Kubernetes មូលដ្ឋាន ម៉ាស៊ីន docker ត្រូវបានផ្តល់ពាក្យបញ្ជាដូចខាងក្រោម៖

eval $(minikube docker-env)

ឥឡូវនេះយើងអាចបង្កើតកម្មវិធីនៅលើចង្កោម Kubernetes ក្នុងតំបន់។

កុំផ្តល់សិទ្ធិចូលប្រើ kubectl ដល់មនុស្សគ្រប់គ្នា

វាហាក់ដូចជាជាក់ស្តែង ប៉ុន្តែប្រសិនបើក្រុមជាច្រើនកំពុងប្រើចង្កោមដូចគ្នាសម្រាប់កម្មវិធីរបស់ពួកគេ (ដែលជាអ្វីដែល Kubernetes ត្រូវបានបង្កើតឡើងសម្រាប់) អ្នកមិនគួរគ្រាន់តែផ្តល់ឱ្យអ្នកគ្រប់គ្នានោះទេ។ kubectl. វាជាការប្រសើរជាងក្នុងការបែងចែកពាក្យបញ្ជា ដោយកំណត់ឱ្យពួកវានីមួយៗមានលំហឈ្មោះផ្ទាល់ខ្លួន និងកំណត់ការចូលប្រើប្រាស់ដោយប្រើគោលការណ៍ RBAC ។

អ្នកអាចយល់ច្រលំដោយកំណត់សិទ្ធិចូលប្រើ អាន បង្កើត លុប និងប្រតិបត្តិការផ្សេងទៀតសម្រាប់ផតនីមួយៗ។ ប៉ុន្តែរឿងសំខាន់គឺកំណត់ការចូលប្រើអាថ៌កំបាំងដោយអនុញ្ញាតឱ្យវាសម្រាប់តែអ្នកគ្រប់គ្រងប៉ុណ្ណោះ។ វិធីនេះ យើងនឹងបែងចែកភាពខុសគ្នារវាងអ្នកដែលអាចគ្រប់គ្រងចង្កោម និងអ្នកដែលអាចប្រើវាដោយសាមញ្ញ។

គ្រប់គ្រងថវិកា Pod

តើធ្វើដូចម្តេចដើម្បីធានាថាមិនមានពេលវេលារងចាំសម្រាប់កម្មវិធីនៅក្នុងចង្កោម Kubernetes? PodDisruptionBudget ហើយម្តងទៀត PodDisruptionBudget ។

ចង្កោមត្រូវបានធ្វើបច្ចុប្បន្នភាពជាទៀងទាត់ ហើយថ្នាំងត្រូវបានទទេ។ គ្មានអ្វីនៅស្ងៀមទេ នោះជាការពិត។ រាល់ការដាក់ពង្រាយដែលមានឧទាហរណ៍ច្រើនជាងមួយគួរតែរួមបញ្ចូល PDB (PodDisruptionBudget) ។ វា​ត្រូវ​បាន​បង្កើត​ក្នុង​ឯកសារ yaml សាមញ្ញ​ដែល​ត្រូវ​បាន​អនុវត្ត​ទៅ​នឹង​ចង្កោម។ តំបន់គ្របដណ្តប់នៃ PDB ជាក់លាក់មួយត្រូវបានកំណត់ដោយអ្នកជ្រើសរើសស្លាក។

ចំណាំ: ថវិកា PDB ត្រូវបានគេយកមកពិចារណាតែនៅពេលដែលការបំពានថវិកាអាចត្រឡប់វិញបាន (ការរំខានដោយស្ម័គ្រចិត្ត) នៅក្នុងស្ថានភាពដូចជាការបរាជ័យផ្នែករឹង PDB នឹងមិនដំណើរការទេ។

ឧទាហរណ៍ PDB៖

apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
  name: app-a-pdb
spec:
  minAvailable: 2
  selector:
      matchLabels:
        app: app-a

ប៉ារ៉ាម៉ែត្រសំខាន់ពីរគឺ matchLabels и minAvailable. ប៉ារ៉ាម៉ែត្រទីមួយបញ្ជាក់ថាតើកម្មវិធីណាដែលថវិកាត្រូវអនុវត្ត។ ឧទាហរណ៍ ប្រសិនបើខ្ញុំដាក់ពង្រាយជាមួយស្លាក app: app-a и app: app-bបន្ទាប់មក PDB នេះនឹងអនុវត្តចំពោះតែទីមួយប៉ុណ្ណោះ។

ប៉ារ៉ាម៉ែត្រ minAvailable យកទៅក្នុងគណនីនៅពេលសម្អាត (សម្អាត) ថ្នាំង។ ជាឧទាហរណ៍ ក្នុងឧទាហរណ៍របស់យើង កំឡុងពេលបញ្ចេញចោល ករណីទាំងអស់ត្រូវបានបណ្តេញចេញ app: app-aលើកលែងតែពីរ។

នេះអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងថាតើកម្មវិធីប៉ុន្មានដែលគួរដំណើរការនៅពេលណាមួយនោះ។

កម្មវិធីតាមដានសុខភាព

ការត្រួតពិនិត្យបែបនេះគឺអាចធ្វើទៅបានតាមវិធីពីរយ៉ាង៖ ដោយប្រើតេស្ត Readiness ឬ Liveness ។

ការស៊ើបអង្កេតដំបូង (ការត្រៀមខ្លួន) កំណត់ការត្រៀមខ្លួនរបស់កុងតឺន័រក្នុងការទទួលចរាចរណ៍។

ទីពីរ (ភាពរស់រវើក) បង្ហាញថាតើកុងតឺន័រមានសុខភាពល្អ ឬចាំបាច់ត្រូវចាប់ផ្តើមឡើងវិញ។

ការកំណត់រចនាសម្ព័ន្ធពាក់ព័ន្ធត្រូវបានបន្ថែមយ៉ាងសាមញ្ញទៅ yaml សម្រាប់ដាក់ពង្រាយ។ នៅទីនោះ អ្នកអាចបញ្ជាក់ការអស់ពេល ពេលវេលាពន្យារពេល និងចំនួននៃការសាកល្បងឡើងវិញ។ មើលព័ត៌មានលម្អិតបន្ថែមអំពីពួកគេ។ ឯកសារ Kubernetes.

ស្លាកគឺនៅគ្រប់ទីកន្លែង

ស្លាកគឺជាគោលគំនិតជាមូលដ្ឋានមួយនៅក្នុង Kubernetes ។ ពួកវាអនុញ្ញាតឱ្យវត្ថុទាក់ទងគ្នាដោយសេរី ក៏ដូចជាបង្កើតសំណួរដោយផ្អែកលើស្លាក។ នៅក្នុង Kubernetes អ្នកថែមទាំងអាចទៅកាន់អតិថិជន និងមើលព្រឹត្តិការណ៍សម្រាប់ស្លាកជាក់លាក់។

អ្នកអាចធ្វើអ្វីៗស្ទើរតែទាំងអស់ជាមួយស្លាក ប៉ុន្តែឧទាហរណ៍ដ៏ល្អមួយគឺការបង្កើតបរិស្ថានជាច្រើនដើម្បីដំណើរការកម្មវិធីនៅលើចង្កោមតែមួយ។

ឧបមាថាអ្នកប្រើចង្កោមដូចគ្នាសម្រាប់ dev и qa. នេះមានន័យថាអ្នកអាចមានកម្មវិធី app-a, ក្នុងពេលដំណាលគ្នាធ្វើការនៅក្នុងបរិស្ថានទាំងពីរ qa и dev. ក្នុងករណីនេះ យើងអាចចូលប្រើឧទាហរណ៍កម្មវិធីដោយឡែកពីគ្នាក្នុងបរិយាកាសជាក់លាក់ដោយបញ្ជាក់ប៉ារ៉ាម៉ែត្រសមស្រប environment។ ឧទាហរណ៍។ app: app-a и environment: dev សម្រាប់បរិស្ថានតែមួយ និង app: app-a и environment: qa សម្រាប់ទីពីរ។

នេះអនុញ្ញាតឱ្យអ្នកចូលប្រើឧទាហរណ៍ទាំងពីរនៃកម្មវិធី ដើម្បីធ្វើការសាកល្បងក្នុងពេលដំណាលគ្នា។

រៀបចំ

Kubernetes គឺជាប្រព័ន្ធដែលមានថាមពលខ្លាំង ប៉ុន្តែប្រព័ន្ធណាមួយអាចក្លាយជាប្រព័ន្ធដែលជាប់គាំងជាមួយនឹងដំណើរការច្រើនពេក។ Kubelet ដំណើរការដំណើរការទាំងអស់ និងពិនិត្យដែលអ្នកបញ្ជាក់ ក៏ដូចជារបស់វាផ្ទាល់។

ជាការពិតណាស់ សេវាកុមារកំព្រាមួយនឹងមិនធ្វើឱ្យប្រព័ន្ធដំណើរការយឺតទេ ហើយ Kubernetes ត្រូវបានរចនាឡើងដើម្បីធ្វើមាត្រដ្ឋានពីមូលដ្ឋាន។ ប៉ុន្តែប្រសិនបើជំនួសឱ្យសេវាកម្មមួយលានលេចឡើង kubelet ចាប់ផ្តើមញាក់។

ប្រសិនបើហេតុផលមួយចំនួនដែលអ្នកលុបការដាក់ពង្រាយ (កុងតឺន័រ រូបភាព អ្វីក៏ដោយ) គ្រាន់តែត្រូវប្រាកដថាធ្វើការសម្អាតពេញលេញ។

ជួប Go

យើងបានរក្សាទុកដំបូន្មានសំខាន់សម្រាប់ចុងក្រោយ។ រៀនភាសាកម្មវិធី Go ។

Kubernetes ត្រូវបានបង្កើតឡើងនៅក្នុង Go ដែលផ្នែកបន្ថែមទាំងអស់ត្រូវបានសរសេរនៅក្នុង Go ហើយបណ្ណាល័យម៉ាស៊ីនភ្ញៀវទៅអតិថិជនក៏ត្រូវបានគាំទ្រជាផ្លូវការផងដែរ។

វា​អាច​ត្រូវ​បាន​ប្រើ​សម្រាប់​អ្វី​ផ្សេង​គ្នា​និង​គួរ​ឱ្យ​ចាប់​អារម្មណ៍​។ ឧទាហរណ៍ ដើម្បីពង្រីកប្រព័ន្ធ Kubernetes ទៅតាមរសជាតិរបស់អ្នក។ ដូច្នេះ អ្នកអាចប្រើកម្មវិធីផ្ទាល់ខ្លួនរបស់អ្នក ដើម្បីប្រមូលទិន្នន័យ ដាក់ពង្រាយកម្មវិធី ឬគ្រាន់តែសម្អាតធុង។

ការរៀនភាសាកម្មវិធី Go និងការធ្វើជាម្ចាស់លើអតិថិជនទៅគឺប្រហែលជាដំបូន្មានដ៏សំខាន់បំផុតដែលអ្នកអាចផ្តល់ឱ្យអ្នកប្រើប្រាស់ Kubernetes ថ្មី។

បកប្រែដោយមានការគាំទ្រពី Mail.ru Cloud Solutions

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

1. កម្រិតនៃការធ្វើមាត្រដ្ឋានដោយស្វ័យប្រវត្តិចំនួនបីនៅក្នុង Kubernetes និងរបៀបប្រើប្រាស់ពួកវាប្រកបដោយប្រសិទ្ធភាព.
2. ថ្នាំងកម្មករ Kubernetes៖ តូចជាច្រើន ឬធំពីរបី?
3. ឧបករណ៍មានប្រយោជន៍ចំនួន 25 សម្រាប់ដាក់ពង្រាយ និងគ្រប់គ្រង Kubernetes.

ប្រភព: www.habr.com