ប្រតិបត្តិករសម្រាប់ Kubernetes៖ របៀបដំណើរការកម្មវិធីដែលមានស្ថានភាព

បញ្ហាជាមួយកម្មវិធីដែលមានស្ថានភាពនៅក្នុង Kubernetes

ការកំណត់រចនាសម្ព័ន្ធ ការបើកដំណើរការ និងការធ្វើមាត្រដ្ឋានបន្ថែមទៀតនៃកម្មវិធី និងសេវាកម្មគឺមានភាពងាយស្រួលនៅពេលនិយាយអំពីករណីដែលត្រូវបានចាត់ថ្នាក់ថាគ្មានរដ្ឋ ពោលគឺឧ។ ដោយមិនរក្សាទុកទិន្នន័យ។ វាមានភាពងាយស្រួលក្នុងការដំណើរការសេវាកម្មបែបនេះនៅក្នុង Kubernetes ដោយប្រើ APIs ស្តង់ដាររបស់វា ពីព្រោះអ្វីៗកើតឡើង "ក្រៅប្រអប់"៖ យោងតាមការកំណត់ស្តង់ដារ ដោយមិនពាក់ព័ន្ធនឹងភាពជាក់លាក់ ឬវេទមន្តណាមួយឡើយ។

និយាយឱ្យសាមញ្ញ ដើម្បីបើកដំណើរការច្បាប់ចម្លងប្រាំបន្ថែមទៀតនៃផ្នែកខាងក្រោយនៅក្នុង PHP/Ruby/Python នៅក្នុងចង្កោមកុងតឺន័រ អ្នកគ្រាន់តែត្រូវដំឡើងម៉ាស៊ីនមេថ្មី 5 ដង និងចម្លងប្រភព។ ដោយសារទាំងកូដប្រភព និងស្គ្រីប init មាននៅក្នុងរូបភាព ការធ្វើមាត្រដ្ឋានកម្មវិធីដែលគ្មានរដ្ឋក្លាយជាបឋមទាំងស្រុង។ ក្នុងនាមជាអ្នកគាំទ្រនៃកុងតឺន័រ និងស្ថាបត្យកម្មមីក្រូសេវាកម្មដឹងច្បាស់ ការលំបាកចាប់ផ្តើមជាមួយ កម្មវិធីរដ្ឋ, i.e. ជាមួយនឹងទិន្នន័យជាប់លាប់ដូចជាមូលដ្ឋានទិន្នន័យ និងឃ្លាំងសម្ងាត់ (MySQL, PostgreSQL, Redis, ElasticSearch, Cassandra...)។ នេះអនុវត្តចំពោះកម្មវិធីទាំងពីរដែលអនុវត្តដោយឯករាជ្យនូវក្រុមកូរ៉ុម (ឧទាហរណ៍ Percona XtraDB និង Cassandra) និងកម្មវិធីដែលទាមទារឧបករណ៍ប្រើប្រាស់គ្រប់គ្រងដាច់ដោយឡែក (ដូចជា Redis, MySQL, PostgreSQL...)។

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

ប្រតិបត្តិករ CoreOS

ដើម្បី "កម្មវិធី" ចំនេះដឹងប្រតិបត្តិការនៅចុងឆ្នាំមុនគម្រោង CoreOS ណែនាំ "ថ្នាក់ថ្មីនៃកម្មវិធី" សម្រាប់វេទិកា Kubernetes - ប្រតិបត្តិករ (ពីភាសាអង់គ្លេស "ប្រតិបត្តិការ" ពោលគឺ "ប្រតិបត្តិការ") ។

ប្រតិបត្តិករប្រើប្រាស់ និងពង្រីកសមត្ថភាពស្នូលរបស់ Kubernetes (រួមទាំង។ សំណុំរដ្ឋសូមមើលភាពខុសគ្នាខាងក្រោម) អនុញ្ញាតឱ្យអ្នកឯកទេស DevOps បន្ថែមចំណេះដឹងប្រតិបត្តិការទៅកូដកម្មវិធី។

គោលបំណងរបស់ប្រតិបត្តិករ — ផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវ API ដែលអនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងអង្គភាពកម្មវិធីដែលមានស្ថានភាពច្រើននៅក្នុងចង្កោម Kubernetes ដោយមិនគិតពីអ្វីដែលស្ថិតនៅក្រោមក្រណាត់ (ទិន្នន័យអ្វី និងអ្វីដែលត្រូវធ្វើជាមួយវា តើពាក្យបញ្ជាអ្វីនៅតែត្រូវប្រតិបត្តិដើម្បីរក្សាចង្កោម។ ) តាមពិត ប្រតិបត្តិករត្រូវបានរចនាឡើងដើម្បីសម្រួលការងារជាមួយកម្មវិធីនៅក្នុងចង្កោមឱ្យបានច្រើនតាមដែលអាចធ្វើទៅបាន ដោយស្វ័យប្រវត្តិកម្មការប្រតិបត្តិនៃកិច្ចការប្រតិបត្តិការដែលពីមុនត្រូវដោះស្រាយដោយដៃ។

របៀបដែលប្រតិបត្តិករដំណើរការ

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

តើ​នេះ​ខុស​គ្នា​យ៉ាង​ណា សំណុំរដ្ឋរចនាឡើងសម្រាប់កម្មវិធីដែលតម្រូវឱ្យចង្កោមផ្តល់ឱ្យពួកគេនូវធនធានដែលមានសភាពដូចជាការផ្ទុកទិន្នន័យ ឬ IP ឋិតិវន្ត? សម្រាប់កម្មវិធីបែបនេះ ប្រតិបត្តិករអាចប្រើប្រាស់បាន។ សំណុំរដ្ឋ (ជំនួសឱ្យ ឈុតចម្លង) ជាមូលដ្ឋាន ផ្តល់ជូន ស្វ័យប្រវត្តិកម្មបន្ថែម៖ អនុវត្តសកម្មភាពចាំបាច់ក្នុងករណីគាំង ធ្វើការបម្រុងទុក ធ្វើបច្ចុប្បន្នភាពការកំណត់រចនាសម្ព័ន្ធ។ល។

ហើយដូច្នេះ, តើទាំងអស់នេះដំណើរការយ៉ាងដូចម្តេច? ប្រតិបត្តិករគឺជាដេមិនអ្នកគ្រប់គ្រងដែល៖

1. ជាវប្រចាំទៅ API ព្រឹត្តិការណ៍នៅក្នុង Kubernetes;
2. ទទួលពីវាទិន្នន័យអំពីប្រព័ន្ធ (អំពីរបស់វា។ ឈុតចម្លង, ផ្លែកួរ, សេវាកម្ម ល​ល។);
3. ទទួលទិន្នន័យអំពី ធនធានភាគីទីបី (សូមមើលឧទាហរណ៍ខាងក្រោម);
4. ប្រតិកម្មទៅនឹងរូបរាង / ការផ្លាស់ប្តូរ ធនធានភាគីទីបី (ឧទាហរណ៍ ដើម្បីផ្លាស់ប្តូរទំហំ ផ្លាស់ប្តូរកំណែ ហើយដូច្នេះនៅលើ);
5. ប្រតិកម្មទៅនឹងការផ្លាស់ប្តូរនៅក្នុងស្ថានភាពនៃប្រព័ន្ធ (អំពីរបស់វា។ ឈុតចម្លង, ផ្លែកួរ, សេវាកម្ម ល​ល។);
6. សំខាន់​បំផុត:
   1. អំពាវនាវនៅលើ Kubernetes API ដើម្បីបង្កើតអ្វីគ្រប់យ៉ាងដែលវាត្រូវការ (ម្តងទៀត របស់វាផ្ទាល់ ឈុតចម្លង, ផ្លែកួរ, សេវាកម្ម... ),
   2. អនុវត្តវេទមន្តមួយចំនួន (ដើម្បីសម្រួល អ្នកអាចគិតថា Operator ចូលទៅក្នុង pods ដោយខ្លួនឯង ហើយហៅពាក្យបញ្ជា ឧទាហរណ៍ ដើម្បីចូលរួមជាមួយ cluster ឬ upgrade format ទិន្នន័យនៅពេល update version)។

តាមពិត ដូចដែលអាចមើលឃើញពីរូបភាព កម្មវិធីដាច់ដោយឡែកមួយត្រូវបានបន្ថែមយ៉ាងសាមញ្ញទៅ Kubernetes (ធម្មតា។ ការដាក់ពង្រាយ с សំណុំចម្លង) ដែលត្រូវបានគេហៅថាប្រតិបត្តិករ។ វារស់នៅក្នុងផើងធម្មតាមួយ (ជាធម្មតាតែមួយ) ហើយជាក្បួនគឺទទួលខុសត្រូវចំពោះតែរបស់វា។ ចន្លោះឈ្មោះ. កម្មវិធីប្រតិបត្តិករនេះអនុវត្ត API របស់វា - ទោះបីជាមិនមែនដោយផ្ទាល់ ប៉ុន្តែតាមរយៈ ធនធានភាគីទីបី នៅ Kubernetes ។

ដូច្នេះបន្ទាប់ពីយើងបានបង្កើត ចន្លោះឈ្មោះ ប្រតិបត្តិករ យើងអាចបន្ថែមទៅវាបាន ធនធានភាគីទីបី.

ឧទាហរណ៍សម្រាប់ ល។ (សូមមើលខាងក្រោមសម្រាប់ព័ត៌មានលម្អិត):

apiVersion: etcd.coreos.com/v1beta1
kind: Cluster
metadata:
  name: example-etcd-cluster
spec:
  size: 3
  version: 3.1.0

ឧទាហរណ៍សម្រាប់ Elasticsearch៖

apiVersion: enterprises.upmc.com/v1
kind: ElasticsearchCluster
metadata:
  name: example-es-cluster
spec:
  client-node-replicas: 3
  master-node-replicas: 2
  data-node-replicas: 3
  zones:
  - us-east-1c
  - us-east-1d
  - us-east-1e
  data-volume-size: 10Gi
  java-options: "-Xms1024m -Xmx1024m"
  snapshot:
    scheduler-enabled: true
    bucket-name: elasticsnapshots99
    cron-schedule: "@every 2m"
  storage:
    type: gp2
    storage-class-provisioner: kubernetes.io/aws-ebs

តម្រូវការសម្រាប់ប្រតិបត្តិករ

CoreOS បានបង្កើតលំនាំសំខាន់ៗដែលទទួលបានដោយវិស្វករ នៅពេលធ្វើការលើ Operators។ ទោះបីជាការពិតដែលថាប្រតិបត្តិករទាំងអស់មានលក្ខណៈបុគ្គល (ត្រូវបានបង្កើតឡើងសម្រាប់កម្មវិធីជាក់លាក់មួយដែលមានលក្ខណៈ និងតម្រូវការផ្ទាល់របស់វា) ការបង្កើតរបស់ពួកគេត្រូវតែផ្អែកលើប្រភេទនៃក្របខ័ណ្ឌដែលកំណត់តម្រូវការដូចខាងក្រោមៈ

1. ការដំឡើងត្រូវតែធ្វើឡើងតាមរយៈតែមួយ ការដាក់ពង្រាយ: kubectl បង្កើត -f SOME_OPERATOR_URL/deployment.yaml - ហើយមិនត្រូវការសកម្មភាពបន្ថែមទេ។
2. នៅពេលដំឡើងប្រតិបត្តិករនៅក្នុង Kubernetes ប្រភេទភាគីទីបីថ្មីត្រូវតែត្រូវបានបង្កើត (ធនធានភាគីទីបី). ដើម្បីបើកដំណើរការកម្មវិធី (cluster instances) និងគ្រប់គ្រងពួកវាបន្ថែមទៀត (ការធ្វើបច្ចុប្បន្នភាពកំណែ ផ្លាស់ប្តូរទំហំ។ល។) អ្នកប្រើប្រាស់នឹងប្រើប្រភេទនេះ។
3. នៅពេលណាដែលអាចធ្វើទៅបាន អ្នកគួរតែប្រើបុព្វបទដែលបានបង្កើតឡើងនៅក្នុង Kubernetes ដូចជា សេវាកម្ម и ឈុតចម្លងដើម្បីប្រើកូដដែលបានសាកល្បង និងអាចយល់បាន។
4. ទាមទារភាពឆបគ្នាថយក្រោយរបស់ប្រតិបត្តិករ និងការគាំទ្រសម្រាប់កំណែចាស់នៃធនធានដែលបង្កើតឡើងដោយអ្នកប្រើប្រាស់។
5. ប្រសិនបើប្រតិបត្តិករត្រូវបានដកចេញ កម្មវិធីខ្លួនវាគួរតែបន្តដំណើរការដោយគ្មានការផ្លាស់ប្តូរ។
6. អ្នកប្រើប្រាស់គួរតែអាចកំណត់កំណែកម្មវិធីដែលចង់បាន និងរៀបចំការអាប់ដេតកំណែកម្មវិធី។ កង្វះការអាប់ដេតកម្មវិធីគឺជាប្រភពទូទៅនៃបញ្ហាប្រតិបត្តិការ និងសុវត្ថិភាព ដូច្នេះប្រតិបត្តិករត្រូវតែជួយអ្នកប្រើប្រាស់ក្នុងបញ្ហានេះ។
7. ប្រតិបត្តិករគួរតែត្រូវបានសាកល្បងដោយប្រើឧបករណ៍ដូចជា Chaos Monkey ដែលកំណត់ការបរាជ័យដែលអាចកើតមាននៅក្នុងផត ការកំណត់ និងបណ្តាញ។

ប្រតិបត្តិករ etcd

ឧទាហរណ៍នៃការអនុវត្តប្រតិបត្តិករ - ប្រតិបត្តិករ etcd, រៀបចំ នៅថ្ងៃប្រកាសនៃគំនិតនេះ។ ការកំណត់រចនាសម្ព័ន្ធ cluster etcd អាចស្មុគស្មាញដោយសារតម្រូវការរក្សាកូរ៉ុម តម្រូវការក្នុងការកំណត់រចនាសម្ព័ន្ធសមាជិកក្រុមឡើងវិញ បង្កើតការបម្រុងទុក។ល។ ឧទាហរណ៍ ការធ្វើមាត្រដ្ឋាន ចង្កោម etcd ដោយដៃមានន័យថា អ្នកត្រូវបង្កើតឈ្មោះ DNS សម្រាប់សមាជិកចង្កោមថ្មី ចាប់ផ្តើមអង្គភាព etcd ថ្មី និងជូនដំណឹងដល់ចង្កោមអំពីសមាជិកថ្មី (បន្ថែមសមាជិក etcdctl) ក្នុងករណីនៃប្រតិបត្តិករ អ្នកប្រើប្រាស់នឹងត្រូវការផ្លាស់ប្តូរទំហំចង្កោមតែប៉ុណ្ណោះ - អ្វីៗផ្សេងទៀតនឹងកើតឡើងដោយស្វ័យប្រវត្តិ។

ហើយចាប់តាំងពី etcd ត្រូវបានបង្កើតឡើងផងដែរនៅក្នុង CoreOS វាពិតជាឡូជីខលណាស់ក្នុងការឃើញ Operator របស់វាបង្ហាញខ្លួនជាលើកដំបូង។ តើគាត់ធ្វើការយ៉ាងដូចម្តេច? តក្កវិជ្ជាប្រតិបត្តិករ ល។ ត្រូវបានកំណត់ដោយសមាសធាតុបី៖

1. សង្កេត។ ប្រតិបត្តិករត្រួតពិនិត្យស្ថានភាពនៃចង្កោមដោយប្រើ Kubernetes API ។
2. ការវិភាគ។ ស្វែងរកភាពខុសគ្នារវាងស្ថានភាពបច្ចុប្បន្ន និងស្ថានភាពដែលអ្នកចង់បាន (កំណត់ដោយការកំណត់រចនាសម្ព័ន្ធអ្នកប្រើប្រាស់)។
3. សកម្មភាព។ ដោះស្រាយភាពខុសគ្នាដែលបានរកឃើញដោយប្រើ APIs សេវាកម្ម etcd និង/ឬ Kubernetes ។

ដើម្បីអនុវត្តតក្កវិជ្ជានេះ មុខងារត្រូវបានរៀបចំនៅក្នុងប្រតិបត្តិករ បង្កើត/បំផ្លាញ (បង្កើត និងលុបសមាជិកក្រុម etcd) និង ប្ដូរទំហំ (ការផ្លាស់ប្តូរចំនួនសមាជិកក្រុម) ។ ភាពត្រឹមត្រូវនៃប្រតិបត្តិការរបស់វាត្រូវបានត្រួតពិនិត្យដោយប្រើឧបករណ៍ប្រើប្រាស់ដែលបានបង្កើតឡើងក្នុងលក្ខណៈនៃ Chaos Monkey ពី Netflix ពោលគឺឧ។ ការសម្លាប់ផ្សិត etcd ដោយចៃដន្យ។

សម្រាប់ប្រតិបត្តិការពេញលេញនៃ etcd ប្រតិបត្តិករផ្តល់នូវលក្ខណៈពិសេសបន្ថែម៖ បម្រុងទុក (ដោយស្វ័យប្រវត្តិ និងមើលមិនឃើញចំពោះអ្នកប្រើប្រាស់ ការបង្កើតច្បាប់ចម្លងបម្រុងទុក - នៅក្នុងការកំណត់រចនាសម្ព័ន្ធ វាគ្រប់គ្រាន់ដើម្បីកំណត់ថាតើត្រូវបង្កើតវាញឹកញាប់ប៉ុណ្ណា និងចំនួនប៉ុន្មានដែលត្រូវរក្សាទុក - និងការស្ដារឡើងវិញនូវទិន្នន័យពីពួកគេជាបន្តបន្ទាប់) និង ធ្វើឱ្យប្រសើរឡើង (ធ្វើបច្ចុប្បន្នភាពការដំឡើង etcd ដោយគ្មានពេលវេលារងចាំ) ។

តើការធ្វើការជាមួយប្រតិបត្តិករមើលទៅដូចអ្វី?

$ kubectl create -f https://coreos.com/operators/etcd/latest/deployment.yaml
$ kubectl create -f https://coreos.com/operators/etcd/latest/example-etcd-cluster.yaml
$ kubectl get pods
NAME                             READY     STATUS    RESTARTS   AGE
etcd-cluster-0000                1/1       Running   0          23s
etcd-cluster-0001                1/1       Running   0          16s
etcd-cluster-0002                1/1       Running   0          8s
etcd-cluster-backup-tool-rhygq   1/1       Running   0          18s

ស្ថានភាពបច្ចុប្បន្នរបស់ប្រតិបត្តិករ etcd គឺជាកំណែបែតា ដែលទាមទារ Kubernetes 1.5.3+ និង etcd 3.0+ ដើម្បីដំណើរការ។ កូដប្រភព និងឯកសារ (រួមទាំងការណែនាំសម្រាប់ការប្រើប្រាស់) មាននៅ GitHub.

ការអនុវត្តឧទាហរណ៍មួយទៀតពី CoreOS ត្រូវបានបង្កើតឡើង - ប្រតិបត្តិករ Prometheusប៉ុន្តែវានៅតែស្ថិតក្នុងកំណែអាល់ហ្វា (មិនមែនមុខងារដែលបានគ្រោងទុកទាំងអស់ត្រូវបានអនុវត្តទេ)។

ស្ថានភាព និងការរំពឹងទុក

5 ខែបានកន្លងផុតទៅចាប់តាំងពីការប្រកាសរបស់ប្រតិបត្តិករ Kubernetes ។ នៅតែមានការអនុវត្តពីរប៉ុណ្ណោះដែលមាននៅក្នុងឃ្លាំង CoreOS ផ្លូវការ (សម្រាប់ etcd និង Prometheus) ។ ទាំងពីរមិនទាន់ឈានដល់កំណែថេររបស់ពួកគេនៅឡើយទេ ប៉ុន្តែការប្តេជ្ញាចិត្តត្រូវបានអង្កេតជារៀងរាល់ថ្ងៃ។

អ្នកអភិវឌ្ឍន៍ស្រមៃថា "អនាគតដែលអ្នកប្រើប្រាស់ដំឡើងកម្មវិធី Postgres Operators Cassandra Operators ឬ Redis Operators នៅលើចង្កោម Kubernetes របស់ពួកគេ ហើយធ្វើការជាមួយអង្គភាពដែលអាចធ្វើមាត្រដ្ឋានបាននៃកម្មវិធីទាំងនេះយ៉ាងងាយស្រួលដូចការដាក់ពង្រាយកម្មវិធីចម្លងនៃកម្មវិធីបណ្តាញគ្មានរដ្ឋគឺសព្វថ្ងៃនេះ។" ទីមួយ ប្រតិបត្តិករពីអ្នកអភិវឌ្ឍន៍ភាគីទីបី ពិតជាចាប់ផ្តើមលេចឡើង៖

• ប្រតិបត្តិករ Elasticsearch ពីសហគ្រាស UPMC;
• ប្រតិបត្តិករ PostgreSQL ពីទិន្នន័យ Crunchy (បានប្រកាសនៅចុងខែមីនា 2017);
• ប្រតិបត្តិករ Rook ពីអ្នកនិពន្ធនៃប្រព័ន្ធផ្ទុកទិន្នន័យចែកចាយដោយផ្អែកលើ Ceph (Rook ស្ថិតក្នុងស្ថានភាពអាល់ហ្វា);
• ប្រតិបត្តិករ Openstack ពី SAP CCloud ។

នៅឯសន្និសីទកម្មវិធីឥតគិតថ្លៃដ៏ធំបំផុតរបស់អឺរ៉ុប FOSDEM ដែលបានធ្វើឡើងក្នុងខែកុម្ភៈ ឆ្នាំ 2017 នៅទីក្រុងប្រ៊ុចសែល លោក Josh Wood មកពី CoreOS បានប្រកាសថា ប្រតិបត្តិករនៅក្នុង របាយការណ៍ (វីដេអូមាននៅតំណ!) ដែលគួរតែរួមចំណែកដល់ការរីកលូតលាស់នៃប្រជាប្រិយភាពនៃគំនិតនេះនៅក្នុងសហគមន៍ប្រភពបើកចំហកាន់តែទូលំទូលាយ។

PS សូមអរគុណចំពោះការចាប់អារម្មណ៍របស់អ្នកនៅក្នុងអត្ថបទ! ជាវទៅកាន់មជ្ឈមណ្ឌលរបស់យើង។ដើម្បីកុំឱ្យខកខានសម្ភារ និងរូបមន្តថ្មីៗនៅលើការគ្រប់គ្រងប្រព័ន្ធ DevOps និង GNU/Linux - យើងនឹងផ្សព្វផ្សាយវាជាប្រចាំ!

ប្រភព: www.habr.com