ការអាប់ដេតចង្កោម Kubernetes ដោយគ្មានពេលទំនេរ

ដំណើរការធ្វើឱ្យប្រសើរឡើងសម្រាប់ក្រុម Kubernetes របស់អ្នក។

នៅចំណុចខ្លះ នៅពេលប្រើចង្កោម Kubernetes ចាំបាច់ត្រូវធ្វើបច្ចុប្បន្នភាពថ្នាំងដែលកំពុងដំណើរការ។ នេះអាចរួមបញ្ចូលការអាប់ដេតកញ្ចប់ ការធ្វើបច្ចុប្បន្នភាពខឺណែល ឬការដាក់ឱ្យប្រើប្រាស់រូបភាពម៉ាស៊ីននិម្មិតថ្មី។ នៅក្នុងវាក្យស័ព្ទ Kubernetes នេះត្រូវបានគេហៅថា "ការរំខានដោយស្ម័គ្រចិត្ត".

ប្រកាសនេះគឺជាផ្នែកមួយនៃស៊េរី 4 ប្រកាស:

1. ប្រកាសនេះ។
2. ការបិទ pods ត្រឹមត្រូវនៅក្នុងចង្កោម Kubernetes
3. ការពន្យាពេលនៃការបញ្ចប់ផតនៅពេលដែលវាត្រូវបានលុប
4. វិធីជៀសវាងការឈប់សម្រាករបស់ Kubernetes Cluster ដោយប្រើ PodDisruptionBudgets

(ប្រហែល។ រំពឹងថាការបកប្រែអត្ថបទដែលនៅសល់ក្នុងស៊េរីនាពេលខាងមុខ)

នៅក្នុងអត្ថបទនេះ យើងនឹងពណ៌នាអំពីឧបករណ៍ទាំងអស់ដែល Kubernetes ផ្ដល់ឱ្យ ដើម្បីសម្រេចបាននូវពេលវេលាឈប់សម្រាកសូន្យសម្រាប់ថ្នាំងដែលកំពុងដំណើរការនៅក្នុងចង្កោមរបស់អ្នក។

កំណត់បញ្ហា

យើងនឹងប្រើវិធីសាស្រ្តឆោតល្ងង់នៅពេលដំបូង កំណត់បញ្ហា និងវាយតម្លៃហានិភ័យដែលអាចកើតមាននៃវិធីសាស្រ្តនេះ និងបង្កើតចំណេះដឹងដើម្បីដោះស្រាយបញ្ហានីមួយៗដែលយើងជួបប្រទះពេញមួយវដ្ត។ លទ្ធផលគឺជាការកំណត់រចនាសម្ព័ន្ធដែលប្រើទំពក់នៃវដ្តជីវិត ការស៊ើបអង្កេតការត្រៀមខ្លួន និងថវិការរំខាន Pod ដើម្បីសម្រេចបាននូវគោលដៅគ្មានពេលទំនេររបស់យើង។

ដើម្បីចាប់ផ្តើមដំណើររបស់យើង សូមលើកឧទាហរណ៍ជាក់ស្តែងមួយ។ ចូរនិយាយថាយើងមានចង្កោម Kubernetes នៃ nodes ពីរ ដែលកម្មវិធីមួយកំពុងដំណើរការជាមួយ pods ពីរដែលមានទីតាំងនៅខាងក្រោយ Service:

ចូរចាប់ផ្តើមជាមួយនឹងផតចំនួនពីរជាមួយ Nginx និងសេវាកម្មដែលដំណើរការលើថ្នាំងចង្កោម Kubernetes ពីររបស់យើង។

យើងចង់ធ្វើបច្ចុប្បន្នភាពកំណែខឺណែលនៃថ្នាំងកម្មករពីរនៅក្នុងចង្កោមរបស់យើង។ តើ​យើង​ធ្វើ​បែប​នេះ​ដោយ​របៀប​ណា? ដំណោះស្រាយដ៏សាមញ្ញមួយគឺការចាប់ផ្ដើមថ្នាំងថ្មីជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធដែលបានធ្វើបច្ចុប្បន្នភាព ហើយបន្ទាប់មកបិទថ្នាំងចាស់ខណៈពេលចាប់ផ្តើមថ្នាំងថ្មី។ ខណៈពេលដែលវានឹងដំណើរការ វានឹងមានបញ្ហាមួយចំនួនជាមួយនឹងវិធីសាស្រ្តនេះ៖

• នៅពេលអ្នកបិទថ្នាំងចាស់ ផតដែលដំណើរការលើពួកវាក៏នឹងត្រូវបានបិទផងដែរ។ តើមានអ្វីប្រសិនបើ pods ត្រូវការសម្អាតសម្រាប់ការបិទយ៉ាងប្រណិត? ប្រព័ន្ធនិម្មិតដែលអ្នកកំពុងប្រើប្រហែលជាមិនរង់ចាំដំណើរការសម្អាតបញ្ចប់នោះទេ។
• ចុះបើអ្នកបិទថ្នាំងទាំងអស់ក្នុងពេលតែមួយ? អ្នក​នឹង​ទទួល​បាន​ពេល​វេលា​ឈប់​សម្រាក​សមរម្យ​ខណៈ​ពេល​ដែល​ផតឃែរ​ផ្លាស់ទី​ទៅ​ថ្នាំង​ថ្មី។

យើងត្រូវការវិធីមួយដើម្បីផ្ទេរ pods ពីថ្នាំងចាស់ដោយរលូន ខណៈពេលដែលធានាថាគ្មានដំណើរការរបស់កម្មកររបស់យើងកំពុងដំណើរការ ខណៈពេលដែលយើងធ្វើការផ្លាស់ប្តូរទៅ node ។ ឬនៅពេលដែលយើងធ្វើការជំនួសពេញលេញនៃចង្កោមដូចក្នុងឧទាហរណ៍ (នោះគឺយើងជំនួសរូបភាព VM) យើងចង់ផ្ទេរកម្មវិធីដែលកំពុងដំណើរការពីថ្នាំងចាស់ទៅថ្មី។ ក្នុងករណីទាំងពីរនេះ យើងចង់ទប់ស្កាត់ផតថលថ្មីពីការកំណត់ពេលនៅលើថ្នាំងចាស់ ហើយបន្ទាប់មកបណ្តេញផតដែលកំពុងដំណើរការទាំងអស់ចេញពីពួកវា។ ដើម្បីសម្រេចបាននូវគោលដៅទាំងនេះ យើងអាចប្រើពាក្យបញ្ជាបាន។ kubectl drain.

ការចែកចាយផតទាំងអស់ឡើងវិញពីថ្នាំង

ប្រតិបត្តិការបង្ហូរអនុញ្ញាតឱ្យអ្នកចែកចាយផតទាំងអស់ឡើងវិញពីថ្នាំង។ កំឡុងពេលដំណើរការបង្ហូរ ថ្នាំងត្រូវបានសម្គាល់ថាមិនអាចកំណត់ពេលបាន (ទង់ NoSchedule) នេះរារាំងផតថលថ្មីមិនឱ្យលេចឡើងនៅលើវា។ បន្ទាប់មកបង្ហូរចាប់ផ្តើមបណ្តេញ pods ចេញពីថ្នាំង បិទកុងតឺន័រដែលកំពុងដំណើរការនៅលើថ្នាំង បញ្ជូនសញ្ញា TERM ធុងនៅក្នុងផើងមួយ។

ទោះបីជា kubectl drain នឹងធ្វើការងារដ៏ល្អក្នុងការបណ្តេញចេញ មានកត្តាពីរផ្សេងទៀតដែលអាចបណ្តាលឱ្យប្រតិបត្តិការបង្ហូរមិនដំណើរការ៖

• ពាក្យសុំរបស់អ្នកត្រូវតែអាចបញ្ចប់ដោយរលូននៅពេលដាក់ស្នើ TERM សញ្ញា។ នៅពេលដែលផតត្រូវបានបណ្តេញចេញ Kubernetes បញ្ជូនសញ្ញាមួយ។ TERM កុងតឺន័រ ហើយរង់ចាំឱ្យពួកគេឈប់ក្នុងរយៈពេលកំណត់មួយ បន្ទាប់មកប្រសិនបើពួកគេមិនបានឈប់ទេ វាបញ្ឈប់ពួកវាដោយបង្ខំ។ ក្នុងករណីណាក៏ដោយ ប្រសិនបើកុងតឺន័ររបស់អ្នកមិនយល់ឃើញសញ្ញាត្រឹមត្រូវ អ្នកនៅតែអាចពន្លត់ផតថលមិនត្រឹមត្រូវ ប្រសិនបើពួកវាកំពុងដំណើរការ (ឧទាហរណ៍ ប្រតិបត្តិការមូលដ្ឋានទិន្នន័យកំពុងដំណើរការ)។
• អ្នកបាត់បង់ផតទាំងអស់ដែលមានកម្មវិធីរបស់អ្នក។ វាប្រហែលជាមិនមានទេ នៅពេលដែលធុងថ្មីត្រូវបានដាក់ឱ្យដំណើរការនៅលើថ្នាំងថ្មី ឬប្រសិនបើផតរបស់អ្នកត្រូវបានដាក់ឱ្យប្រើប្រាស់ដោយគ្មានឧបករណ៍បញ្ជា ពួកវាប្រហែលជាមិនចាប់ផ្តើមឡើងវិញទាល់តែសោះ។

ជៀសវាងការឈប់សម្រាក

ដើម្បីកាត់បន្ថយពេលវេលារងចាំពីការរំខានដោយស្ម័គ្រចិត្ត ដូចជាពីប្រតិបត្តិការបង្ហូរនៅលើថ្នាំង Kubernetes ផ្តល់នូវជម្រើសដោះស្រាយការបរាជ័យដូចខាងក្រោម៖

• ការបញ្ចប់ប្រកបដោយគុណធម៌
• ទំពក់ជីវិត
• PodDisruptionBudgets

នៅក្នុងស៊េរីដែលនៅសល់ យើងនឹងប្រើលក្ខណៈពិសេស Kubernetes ទាំងនេះ ដើម្បីកាត់បន្ថយផលប៉ះពាល់នៃការផ្ទេរ pod ។ ដើម្បីធ្វើឱ្យវាកាន់តែងាយស្រួលក្នុងការធ្វើតាមគំនិតចម្បង យើងនឹងប្រើឧទាហរណ៍របស់យើងខាងលើជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធធនធានដូចខាងក្រោម៖

---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx-deployment
 labels:
   app: nginx
spec:
 replicas: 2
 selector:
   matchLabels:
     app: nginx
 template:
   metadata:
     labels:
       app: nginx
   spec:
     containers:
     - name: nginx
       image: nginx:1.15
       ports:
       - containerPort: 80
---
kind: Service
apiVersion: v1
metadata:
 name: nginx-service
spec:
 selector:
   app: nginx
 ports:
 - protocol: TCP
   targetPort: 80
   port: 80

ការកំណត់រចនាសម្ព័ន្ធនេះគឺជាឧទាហរណ៍តិចតួចបំផុត។ Deploymentដែលគ្រប់គ្រង nginx pods នៅក្នុង cluster ។ លើសពីនេះ ការកំណត់រចនាសម្ព័ន្ធពិពណ៌នាអំពីធនធាន Serviceដែលអាចត្រូវបានប្រើដើម្បីចូលប្រើ nginx pods នៅក្នុង cluster ។

ពេញមួយវដ្ត យើងនឹងពង្រីកការកំណត់នេះម្តងហើយម្តងទៀត ដើម្បីអោយវារួមបញ្ចូលនូវសមត្ថភាពទាំងអស់ដែល Kubernetes ផ្តល់អោយ ដើម្បីកាត់បន្ថយពេលវេលារងចាំ។

សម្រាប់កំណែដែលបានអនុវត្ត និងសាកល្បងពេញលេញនៃការអាប់ដេតចង្កោម Kubernetes សម្រាប់គ្មានពេលទំនេរនៅលើ AWS និងលើសពីនេះ សូមចូលទៅកាន់ Gruntwork.io.

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

• ការដាក់ពង្រាយពេលមិនដំណើរការ និងមូលដ្ឋានទិន្នន័យ
• Kubernetes៖ ហេតុអ្វីបានជាវាមានសារៈសំខាន់ខ្លាំងណាស់ក្នុងការកំណត់រចនាសម្ព័ន្ធការគ្រប់គ្រងធនធានប្រព័ន្ធ?
• បំពង់ Tekton - បំពង់បង្ហូរប្រេងដើម Kubernetes
• ការកសាងម៉ូឌុលថាមវន្តសម្រាប់ Nginx
• ការណែនាំអំពីការអនុញ្ញាត Kubernetes របស់កុងស៊ុល Hashicorp
• តើការធ្វើចំណាកស្រុកពី ClickHouse ដោយគ្មានការអនុញ្ញាតទៅ ClickHouse ជាមួយនឹងការអនុញ្ញាតនាំទៅរកអ្វី?

ប្រភព: www.habr.com