ត្រឡប់ទៅ សេវាមីក្រូ ជាមួយ Istio ។ ផ្នែកទី 1

ចំណាំ។ បកប្រែ៖ សំណាញ់សេវាកម្មពិតជាបានក្លាយទៅជាដំណោះស្រាយដែលពាក់ព័ន្ធនៅក្នុងហេដ្ឋារចនាសម្ព័ន្ធទំនើបសម្រាប់កម្មវិធីបន្ទាប់ពីស្ថាបត្យកម្មមីក្រូសេវាកម្ម។ ខណៈពេលដែល Istio អាចនឹងស្ថិតនៅលើបបូរមាត់របស់វិស្វករ DevOps ជាច្រើន វាគឺជាផលិតផលថ្មីគួរសម ដែលខណៈពេលដែលមានភាពទូលំទូលាយនៅក្នុងលក្ខខណ្ឌនៃសមត្ថភាពដែលវាផ្តល់ឱ្យ អាចត្រូវការពេលវេលាច្រើនដើម្បីស្គាល់។ វិស្វករជនជាតិអាឡឺម៉ង់ Rinor Maloku ដែលជាអ្នកទទួលខុសត្រូវលើការ cloud computing សម្រាប់អតិថិជនធំៗនៅក្រុមហ៊ុនទូរគមនាគមន៍ Orange Networks បានសរសេរស៊េរីសម្ភារៈដ៏អស្ចារ្យដែលអនុញ្ញាតឱ្យអ្នកជ្រមុជទឹកចូលទៅក្នុង Istio យ៉ាងរហ័ស និងជ្រៅ។ គាត់ចាប់ផ្តើមរឿងរបស់គាត់ជាមួយនឹងអ្វីដែល Istio អាចធ្វើបានជាទូទៅ និងរបៀបដែលអ្នកអាចមើលឃើញវាភ្លាមៗដោយភ្នែករបស់អ្នក។

អ៊ីស៊ីអូ - គម្រោងប្រភពបើកចំហដែលត្រូវបានបង្កើតឡើងដោយសហការជាមួយក្រុមមកពី Google, IBM និង Lyft ។ វាដោះស្រាយភាពស្មុគ្រស្មាញដែលកើតឡើងនៅក្នុងកម្មវិធីដែលមានមូលដ្ឋានលើ microservices ដូចជា៖

• ការគ្រប់គ្រងចរាចរណ៍៖ អស់ពេល, ព្យាយាម, ផ្ទុកតុល្យភាព;
• សន្តិសុខ៖ ការផ្ទៀងផ្ទាត់អ្នកប្រើប្រាស់ចុងក្រោយ និងការអនុញ្ញាតិ;
• ការសង្កេត៖ តាមដាន, ត្រួតពិនិត្យ, កត់ត្រា។

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

អ្នក​គ្រប់​គ្រង​គម្រោង៖ តើ​ត្រូវ​ចំណាយ​ពេល​ប៉ុន្មាន​ដើម្បី​បន្ថែម​លក្ខណៈ​ពិសេស​មតិ​កែលម្អ?
អ្នកអភិវឌ្ឍន៍៖ រត់ពីរ។

MP: ស្អី?.. វាគ្រាន់តែជា CRUD!
R: ការធ្វើ CRUD គឺជាផ្នែកមួយដ៏ងាយស្រួល ប៉ុន្តែយើងនៅតែត្រូវការផ្ទៀងផ្ទាត់ និងផ្តល់សិទ្ធិដល់អ្នកប្រើប្រាស់ និងសេវាកម្ម។ ដោយសារបណ្តាញមិនគួរឱ្យទុកចិត្ត អ្នកនឹងត្រូវអនុវត្តសំណើម្តងហើយម្តងទៀត ក៏ដូចជា លំនាំបំបែកសៀគ្វី នៅក្នុងអតិថិជន។ ដូចគ្នានេះផងដែរដើម្បីធ្វើឱ្យប្រាកដថាប្រព័ន្ធទាំងមូលមិនគាំងអ្នកនឹងត្រូវការការអស់ពេលនិង រនាំង (សម្រាប់ព័ត៌មានលម្អិតបន្ថែមអំពីគំរូដែលបានរៀបរាប់ទាំងពីរ សូមមើលនៅពេលក្រោយក្នុងអត្ថបទ - ប្រហាក់ប្រហែល។ បកប្រែ។ )ហើយដើម្បីស្វែងរកបញ្ហា ការត្រួតពិនិត្យ តាមដាន […]

សមាជិកសភា៖ អូ អញ្ចឹងតោះបញ្ចូលមុខងារនេះទៅក្នុងសេវាកម្មផលិតផល។

ខ្ញុំ​គិត​ថា​គំនិត​នេះ​ច្បាស់​ណាស់៖ ចំនួន​ជំហាន​និង​ការ​ខិត​ខំ​ប្រឹង​ប្រែង​ដែល​ទាមទារ​ដើម្បី​បន្ថែម​សេវា​មួយ​គឺ​ធំ​សម្បើម។ នៅក្នុងអត្ថបទនេះ យើងនឹងពិនិត្យមើលពីរបៀបដែល Istio ដកចេញនូវភាពស្មុគស្មាញទាំងអស់ដែលបានរៀបរាប់ខាងលើ (ដែលមិនមានបំណងជាតក្កវិជ្ជាអាជីវកម្ម) ពីសេវាកម្ម។

ការកត់សម្គាល់៖ អត្ថបទនេះសន្មត់ថាអ្នកមានចំណេះដឹងការងាររបស់ Kubernetes ។ បើមិនដូច្នោះទេខ្ញុំសូមណែនាំឱ្យអាន ការណែនាំរបស់ខ្ញុំចំពោះ Kubernetes ហើយមានតែបន្ទាប់ពីនោះបន្តអានសម្ភារៈនេះ។

គំនិត

នៅក្នុងពិភពលោកដែលគ្មាន Istio សេវាកម្មមួយធ្វើសំណើដោយផ្ទាល់ទៅមួយផ្សេងទៀត ហើយក្នុងករណីមានការបរាជ័យ សេវាកម្មត្រូវតែដោះស្រាយដោយខ្លួនឯង៖ ធ្វើការប៉ុនប៉ងថ្មី ផ្តល់ពេលវេលាអស់ពេល បើកឧបករណ៍បំប្លែងសៀគ្វី។ល។

ចរាចរណ៍បណ្តាញនៅក្នុង Kubernetes

Istio ផ្តល់នូវដំណោះស្រាយឯកទេស បំបែកទាំងស្រុងពីសេវាកម្ម និងដំណើរការដោយការរំខានដល់ការទំនាក់ទំនងបណ្តាញ។ ហើយដូច្នេះវាអនុវត្ត៖

• ការអត់ធ្មត់កំហុស៖ ដោយផ្អែកលើលេខកូដស្ថានភាពនៅក្នុងការឆ្លើយតប វាយល់ថាតើសំណើនេះបរាជ័យហើយឬអត់ ហើយដំណើរការវាឡើងវិញ។
• ការចេញផ្សាយ Canary៖ បញ្ជូនបន្តតែភាគរយថេរនៃសំណើទៅកាន់កំណែថ្មីនៃសេវាកម្ម។
• ការត្រួតពិនិត្យនិងម៉ែត្រ៖ តើវាត្រូវការពេលប៉ុន្មានសម្រាប់សេវាកម្មដើម្បីឆ្លើយតប?
• ការតាមដាន និងការសង្កេត៖ បន្ថែមបឋមកថាពិសេសទៅសំណើនីមួយៗ ហើយតាមដានពួកវាតាមចង្កោម។
• សន្តិសុខ៖ ទាញយកនិមិត្តសញ្ញា JWT ផ្ទៀងផ្ទាត់ និងផ្តល់សិទ្ធិឱ្យអ្នកប្រើប្រាស់។

ទាំងនេះគ្រាន់តែជាលទ្ធភាពមួយចំនួនប៉ុណ្ណោះ (ពិតជាមានតិចតួចណាស់!) ដើម្បីទាក់ទាញចំណាប់អារម្មណ៍អ្នក។ ឥឡូវ​យើង​ចូល​មើល​ព័ត៌មាន​លម្អិត​បច្ចេកទេស!

ស្ថាបត្យកម្មអ៊ីស្តូ

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

យន្តហោះទិន្នន័យ

ប្រូកស៊ីដែលបានបញ្ចូលទៅក្នុងផត អនុញ្ញាតឱ្យ Istio ងាយស្រួលបំពេញតាមតម្រូវការដែលយើងត្រូវការ។ ជាឧទាហរណ៍ សូមពិនិត្យមើលមុខងាររបស់ឧបករណ៍បំប្លែងសៀគ្វីម្តងទៀត។

របៀបដែលការព្យាយាម និងការបំបែកសៀគ្វីត្រូវបានអនុវត្តនៅក្នុង Envoy

ដើម្បីសង្ខេប:

1. ប្រេសិត (យើងកំពុងនិយាយអំពីប្រូកស៊ីដែលមានទីតាំងនៅក្នុងធុងចំហៀង ដែលត្រូវបានចែកចាយជា ផលិតផលដាច់ដោយឡែក - ប្រហែល បកប្រែ។ ) ផ្ញើសំណើទៅសេវាកម្ម B ហើយបរាជ័យ។
2. Envoy Sidecar ព្យាយាមម្តងទៀត (ព្យាយាមម្តងទៀត). (1​)
3. សំណើបរាជ័យ ហើយត្រូវត្រលប់ទៅប្រូកស៊ីដែលហៅវាវិញ។
4. វាបើក Circuit Breaker ហើយហៅសេវាបន្ទាប់សម្រាប់សំណើជាបន្តបន្ទាប់។ (2​)

នេះមានន័យថាអ្នកមិនចាំបាច់ប្រើបណ្ណាល័យសាកល្បងម្តងទៀតទេ អ្នកមិនចាំបាច់អនុវត្តការបំបែកសៀគ្វី និងការរកឃើញសេវាកម្មផ្ទាល់ខ្លួនរបស់អ្នកជាភាសាសរសេរកម្មវិធី X, Y ឬ Z។ ទាំងអស់នេះ និងអ្វីៗជាច្រើនទៀតគឺអាចរកបានចេញពីប្រអប់។ នៅក្នុង Istio និងមិនទាមទារ ទេ ការផ្លាស់ប្តូរនៅក្នុងកូដ។

អស្ចារ្យ! ឥឡូវនេះអ្នកប្រហែលជាចង់ទៅធ្វើដំណើរជាមួយ Istio ប៉ុន្តែអ្នកនៅតែមានការសង្ស័យខ្លះ បើកសំណួរ។ ប្រសិនបើនេះជាដំណោះស្រាយជាសកលសម្រាប់គ្រប់ឱកាសទាំងអស់ក្នុងជីវិត នោះអ្នកមានការសង្ស័យពីធម្មជាតិមួយ៖ បន្ទាប់ពីទាំងអស់ ដំណោះស្រាយបែបនេះនៅក្នុងការពិតប្រែទៅជាមិនសមរម្យសម្រាប់ករណីណាមួយ។

ហើយចុងក្រោយអ្នកសួរថា "តើវាអាចប្ដូរតាមបំណងបានទេ?"

ឥឡូវនេះអ្នកត្រៀមខ្លួនសម្រាប់ការធ្វើដំណើរតាមសមុទ្រហើយ តោះមកស្គាល់យន្តហោះបញ្ជា។

យន្តហោះគ្រប់គ្រង

វាមានធាតុផ្សំបីយ៉ាង៖ សាកល្បង, លាយ и Citadelដែលធ្វើការរួមគ្នាដើម្បីកំណត់រចនាសម្ព័ន្ធបេសកជនដើម្បីបញ្ជូនចរាចរណ៍ ពង្រឹងគោលនយោបាយ និងប្រមូលទិន្នន័យទូរលេខ។ តាមគ្រោងការណ៍វាមើលទៅដូចនេះ:

អន្តរកម្មនៃយន្តហោះគ្រប់គ្រងជាមួយយន្តហោះទិន្នន័យ

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

ទំនាក់ទំនងនៃសេវាកម្មជាមួយ Istio

យើងបានពណ៌នាអំពីទំនាក់ទំនងរបស់ Istio ចំពោះសេវាកម្ម ប៉ុន្តែមិនមែនជាការបញ្ច្រាសទេ៖ តើសេវាកម្មទាក់ទងនឹង Istio យ៉ាងដូចម្តេច?

និយាយឱ្យត្រង់ទៅ សេវាដឹងអំពីវត្តមានរបស់ Istio ខណៈដែលត្រីមានទឹក នៅពេលដែលពួកគេសួរខ្លួនឯងថា "តើទឹកជាអ្វី?"

ឧទាហរណ៍ Victoria Dimitrakopoulos: - តើអ្នកចូលចិត្តទឹកយ៉ាងម៉េច? - តើទឹកជាអ្វី?

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

ទ្រឹស្តីគ្រប់គ្រាន់ - តោះយកចំណេះដឹងនេះទៅអនុវត្ត!

Istio នៅក្នុងការអនុវត្ត

Istio ទាមទារចង្កោម Kubernetes ដែលមាន vCPU យ៉ាងតិច 4 និង RAM 8 GB ។ ដើម្បីរៀបចំចង្កោមយ៉ាងឆាប់រហ័ស និងធ្វើតាមការណែនាំពីអត្ថបទ ខ្ញុំសូមណែនាំឱ្យប្រើ Google Cloud Platform ដែលផ្តល់ជូនអ្នកប្រើប្រាស់ថ្មី ឥតគិតថ្លៃ ៣០០ ដុល្លារ.

បន្ទាប់ពីបង្កើតចង្កោម និងកំណត់រចនាសម្ព័ន្ធការចូលប្រើ Kubernetes តាមរយៈឧបករណ៍ប្រើប្រាស់កុងសូល អ្នកអាចដំឡើង Istio តាមរយៈកម្មវិធីគ្រប់គ្រងកញ្ចប់ Helm ។

ការដំឡើងមួក

ដំឡើងកម្មវិធី Helm នៅលើកុំព្យូទ័ររបស់អ្នក ដូចដែលបានពិពណ៌នានៅក្នុង ឯកសារផ្លូវការ. យើងនឹងប្រើវាដើម្បីបង្កើតគំរូសម្រាប់ដំឡើង Istio នៅផ្នែកបន្ទាប់។

ការដំឡើង Istio

ទាញយកធនធាន Istio ពី ការចេញផ្សាយចុងក្រោយបំផុត។ (តំណភ្ជាប់របស់អ្នកនិពន្ធដើមទៅកំណែ 1.0.5 ត្រូវបានប្តូរទៅបច្ចុប្បន្ន ពោលគឺ 1.0.6 - ប្រហែលបកប្រែ។ )ស្រង់មាតិកាទៅក្នុងថតតែមួយ ដែលខ្ញុំនឹងហៅជាបន្ត [istio-resources].

ដើម្បីងាយស្រួលកំណត់អត្តសញ្ញាណធនធាន Istio បង្កើត namespace ក្នុងចង្កោម K8s istio-system:

$ kubectl create namespace istio-system

បញ្ចប់ការដំឡើងដោយចូលទៅកាន់ថត [istio-resources] ហើយដំណើរការពាក្យបញ្ជា៖

$ helm template install/kubernetes/helm/istio 
  --set global.mtls.enabled=false 
  --set tracing.enabled=true 
  --set kiali.enabled=true 
  --set grafana.enabled=true 
  --namespace istio-system > istio.yaml

ពាក្យបញ្ជានេះនឹងបញ្ចេញសមាសធាតុសំខាន់ៗរបស់ Istio ទៅជាឯកសារមួយ។ istio.yaml. យើងបានកែប្រែគំរូស្ដង់ដារឱ្យសមនឹងខ្លួនយើង ដោយបញ្ជាក់ប៉ារ៉ាម៉ែត្រដូចខាងក្រោម៖

• global.mtls.enabled បានដំឡើងនៅក្នុង false (ឧ. ការផ្ទៀងផ្ទាត់ mTLS ត្រូវបានបិទ - ប្រហាក់ប្រហែល)ដើម្បីសម្រួលដំណើរការណាត់ជួបរបស់យើង;
• tracing.enabled រួមបញ្ចូលទាំងការតាមដានសំណើដោយប្រើ Jaeger;
• kiali.enabled ដំឡើង Kiali ទៅក្នុងចង្កោម ដើម្បីមើលឃើញសេវាកម្ម និងចរាចរណ៍។
• grafana.enabled ដំឡើង Grafana ដើម្បីស្រមៃមើលម៉ែត្រដែលប្រមូលបាន។

តោះប្រើធនធានដែលបានបង្កើតដោយប្រើពាក្យបញ្ជា៖

$ kubectl apply -f istio.yaml

ការដំឡើង Istio នៅលើចង្កោមត្រូវបានបញ្ចប់! រង់ចាំរហូតដល់ផតទាំងអស់ស្ថិតនៅក្នុងចន្លោះឈ្មោះ istio-system នឹងអាច Running ឬ Completedដោយដំណើរការពាក្យបញ្ជាខាងក្រោម៖

$ kubectl get pods -n istio-system

ឥឡូវនេះ យើងត្រៀមខ្លួនរួចរាល់ហើយដើម្បីបន្តនៅផ្នែកបន្ទាប់ ដែលយើងនឹងដំណើរការកម្មវិធី។

ស្ថាបត្យកម្មនៃកម្មវិធីវិភាគអារម្មណ៍

ចូរយើងប្រើឧទាហរណ៍នៃកម្មវិធីមីក្រូសេវាកម្ម Sentiment Analysis ដែលប្រើក្នុងអ្វីដែលបានរៀបរាប់រួចហើយ អត្ថបទណែនាំអំពី Kubernetes. វាស្មុគស្មាញគ្រប់គ្រាន់ដើម្បីបង្ហាញពីសមត្ថភាពរបស់ Istio នៅក្នុងការអនុវត្ត។

កម្មវិធីមានមីក្រូសេវាចំនួនបួន៖

1. RЎRμSЂRІRёSЃ SA-Frontenដែលបម្រើផ្នែកខាងមុខនៃកម្មវិធី Reactjs;
2. RЎRμSЂRІRёSЃ SA-WebAppដែលបម្រើសំណួរការវិភាគអារម្មណ៍;
3. RЎRμSЂRІRёSЃ SA-Logicដែលអនុវត្តដោយខ្លួនវាផ្ទាល់ ការវិភាគអារម្មណ៍;
4. RЎRμSЂRІRёSЃ SA- មតិប្រតិកម្មដែលទទួលបានមតិកែលម្អពីអ្នកប្រើប្រាស់អំពីភាពត្រឹមត្រូវនៃការវិភាគ។

នៅក្នុងដ្យាក្រាមនេះ បន្ថែមពីលើសេវាកម្ម យើងក៏ឃើញ Ingress Controller ដែលនៅក្នុង Kubernetes បញ្ជូនសំណើចូលទៅកាន់សេវាកម្មសមស្រប។ Istio ប្រើគំនិតស្រដៀងគ្នានៅក្នុង Ingress Gateway របស់វា ព័ត៌មានលម្អិតបន្ថែមទៀតនឹងធ្វើតាម។

កំពុងដំណើរការកម្មវិធីជាមួយប្រូកស៊ីពី Istio

សម្រាប់ប្រតិបត្តិការបន្ថែមទៀតដែលបានរៀបរាប់នៅក្នុងអត្ថបទ សូមក្លូនឃ្លាំងរបស់អ្នក។ ជំនាញ istio. វាមានកម្មវិធី និងការបង្ហាញសម្រាប់ Kubernetes និង Istio ។

ការបញ្ចូលរថយន្តចំហៀង

ការបញ្ចូលអាចធ្វើទៅបាន ដោយស្វ័យប្រវត្តិ ឬ ដោយដៃ. ដើម្បីបញ្ចូលធុងចំហៀងដោយស្វ័យប្រវត្តិ អ្នកនឹងត្រូវកំណត់ស្លាកទៅចន្លោះឈ្មោះ istio-injection=enabledដែលត្រូវបានធ្វើដោយពាក្យបញ្ជាខាងក្រោម៖

$ kubectl label namespace default istio-injection=enabled
namespace/default labeled

ឥឡូវនេះ ផតនីមួយៗដែលនឹងត្រូវបានដាក់ឱ្យប្រើប្រាស់ក្នុងចន្លោះឈ្មោះលំនាំដើម (default) នឹងទទួលបានធុងចំហៀងរបស់វា។ ដើម្បីផ្ទៀងផ្ទាត់វា សូមដាក់ឱ្យប្រើប្រាស់កម្មវិធីសាកល្បង ដោយចូលទៅកាន់ថត root នៃឃ្លាំង [istio-mastery] ហើយដំណើរការពាក្យបញ្ជាខាងក្រោម៖

$ kubectl apply -f resource-manifests/kube
persistentvolumeclaim/sqlite-pvc created
deployment.extensions/sa-feedback created
service/sa-feedback created
deployment.extensions/sa-frontend created
service/sa-frontend created
deployment.extensions/sa-logic created
service/sa-logic created
deployment.extensions/sa-web-app created
service/sa-web-app created

ដោយបានដាក់ពង្រាយសេវាកម្ម សូមពិនិត្យមើលថាផតឃ័រមានធុងពីរ (ជាមួយសេវាកម្មខ្លួនវា និងរថយន្តចំហៀងរបស់វា) ដោយដំណើរការពាក្យបញ្ជា kubectl get pods ហើយត្រូវប្រាកដថានៅក្រោមជួរឈរ READY តម្លៃដែលបានបញ្ជាក់ 2/2ជានិមិត្តសញ្ញាថាធុងទាំងពីរកំពុងដំណើរការ៖

$ kubectl get pods
NAME                           READY     STATUS    RESTARTS   AGE
sa-feedback-55f5dc4d9c-c9wfv   2/2       Running   0          12m
sa-frontend-558f8986-hhkj9     2/2       Running   0          12m
sa-logic-568498cb4d-2sjwj      2/2       Running   0          12m
sa-logic-568498cb4d-p4f8c      2/2       Running   0          12m
sa-web-app-599cf47c7c-s7cvd    2/2       Running   0          12m

តាមទស្សនៈវាមើលទៅដូចនេះ៖

ប្រូកស៊ីបេសកជននៅក្នុងផតថលមួយ។

ឥឡូវនេះកម្មវិធីចាប់ផ្តើមដំណើរការហើយ យើងត្រូវអនុញ្ញាតឱ្យចរាចរចូលចូលមកក្នុងកម្មវិធី។

ច្រកទ្វារចូល

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

សមាសភាគ Ingress Gateway និងសេវាកម្មដែលបញ្ជូនវាទៅខាងក្រៅត្រូវបានដំឡើងនៅក្នុងចង្កោមកំឡុងពេលដំឡើង Istio ។ ដើម្បីស្វែងយល់ពីអាសយដ្ឋាន IP ខាងក្រៅរបស់សេវាកម្ម សូមដំណើរការ៖

$ kubectl get svc -n istio-system -l istio=ingressgateway
NAME                   TYPE           CLUSTER-IP     EXTERNAL-IP
istio-ingressgateway   LoadBalancer   10.0.132.127   13.93.30.120

យើងនឹងបន្តចូលប្រើកម្មវិធីដោយប្រើ IP នេះ (ខ្ញុំនឹងហៅវាថាជា EXTERNAL-IP) ដូច្នេះដើម្បីភាពងាយស្រួល យើងនឹងសរសេរតម្លៃទៅក្នុងអថេរ៖

$ EXTERNAL_IP=$(kubectl get svc -n istio-system 
  -l app=istio-ingressgateway 
  -o jsonpath='{.items[0].status.loadBalancer.ingress[0].ip}')

ប្រសិនបើអ្នកព្យាយាមចូលប្រើ IP នេះតាមរយៈកម្មវិធីរុករកឥឡូវនេះ អ្នកនឹងទទួលបានសេវាកម្មមិនអាចប្រើបាន ពីព្រោះ តាមលំនាំដើម Istio រារាំងចរាចរណ៍ចូលទាំងអស់។, Gateway មិនទាន់ត្រូវបានកំណត់។

ធនធានច្រកផ្លូវ

Gateway គឺជា CRD (Custom Resource Definition) នៅក្នុង Kubernetes ដែលកំណត់បន្ទាប់ពីដំឡើង Istio នៅក្នុង cluster ហើយបើកលទ្ធភាពក្នុងការបញ្ជាក់ច្រក ពិធីការ និង hosts ដែលយើងចង់អនុញ្ញាតចរាចរចូល។

ក្នុងករណីរបស់យើង យើងចង់អនុញ្ញាតឱ្យចរាចរ HTTP នៅលើច្រក 80 សម្រាប់ម៉ាស៊ីនទាំងអស់។ ភារកិច្ចត្រូវបានអនុវត្តតាមនិយមន័យខាងក្រោម (http-gateway.yaml):

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: http-gateway
spec:
  selector:
    istio: ingressgateway
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
- "*"

ការកំណត់រចនាសម្ព័ន្ធនេះមិនត្រូវការការពន្យល់ទេ លើកលែងតែឧបករណ៍ជ្រើសរើស istio: ingressgateway. ជាមួយនឹងឧបករណ៍ជ្រើសរើសនេះ យើងអាចបញ្ជាក់ថាតើច្រកចូលណាមួយដែលត្រូវអនុវត្តការកំណត់រចនាសម្ព័ន្ធ។ ក្នុងករណីរបស់យើង នេះគឺជាឧបករណ៍បញ្ជា Ingress Gateway ដែលត្រូវបានដំឡើងតាមលំនាំដើមនៅក្នុង Istio ។

ការកំណត់រចនាសម្ព័ន្ធត្រូវបានអនុវត្តដោយហៅពាក្យបញ្ជាខាងក្រោម៖

$ kubectl apply -f resource-manifests/istio/http-gateway.yaml gateway.networking.istio.io/http-gateway created

ច្រកផ្លូវឥឡូវនេះអនុញ្ញាតឱ្យចូលទៅកាន់ច្រក 80 ប៉ុន្តែមិនដឹងថាត្រូវបញ្ជូនសំណើទៅទីណាទេ។ សម្រាប់ការនេះអ្នកនឹងត្រូវការ សេវាកម្មនិម្មិត.

ធនធាន VirtualService

VirtualService ប្រាប់ Ingress Gateway ពីរបៀបបញ្ជូនសំណើដែលត្រូវបានអនុញ្ញាតនៅក្នុងចង្កោម។

សំណើទៅកាន់កម្មវិធីរបស់យើងដែលចូលមកតាមរយៈ http-gateway ត្រូវតែផ្ញើទៅកាន់ sa-frontend, sa-web-app និង sa-feedback services:

ផ្លូវដែលត្រូវកំណត់រចនាសម្ព័ន្ធជាមួយសេវាកម្ម VirtualServices

សូមក្រឡេកមើលសំណើដែលគួរផ្ញើទៅ SA-Frontend៖

• ការប្រកួតពិតប្រាកដនៅតាមផ្លូវ / គួរតែត្រូវបានបញ្ជូនទៅ SA-Frontend ដើម្បីទទួលបាន index.html;
• ផ្លូវបុព្វបទ /static/* ត្រូវតែផ្ញើទៅ SA-Frontend ដើម្បីទទួលឯកសារឋិតិវន្តដែលប្រើក្នុងផ្នែកខាងមុខ ដូចជា CSS និង JavaScript ។
• ផ្លូវត្រូវគ្នាដោយកន្សោមធម្មតា។ '^.*.(ico|png|jpg)$'ត្រូវតែបញ្ជូនទៅ SA-Frontend ពីព្រោះ ទាំងនេះគឺជារូបភាពដែលបង្ហាញនៅលើទំព័រ។

ការអនុវត្តត្រូវបានសម្រេចដោយការកំណត់ដូចខាងក្រោម (sa-virtualservice-external.yaml):

kind: VirtualService
metadata:
  name: sa-external-services
spec:
  hosts:
  - "*"
  gateways:
  - http-gateway                      # 1
  http:
  - match:
    - uri:
        exact: /
    - uri:
        exact: /callback
    - uri:
        prefix: /static
    - uri:
        regex: '^.*.(ico|png|jpg)$'
    route:
    - destination:
        host: sa-frontend             # 2
        port:
number: 80

ចំណុចសំខាន់ៗ៖

1. សេវា​និម្មិត​នេះ​សំដៅ​លើ​សំណើ​ដែល​មក​ដល់ http-gateway;
2. В destination សេវាកម្មដែលសំណើត្រូវបានផ្ញើត្រូវបានកំណត់។

ការកត់សម្គាល់៖ ការកំណត់រចនាសម្ព័ន្ធខាងលើត្រូវបានរក្សាទុកក្នុងឯកសារមួយ។ sa-virtualservice-external.yamlដែលក៏មានការកំណត់សម្រាប់កំណត់ផ្លូវនៅក្នុង SA-WebApp និង SA-Feedback ប៉ុន្តែត្រូវបានខ្លីនៅទីនេះក្នុងអត្ថបទសម្រាប់ភាពសង្ខេប។

តោះដាក់ពាក្យ VirtualService ដោយហៅទូរសព្ទមក៖

$ kubectl apply -f resource-manifests/istio/sa-virtualservice-external.yaml
virtualservice.networking.istio.io/sa-external-services created

ការកត់សម្គាល់៖ នៅពេលដែលយើងប្រើប្រាស់ធនធាន Istio ម៉ាស៊ីនបម្រើ API របស់ Kubernetes បង្កើតព្រឹត្តិការណ៍មួយដែលត្រូវបានទទួលដោយ Istio Control Plane ហើយបន្ទាប់ពីនោះការកំណត់រចនាសម្ព័ន្ធថ្មីត្រូវបានអនុវត្តចំពោះប្រូកស៊ី Envoy របស់ pod នីមួយៗ។ ហើយឧបករណ៍បញ្ជា Ingress Gateway ហាក់ដូចជាប្រេសិតមួយផ្សេងទៀតដែលបានកំណត់រចនាសម្ព័ន្ធនៅក្នុង Control Plane ។ ទាំងអស់នេះមើលទៅដូចនេះនៅក្នុងដ្យាក្រាម៖

ការកំណត់រចនាសម្ព័ន្ធ Istio-IngressGateway សម្រាប់ការកំណត់ផ្លូវស្នើសុំ

កម្មវិធីវិភាគអារម្មណ៍ឥឡូវនេះមាននៅលើ http://{EXTERNAL-IP}/. កុំបារម្ភ ប្រសិនបើអ្នកទទួលបានស្ថានភាពរកមិនឃើញ៖ ពេលខ្លះវាត្រូវចំណាយពេលយូរបន្តិចដើម្បីឱ្យការកំណត់មានប្រសិទ្ធភាព ហើយ Envoy ឃ្លាំងសម្ងាត់ដើម្បីធ្វើបច្ចុប្បន្នភាព.

មុននឹងបន្ត សូមលេងជាមួយកម្មវិធីបន្តិចដើម្បីបង្កើតចរាចរណ៍។ (វត្តមានរបស់វាគឺចាំបាច់សម្រាប់ភាពច្បាស់លាស់នៅក្នុងសកម្មភាពជាបន្តបន្ទាប់ - ប្រហាក់ប្រហែល។ transl ។ ).

Kiali: ការសង្កេត

ដើម្បីចូលទៅកាន់ចំណុចប្រទាក់រដ្ឋបាល Kiali សូមដំណើរការពាក្យបញ្ជាខាងក្រោម៖

$ kubectl port-forward 
    $(kubectl get pod -n istio-system -l app=kiali 
    -o jsonpath='{.items[0].metadata.name}') 
    -n istio-system 20001

... ហើយបើក http://localhost:20001/ចូលជាអ្នកគ្រប់គ្រង/គ្រប់គ្រង។ នៅទីនេះ អ្នកនឹងឃើញមុខងារមានប្រយោជន៍ជាច្រើន ជាឧទាហរណ៍ ដើម្បីពិនិត្យមើលការកំណត់រចនាសម្ព័ន្ធនៃសមាសធាតុ Istio មើលឃើញសេវាកម្មដោយប្រើព័ត៌មានដែលប្រមូលបានពីការស្ទាក់ចាប់សំណើបណ្តាញ ទទួលបានចម្លើយចំពោះសំណួរ “តើអ្នកណាកំពុងទាក់ទងអ្នកណា?” “តើសេវាកម្មមួយណាកំពុងជួបប្រទះ។ បរាជ័យ?” ល​ល។ ជាទូទៅ ស្វែងយល់ពីសមត្ថភាពរបស់ Kiali មុនពេលបន្តទៅការមើលឃើញម៉ែត្រជាមួយ Grafana ។

Grafana: ការមើលឃើញម៉ែត្រ

ម៉ែត្រដែលប្រមូលបាននៅ Istio ចូលទៅក្នុង Prometheus ហើយត្រូវបានមើលឃើញដោយ Grafana ។ ដើម្បីចូលទៅកាន់ចំណុចប្រទាក់រដ្ឋបាល Grafana សូមដំណើរការពាក្យបញ្ជាខាងក្រោម រួចបើក http://localhost:3000/:

$ kubectl -n istio-system port-forward 
    $(kubectl -n istio-system get pod -l app=grafana 
    -o jsonpath={.items[0].metadata.name}) 3000

ការចុចលើម៉ឺនុយ ទំព័រដើម កំពូលខាងឆ្វេងហើយជ្រើសរើស ផ្ទាំងគ្រប់គ្រងសេវាកម្ម Istio នៅជ្រុងខាងឆ្វេងខាងលើ ចាប់ផ្តើមជាមួយសេវាកម្ម sa-web-appដើម្បីមើលម៉ែត្រដែលប្រមូលបាន៖

អ្វី​ដែល​កំពុង​រង់ចាំ​យើង​នៅ​ទី​នេះ​គឺ​ការ​អនុវត្ត​ទទេ​និង​គួរ​ឱ្យ​ធុញ​ទ្រាន់​ទាំង​ស្រុង - ការ​គ្រប់​គ្រង​នឹង​មិន​ដែល​យល់ព្រម​ចំពោះ​ការ​នេះ​។ តោះបង្កើតបន្ទុកតូចមួយដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ while true; do 
    curl -i http://$EXTERNAL_IP/sentiment 
    -H "Content-type: application/json" 
    -d '{"sentence": "I love yogobella"}'; 
    sleep .8; done

ឥឡូវនេះយើងមានក្រាហ្វដែលល្អជាងមុន ហើយបន្ថែមពីលើពួកវា ឧបករណ៍ Prometheus ដ៏អស្ចារ្យសម្រាប់ការត្រួតពិនិត្យ និង Grafana សម្រាប់ការមើលឃើញម៉ែត្រដែលនឹងអនុញ្ញាតឱ្យយើងសិក្សាអំពីការអនុវត្ត សុខភាព ការកែលម្អ/ការថយចុះនៃសេវាកម្មតាមពេលវេលា។

ជាចុងក្រោយ សូមក្រឡេកមើលសំណើតាមដានក្នុងសេវាកម្ម។

Jaeger: តាមដាន

យើង​នឹង​ត្រូវ​ការ​ការ​តាម​ដាន​ព្រោះ​តែ​យើង​មាន​សេវា​កាន់​តែ​ច្រើន វា​កាន់​តែ​លំបាក​ក្នុង​ការ​ឈាន​ទៅ​រក​មូលហេតុ​នៃ​ការ​បរាជ័យ។ តោះមើលករណីសាមញ្ញមួយពីរូបភាពខាងក្រោម៖

ឧទាហរណ៍ធម្មតានៃសំណើដែលបរាជ័យដោយចៃដន្យ

សំណើបានមក, ធ្លាក់ - តើ​អ្វី​ជា​ហេតុផល? សេវាកម្មដំបូង? ឬទីពីរ? មានករណីលើកលែងទាំងពីរ - តោះមើលកំណត់ហេតុនីមួយៗ។ តើអ្នកចាប់ខ្លួនឯងធ្វើបែបនេះញឹកញាប់ប៉ុណ្ណា? ការងាររបស់យើងគឺដូចជាអ្នកស៊ើបអង្កេតកម្មវិធីជាងអ្នកអភិវឌ្ឍន៍...

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

TraceId ត្រូវបានប្រើដើម្បីកំណត់អត្តសញ្ញាណសំណើ

Istio ប្រើ Jaeger Tracer ដែលអនុវត្តក្របខ័ណ្ឌ OpenTracing API ឯករាជ្យពីអ្នកលក់។ អ្នកអាចចូលប្រើចំណុចប្រទាក់អ្នកប្រើ Jaeger ដោយប្រើពាក្យបញ្ជាខាងក្រោម៖

$ kubectl port-forward -n istio-system 
    $(kubectl get pod -n istio-system -l app=jaeger 
    -o jsonpath='{.items[0].metadata.name}') 16686

ឥឡូវនេះទៅ http://localhost:16686/ ហើយជ្រើសរើសសេវាកម្ម sa-web-app. ប្រសិនបើសេវាកម្មមិនត្រូវបានបង្ហាញនៅក្នុងម៉ឺនុយទម្លាក់ចុះ បង្ហាញ/បង្កើតសកម្មភាពនៅលើទំព័រ ហើយធ្វើបច្ចុប្បន្នភាពចំណុចប្រទាក់។ បន្ទាប់ពីនោះចុចលើប៊ូតុង ស្វែងរកដានដែលនឹងបង្ហាញដានចុងក្រោយបំផុត - ជ្រើសរើសណាមួយ - ព័ត៌មានលម្អិតអំពីដានទាំងអស់នឹងបង្ហាញឡើង៖

ដាននេះបង្ហាញ៖

1. ពាក្យសុំចូលមក istio-ingressgateway (នេះ​ជា​អន្តរកម្ម​ដំបូង​ជាមួយ​សេវាកម្ម​មួយ ហើយ​លេខ​សម្គាល់​ដាន​ត្រូវ​បាន​បង្កើត​សម្រាប់​សំណើ) បន្ទាប់​ពី​នោះ​ច្រក​ចេញ​នឹង​ផ្ញើ​សំណើ​ទៅ​សេវាកម្ម sa-web-app.
2. នៅក្នុងសេវាកម្ម sa-web-app សំណើ​នេះ​ត្រូវ​បាន​ទទួល​ដោយ​រថយន្ត​ខាង​ប្រេសិត “កូន” ត្រូវ​បាន​បង្កើត​ឡើង​ក្នុង​ចន្លោះ (នោះ​ជា​មូល​ហេតុ​ដែល​យើង​ឃើញ​វា​នៅ​ក្នុង​ដាន) ហើយ​បញ្ជូន​បន្ត​ទៅ​កុងតឺន័រ។ sa-web-app. (រយៈពេល - ឯកតាឡូជីខលនៃការងារនៅក្នុង Jaeger ដែលមានឈ្មោះ ពេលវេលាចាប់ផ្តើមនៃប្រតិបត្តិការ និងរយៈពេលរបស់វា។ ចន្លោះអាចត្រូវបានដាក់និងបញ្ជា។ ក្រាហ្វ acyclic ដឹកនាំនៃវិសាលភាពបង្កើតជាដានមួយ។ - ប្រហែល បកប្រែ។ )
3. នៅទីនេះសំណើត្រូវបានដំណើរការដោយវិធីសាស្ត្រ ការវិភាគអារម្មណ៍. ដានទាំងនេះត្រូវបានបង្កើតរួចហើយដោយកម្មវិធី i.e. ពួកគេទាមទារការផ្លាស់ប្តូរកូដ។
4. ចាប់ពីពេលនេះតទៅ សំណើ POST ត្រូវបានផ្តួចផ្តើមនៅក្នុង សា-តក្កវិជ្ជា. លេខសម្គាល់ដានត្រូវតែបញ្ជូនបន្តពី sa-web-app.
5. ...

ការកត់សម្គាល់៖ នៅក្នុងជំហានទី 4 កម្មវិធីគួរតែឃើញបឋមកថាដែលបង្កើតដោយ Istio ហើយបញ្ជូនវាទៅសំណើជាបន្តបន្ទាប់ដូចបង្ហាញក្នុងរូបភាពខាងក្រោម៖

(A) Istio ទទួលខុសត្រូវចំពោះការបញ្ជូនបន្តបឋមកថា; (ខ) សេវាកម្មទទួលខុសត្រូវចំពោះក្បាល

Istio ធ្វើការងារភាគច្រើនដោយសារតែ... បង្កើតបឋមកថាសម្រាប់សំណើចូល បង្កើតវិសាលភាពថ្មីនៅក្នុងផ្នែកថែទាំនីមួយៗ និងបញ្ជូនបន្តពួកគេ។ ទោះយ៉ាងណាក៏ដោយ ដោយមិនធ្វើការជាមួយបឋមកថាខាងក្នុងសេវាកម្ម ផ្លូវដានសំណើពេញលេញនឹងត្រូវបាត់បង់។

បឋមកថាខាងក្រោមត្រូវតែយកមកពិចារណា៖

x-request-id
x-b3-traceid
x-b3-spanid
x-b3-parentspanid
x-b3-sampled
x-b3-flags
x-ot-span-context

នេះ​មិន​មែន​ជា​កិច្ចការ​លំបាក​នោះ​ទេ ប៉ុន្តែ​ដើម្បី​សម្រួល​ដល់​ការ​អនុវត្ត​របស់​វា​មាន​រួច​ហើយ។ បណ្ណាល័យជាច្រើន។ - ឧទាហរណ៍ នៅក្នុងសេវាកម្ម sa-web-app ម៉ាស៊ីនភ្ញៀវ RestTemplate បញ្ជូនបន្តបឋមកថាទាំងនេះ ប្រសិនបើអ្នកគ្រាន់តែបន្ថែមបណ្ណាល័យ Jaeger និង OpenTracing ទៅ ការញៀនរបស់គាត់។.

ចំណាំថាកម្មវិធី Sentiment Analysis បង្ហាញពីការអនុវត្តនៅក្នុង Flask, Spring និង ASP.NET Core។

ឥឡូវនេះវាច្បាស់ថាអ្វីដែលយើងទទួលបានចេញពីប្រអប់ (ឬស្ទើរតែចេញពីប្រអប់) សូមក្រឡេកមើលការផាកពិន័យ routing, network traffic management, security, etc.!

ចំណាំ។ បកប្រែ៖ សូមអានអំពីរឿងនេះនៅក្នុងផ្នែកបន្ទាប់នៃសម្ភារៈនៅលើ Istio ពី Rinor Maloku ការបកប្រែដែលនឹងធ្វើតាមនៅលើប្លក់របស់យើងនាពេលខាងមុខនេះ។ ធ្វើឱ្យទាន់សម័យ (ថ្ងៃទី១៤ ខែមីនា)៖ ផ្នែកទីពីរនៃ ត្រូវបានបោះពុម្ពរួចហើយ។

PS ពីអ្នកបកប្រែ

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

• "ត្រលប់ទៅសេវាកម្មខ្នាតតូចជាមួយ Istio"៖ ផ្នែកទី 2 (ផ្លូវ, ការត្រួតពិនិត្យចរាចរណ៍), ផ្នែកទី 3 (ការផ្ទៀងផ្ទាត់ និងការអនុញ្ញាត);
• «បំពង់ - សំណាញ់សេវាទម្ងន់ស្រាលសម្រាប់ Kubernetes»
• «តើអ្វីទៅជាសេវាសំណាញ់ ហើយហេតុអ្វីបានជាខ្ញុំត្រូវការ [សម្រាប់កម្មវិធីពពកជាមួយមីក្រូសឺវីស]?»
• «មគ្គុទ្ទេសក៍បង្ហាញអំពីបណ្តាញនៅក្នុង Kubernetes ។ ផ្នែកទី 1 និងទី 2»
• «តើ​កុងតឺន័រ​ខាង​រថយន្ត​នេះ​បញ្ចប់​ដោយ​របៀប​ណា​នៅ​ទីនេះ [ក្នុង Kubernetes]?"។

ប្រភព: www.habr.com