ខ្ញុំសុំទោស OpenShift យើងមិនបានដឹងគុណអ្នកគ្រប់គ្រាន់ទេ ហើយទទួលយកអ្នកដោយយល់ស្រប

ការបង្ហោះនេះត្រូវបានសរសេរដោយសារតែបុគ្គលិករបស់យើងមានការសន្ទនាតិចតួចជាមួយអតិថិជនអំពីការបង្កើតកម្មវិធីនៅលើ Kubernetes និងជាក់លាក់នៃការអភិវឌ្ឍន៍បែបនេះនៅលើ OpenShift ។

ជាធម្មតាយើងចាប់ផ្តើមជាមួយនឹងនិក្ខេបបទដែល Kubernetes គ្រាន់តែជា Kubernetes ហើយ OpenShift គឺជាវេទិកា Kubernetes រួចហើយដូចជា Microsoft AKS ឬ Amazon EKS ។ វេទិកាទាំងនេះនីមួយៗមានគុណសម្បត្តិផ្ទាល់ខ្លួន ដោយផ្តោតលើទស្សនិកជនគោលដៅជាក់លាក់មួយ។ ហើយបន្ទាប់ពីនោះ ការសន្ទនាបានហូរចូលទៅក្នុងការប្រៀបធៀបភាពខ្លាំង និងចំណុចខ្សោយនៃវេទិកាជាក់លាក់។

ជាទូទៅ យើងបានគិតពីការសរសេរប្រកាសនេះជាមួយនឹងលទ្ធផលដូចជា “ស្តាប់ វាមិនមានបញ្ហាអ្វីដែលអ្នកដំណើរការកូដនៅលើ OpenShift ឬនៅលើ AKS នៅលើ EKS នៅលើ Kubernetes ផ្ទាល់ខ្លួនមួយចំនួន បាទនៅលើ Kubernetes ណាមួយ (តោះហៅវាថា KUK) "វាពិតជាសាមញ្ញ ទាំងនៅទីនោះ និងនៅទីនោះ។"

បន្ទាប់មកយើងគ្រោងនឹងយក "Hello World" សាមញ្ញបំផុត ហើយប្រើវាដើម្បីបង្ហាញពីអ្វីដែលជារឿងធម្មតា និងអ្វីដែលជាភាពខុសគ្នារវាង CMC និង Red Hat OpenShift Container Platform (តទៅនេះ OCP ឬធម្មតា OpenShift)។

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

ជាទូទៅ ពេលវេលាបានមកដល់សម្រាប់ការប្រែចិត្តយ៉ាងសកម្ម ហើយឥឡូវនេះ យើងនឹងប្រៀបធៀបការចាត់ចែងនៃ "Hello World" របស់យើង។ អាកប្បកិរិយាចំពោះប្រធានបទ) ។ ប្រសិនបើអ្នកចាប់អារម្មណ៍លើគំនិតសុទ្ធសាធលើបញ្ហានេះ អ្នកអាចអានវាបាន នៅទីនេះ (EN). ហើយ​ក្នុង​ប្រកាស​នេះ យើង​នឹង​នៅ​ជាប់​នឹង​ការ​ពិត​និង​ការ​ពិត​តែ​ប៉ុណ្ណោះ។

ចង្កោម

ដូច្នេះ "Hello World" របស់យើងត្រូវការចង្កោម។ ចូរនិយាយថា "ទេ" ចំពោះពពកសាធារណៈណាមួយ ដើម្បីកុំឱ្យបង់ប្រាក់សម្រាប់ម៉ាស៊ីនមេ ការចុះឈ្មោះ បណ្តាញ ការផ្ទេរទិន្នន័យជាដើម។ ដូច្នោះហើយ យើងជ្រើសរើសចង្កោមថ្នាំងមួយសាមញ្ញនៅលើ មីនីគូប (សម្រាប់ KUK) និង កុងតឺន័រដែលត្រៀមរួចជាស្រេច (សម្រាប់ក្រុម OpenShift) ។ ជម្រើសទាំងពីរនេះគឺពិតជាងាយស្រួលក្នុងការដំឡើង ប៉ុន្តែត្រូវការធនធានជាច្រើននៅលើកុំព្យូទ័រយួរដៃរបស់អ្នក។

សន្និបាតនៅលើ KUK-e

អញ្ចឹងតោះទៅ។

ជំហានទី 1 - ការកសាងរូបភាពកុងតឺន័ររបស់យើង។

ចូរចាប់ផ្តើមដោយដាក់ "Hello World" របស់យើងទៅ minikube ។ នេះនឹងទាមទារ៖

1. 1. បានដំឡើង Docker ។
2. 2. បានដំឡើង Git ។
3. 3. បានដំឡើង Maven (តាមពិត គម្រោងនេះប្រើ mvnw binary ដូច្នេះអ្នកអាចធ្វើបានដោយគ្មានវា)។
4. 4. តាមពិតប្រភពខ្លួនវា i.e. ក្លូនឃ្លាំង github.com/gcolman/quarkus-hello-world.git

ជំហានដំបូងគឺបង្កើតគម្រោង Quarkus ។ កុំភ័យខ្លាចប្រសិនបើអ្នកមិនធ្លាប់ប្រើ Quarkus.io - វាងាយស្រួល។ អ្នកគ្រាន់តែជ្រើសរើសសមាសធាតុដែលអ្នកចង់ប្រើក្នុងគម្រោង (RestEasy, Hibernate, Amazon SQS, Camel ។ នោះគឺជាការចុចកណ្ដុរមួយតាមព្យញ្ជនៈ ហើយអ្នករួចរាល់ហើយ។ នេះជាមូលហេតុដែលយើងស្រឡាញ់ Quarkus ។

មធ្យោបាយងាយស្រួលបំផុតក្នុងការបង្កើត "Hello World" របស់យើងទៅជារូបភាពដែលមានផ្ទុកគឺត្រូវប្រើផ្នែកបន្ថែម quarkus-maven សម្រាប់ Docker ដែលនឹងធ្វើការងារចាំបាច់ទាំងអស់។ ជាមួយនឹងវត្តមានរបស់ Quarkus នេះបានក្លាយជាការងាយស្រួល និងសាមញ្ញ៖ បន្ថែមផ្នែកបន្ថែម container-image-docker ហើយអ្នកអាចបង្កើតរូបភាពដោយប្រើពាក្យបញ្ជា maven ។

./mvnw quarkus:add-extension -Dextensions=”container-image-docker”

ហើយចុងក្រោយយើងបង្កើតរូបភាពរបស់យើងដោយប្រើ Maven ។ ជាលទ្ធផល កូដប្រភពរបស់យើងប្រែទៅជារូបភាពកុងតឺន័រដែលត្រៀមរួចជាស្រេច ដែលអាចដំណើរការរួចហើយនៅក្នុងរយៈពេលដំណើរការកុងតឺន័រ។

./mvnw -X clean package -Dquarkus.container-image.build=true

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

docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world

បន្ទាប់ពីកម្មវិធីកុងតឺន័របានចាប់ផ្តើម អ្វីៗដែលនៅសល់គឺត្រូវពិនិត្យមើលដោយប្រើពាក្យបញ្ជា curl ដែលសេវាកម្មរបស់យើងកំពុងដំណើរការ៖

ដូច្នេះ អ្វីគ្រប់យ៉ាងដំណើរការ ហើយវាពិតជាងាយស្រួល និងសាមញ្ញ។

ជំហានទី 2 - បញ្ជូនកុងតឺន័ររបស់យើងទៅឃ្លាំងរូបភាពកុងតឺន័រ

សម្រាប់ពេលនេះ រូបភាពដែលយើងបានបង្កើតត្រូវបានរក្សាទុកក្នុងមូលដ្ឋាននៅក្នុងកន្លែងផ្ទុកកុងតឺន័រក្នុងស្រុករបស់យើង។ ប្រសិនបើយើងចង់ប្រើរូបភាពនេះនៅក្នុងបរិស្ថាន KUK របស់យើង យើងត្រូវដាក់វានៅក្នុងឃ្លាំងផ្សេងទៀត។ Kubernetes មិនមានលក្ខណៈពិសេសទាំងនេះទេ ដូច្នេះយើងនឹងប្រើ dockerhub ។ ដោយសារតែដំបូង វាមិនគិតថ្លៃ ហើយទីពីរ (ស្ទើរតែ) មនុស្សគ្រប់គ្នាធ្វើវា។

នេះក៏សាមញ្ញណាស់ដែរ ហើយមានតែគណនី dockerhub ប៉ុណ្ណោះដែលត្រូវការនៅទីនេះ។

ដូច្នេះ យើងដំឡើង dockerhub ហើយផ្ញើរូបភាពរបស់យើងនៅទីនោះ។

ជំហានទី 3 - ចាប់ផ្តើម Kubernetes

មានវិធីជាច្រើនក្នុងការដាក់បញ្ចូលគ្នានូវការកំណត់រចនាសម្ព័ន្ធ kubernetes ដើម្បីដំណើរការ "Hello World" របស់យើង ប៉ុន្តែយើងនឹងប្រើវាសាមញ្ញបំផុត ព្រោះយើងជាមនុស្សបែបនេះ...

ដំបូងយើងចាប់ផ្តើមចង្កោម minikube៖

minikube start

ជំហានទី 4 - ការដាក់ពង្រាយរូបភាពកុងតឺន័ររបស់យើង។

ឥឡូវនេះយើងត្រូវបំប្លែងកូដ និងរូបភាពកុងតឺន័ររបស់យើងទៅជាការកំណត់រចនាសម្ព័ន្ធ kubernetes។ ម្យ៉ាងវិញទៀត យើងត្រូវការ pod និងនិយមន័យនៃការដាក់ពង្រាយដែលចង្អុលទៅរូបភាពកុងតឺន័ររបស់យើងនៅលើ dockerhub ។ មធ្យោបាយងាយស្រួលបំផុតមួយក្នុងការធ្វើនេះគឺដើម្បីដំណើរការពាក្យបញ្ជាបង្កើតការដាក់ពង្រាយដែលចង្អុលទៅរូបភាពរបស់យើង៖

kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT

ជាមួយនឹងពាក្យបញ្ជានេះ យើងបានប្រាប់ COOK របស់យើងឱ្យបង្កើតការកំណត់ដាក់ពង្រាយ ដែលគួរតែមានការបញ្ជាក់ pod សម្រាប់រូបភាពកុងតឺន័ររបស់យើង។ ពាក្យ​បញ្ជា​នេះ​ក៏​នឹង​អនុវត្ត​ការ​កំណត់​រចនាសម្ព័ន្ធ​នេះ​ចំពោះ​ចង្កោម minikube របស់​យើង​ផង​ដែរ ហើយ​បង្កើត​ការ​ដាក់​ពង្រាយ​ដែល​នឹង​ទាញ​យក​រូបភាព​កុងតឺន័រ​របស់​យើង ហើយ​ដំណើរការ​ផត​នៅ​លើ​ចង្កោម។

ជំហានទី 5 - បើកការចូលប្រើសេវាកម្មរបស់យើង។

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

មានវិធីជាច្រើននៅទីនេះ។ ឧទាហរណ៍ អ្នកអាចប្រើពាក្យបញ្ជា expose ដើម្បីបង្កើតសមាសធាតុ Kubernetes ដែលសមស្របដូចជាសេវាកម្ម និងចំណុចបញ្ចប់ដោយស្វ័យប្រវត្តិ។ តាមពិត នេះជាអ្វីដែលយើងនឹងធ្វើដោយប្រតិបត្តិពាក្យបញ្ជា expose សម្រាប់វត្ថុដាក់ពង្រាយរបស់យើង៖

kubectl expose deployment hello-quarkus — type=NodePort — port=8080

ចូរយើងរស់នៅលើជម្រើស "-type" នៃពាក្យបញ្ជា expose មួយភ្លែត។

នៅពេលដែលយើងបង្ហាញ និងបង្កើតសមាសធាតុដែលត្រូវការដើម្បីដំណើរការសេវាកម្មរបស់យើង យើងត្រូវការក្នុងចំណោមរបស់ផ្សេងទៀត ដើម្បីអាចភ្ជាប់ពីខាងក្រៅទៅកាន់សេវា hello-quarkus ដែលស្ថិតនៅក្នុងបណ្តាញដែលកំណត់ដោយកម្មវិធីរបស់យើង។ និងប៉ារ៉ាម៉ែត្រ ប្រភេទ អនុញ្ញាតឱ្យយើងបង្កើត និងភ្ជាប់អ្វីៗដូចជា load balancers ដើម្បីបញ្ជូនចរាចរទៅកាន់បណ្តាញនោះ។

ឧទាហរណ៍ការសរសេរ type=LoadBalancerយើងចាប់ផ្តើមប្រព័ន្ធតុល្យភាពការផ្ទុកពពកសាធារណៈដោយស្វ័យប្រវត្តិ ដើម្បីភ្ជាប់ទៅក្រុម Kubernetes របស់យើង។ នេះពិតជាអស្ចារ្យណាស់ ប៉ុន្តែអ្នកត្រូវយល់ថាការកំណត់រចនាសម្ព័ន្ធបែបនេះនឹងត្រូវបានភ្ជាប់យ៉ាងតឹងរ៉ឹងទៅនឹងពពកសាធារណៈជាក់លាក់មួយ ហើយវានឹងកាន់តែលំបាកក្នុងការផ្ទេរវារវាងវត្ថុ Kubernetes ក្នុងបរិយាកាសផ្សេងៗគ្នា។

នៅក្នុងឧទាហរណ៍របស់យើង។ type=NodePortនោះគឺការហៅទៅកាន់សេវារបស់យើងទៅដោយអាសយដ្ឋាន IP នៃ node និងលេខច្រក។ ជម្រើសនេះអនុញ្ញាតឱ្យអ្នកមិនប្រើពពកសាធារណៈណាមួយឡើយ ប៉ុន្តែទាមទារជំហានបន្ថែមមួយចំនួន។ ដំបូងអ្នកត្រូវការតុល្យភាពបន្ទុកផ្ទាល់ខ្លួនរបស់អ្នក ដូច្នេះយើងនឹងដាក់ពង្រាយឧបករណ៍ផ្ទុក NGINX នៅក្នុងចង្កោមរបស់យើង។

ជំហានទី 6 - រៀបចំតុល្យភាពបន្ទុក

minikube មានមុខងារវេទិកាមួយចំនួនដែលធ្វើឱ្យវាងាយស្រួលក្នុងការបង្កើតសមាសធាតុដែលអ្នកត្រូវការសម្រាប់ការចូលប្រើខាងក្រៅ ដូចជាឧបករណ៍បញ្ជា ingress ជាដើម។ Minikube ភ្ជាប់មកជាមួយឧបករណ៍បញ្ជាចូល Nginx ហើយអ្វីដែលយើងត្រូវធ្វើគឺបើកវា និងកំណត់រចនាសម្ព័ន្ធវា។

minikube addons enable ingress

ឥឡូវនេះ ជាមួយនឹងពាក្យបញ្ជាតែមួយប៉ុណ្ណោះ យើងនឹងបង្កើតឧបករណ៍បញ្ជាចូល Nginx ដែលនឹងដំណើរការនៅក្នុងចង្កោម minikube របស់យើង៖

ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m

ជំហានទី 7 - រៀបចំច្រកចូល

ឥឡូវនេះយើងត្រូវកំណត់រចនាសម្ព័ន្ធឧបករណ៍បញ្ជា Nginx ingress ដើម្បីទទួលយកសំណើ hello-quarkus ។

ហើយចុងក្រោយ យើងត្រូវអនុវត្តការកំណត់នេះ។

kubectl apply -f ingress.yml

ដោយសារយើងកំពុងធ្វើអ្វីៗទាំងអស់នេះនៅលើម៉ាស៊ីនរបស់យើង យើងគ្រាន់តែបន្ថែមអាសយដ្ឋាន IP របស់ថ្នាំងរបស់យើងទៅឯកសារ /etc/hosts ដើម្បីដឹកនាំសំណើ http ទៅកាន់ minikube របស់យើងទៅកាន់ NGINX load balancer ។

192.168.99.100 hello-quarkus.info

នោះហើយជាវា ឥឡូវនេះសេវា minikube របស់យើងអាចរកបានពីខាងក្រៅតាមរយៈឧបករណ៍បញ្ជា Nginx ingress ។

នោះជាការងាយស្រួលមែនទេ? ឬមិនច្រើន?

ដំណើរការលើ OpenShift (Code Ready Containers)

ហើយឥឡូវនេះសូមមើលពីរបៀបដែលវាត្រូវបានធ្វើនៅលើ Red Hat OpenShift Container Platform (OCP)។

ដូចនៅក្នុងករណីនៃ minikube យើងជ្រើសរើសគ្រោងការណ៍ដែលមានចង្កោម OpenShift ថ្នាំងតែមួយក្នុងទម្រង់ Code Ready Containers (CRC) ។ វាធ្លាប់ត្រូវបានគេហៅថា minishift ហើយត្រូវបានផ្អែកលើគម្រោង OpenShift Origin ប៉ុន្តែឥឡូវនេះវាជា CRC ហើយត្រូវបានបង្កើតឡើងនៅលើវេទិកា OpenShift Container Platform របស់ Red Hat ។

នៅទីនេះ សូមអភ័យទោស យើងមិនអាចជួយអ្វីបានក្រៅពីនិយាយថា "OpenShift អស្ចារ្យណាស់!"

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

ចូរ​រត់​តាម​ដំណើរ​ការ​ហើយ​មើល​ថា​យើង​ត្រូវ​ធ្វើ​អ្វី។

ដូច្នេះក្នុងឧទាហរណ៍ minikube យើងចាប់ផ្តើមជាមួយ Docker... រង់ចាំ យើងមិនត្រូវការ Docker ដំឡើងនៅលើម៉ាស៊ីនទៀតទេ។

ហើយយើងមិនត្រូវការ git ក្នុងស្រុកទេ។
ហើយ Maven មិនចាំបាច់ទេ។
ហើយអ្នកមិនចាំបាច់បង្កើតរូបភាពធុងដោយដៃទេ។
ហើយអ្នកមិនចាំបាច់ស្វែងរកកន្លែងផ្ទុករូបភាពកុងតឺន័រណាមួយឡើយ។
ហើយអ្នកមិនចាំបាច់ដំឡើងឧបករណ៍បញ្ជា ingress ទេ។
ហើយអ្នកក៏មិនចាំបាច់កំណត់រចនាសម្ព័ន្ធ ingress ដែរ។

តើ​អ្នក​យល់​ទេ? ដើម្បីដាក់ពង្រាយ និងដំណើរការកម្មវិធីរបស់យើងនៅលើ OpenShift នោះមិនចាំបាច់មានចំណុចណាមួយខាងលើទេ។ ហើយដំណើរការខ្លួនវាគឺដូចខាងក្រោម។

ជំហានទី 1 - ចាប់ផ្តើម OpenShift Cluster របស់អ្នក។

យើងប្រើ Code Ready Containers ពី Red Hat ដែលសំខាន់គឺ Minikube ដូចគ្នា ប៉ុន្តែមានតែ Openshift cluster តែមួយ node ពេញលេញប៉ុណ្ណោះ។

crc start

ជំហានទី 2 - បង្កើត និងដាក់ពង្រាយកម្មវិធីទៅកាន់ OpenShift Cluster

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

OpenShift តែងតែត្រូវបានបង្កើតឡើងជាវេទិកាសម្រាប់ការកសាង និងដំណើរការកម្មវិធីដែលមានកុងតឺន័រ។ ការកសាងធុងតែងតែជាផ្នែកសំខាន់មួយនៃវេទិកានេះ ដូច្នេះហើយមានធនធាន Kubernetes បន្ថែមជាច្រើនសម្រាប់កិច្ចការដែលត្រូវគ្នា។

យើងនឹងប្រើប្រាស់ដំណើរការរូបភាព Source 2 (S2I) របស់ OpenShift ដែលមានវិធីផ្សេងគ្នាជាច្រើនដើម្បីយកប្រភពរបស់យើង (កូដ ឬប្រព័ន្ធគោលពីរ) ហើយប្រែក្លាយវាទៅជារូបភាពផ្ទុកដែលដំណើរការលើចង្កោម OpenShift ។

សម្រាប់រឿងនេះយើងត្រូវការរឿងពីរ៖

• កូដប្រភពរបស់យើងនៅក្នុងឃ្លាំង git
• អ្នកសាងសង់ - រូបភាពដោយផ្អែកលើការជួបប្រជុំគ្នានឹងត្រូវបានអនុវត្ត។

មានរូបភាពបែបនេះជាច្រើន រក្សាទាំងដោយ Red Hat និងដោយសហគមន៍ ហើយយើងនឹងប្រើរូបភាព OpenJDK ផងដែរ ព្រោះខ្ញុំកំពុងបង្កើតកម្មវិធី Java។

អ្នកអាចដំណើរការ S2I build ទាំងពីកុងសូលក្រាហ្វិក OpenShift Developer និងពីបន្ទាត់ពាក្យបញ្ជា។ យើង​នឹង​ប្រើ​ពាក្យ​បញ្ជា​កម្មវិធី​ថ្មី ដោយ​ប្រាប់​ពី​កន្លែង​ទទួល​បាន​រូបភាព​អ្នក​បង្កើត និង​កូដ​ប្រភព​របស់​យើង។

oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git

នោះហើយជាវា កម្មវិធីរបស់យើងត្រូវបានបង្កើតឡើង។ ក្នុងការធ្វើដូច្នេះ ដំណើរការ S2I បានធ្វើរឿងដូចខាងក្រោមៈ

• បានបង្កើតសេវាកម្ម build-pod សម្រាប់គ្រប់ប្រភេទដែលទាក់ទងនឹងការកសាងកម្មវិធី។
• បានបង្កើតការកំណត់រចនាសម្ព័ន្ធ OpenShift Build ។
• ខ្ញុំបានទាញយករូបភាព builder ទៅក្នុងបញ្ជីឈ្មោះ Docker OpenShift ខាងក្នុង។
• ក្លូន "Hello World" ទៅឃ្លាំងក្នុងស្រុក។
• ឃើញមាន maven pom នៅទីនោះ ហើយបានចងក្រងកម្មវិធីជាមួយ maven ។
• បានបង្កើតរូបភាពកុងតឺន័រថ្មីដែលមានកម្មវិធី Java ដែលបានចងក្រង ហើយដាក់រូបភាពនេះទៅក្នុងបញ្ជីឈ្មោះធុងខាងក្នុង។
• បានបង្កើតការដាក់ពង្រាយ Kubernetes ជាមួយនឹងលក្ខណៈជាក់លាក់សម្រាប់ផត សេវាកម្ម។ល។
• បានបើកដំណើរការរូបភាពដាក់ពង្រាយកុងតឺន័រ។
• បានដកសេវាកម្ម build-pod ចេញ។

មានច្រើននៅក្នុងបញ្ជីនេះ ប៉ុន្តែរឿងសំខាន់គឺថាការស្ថាបនាទាំងមូលកើតឡើងទាំងស្រុងនៅក្នុង OpenShift បញ្ជីឈ្មោះ Docker ខាងក្នុងគឺនៅខាងក្នុង OpenShift ហើយដំណើរការបង្កើតបង្កើតសមាសធាតុ Kubernetes ទាំងអស់ ហើយដំណើរការពួកវានៅលើចង្កោម។

ប្រសិនបើអ្នកត្រួតពិនិត្យមើលការបើកដំណើរការ S2I នៅក្នុងកុងសូល អ្នកអាចមើលឃើញពីរបៀបដែល build pod ត្រូវបានដាក់ឱ្យដំណើរការក្នុងអំឡុងពេល build។

ហើយឥឡូវនេះ សូមក្រឡេកមើលកំណត់ហេតុរបស់អ្នកបង្កើតផតសិន៖ ជាដំបូង នៅទីនោះអ្នកអាចមើលឃើញពីរបៀបដែល maven ធ្វើការងាររបស់វា និងទាញយកភាពអាស្រ័យដើម្បីបង្កើតកម្មវិធី java របស់យើង។

បន្ទាប់ពីការសាងសង់ maven ត្រូវបានបញ្ចប់ ការបង្កើតរូបភាពកុងតឺន័រត្រូវបានចាប់ផ្តើម ហើយបន្ទាប់មករូបភាពដែលបានសាងសង់នេះត្រូវបានបញ្ជូនទៅឃ្លាំងខាងក្នុង។

អ្វីគ្រប់យ៉ាងដំណើរការដំឡើងត្រូវបានបញ្ចប់។ ឥឡូវនេះ សូមប្រាកដថា ផត និងសេវាកម្មនៃកម្មវិធីរបស់យើងបានចាប់ផ្តើមនៅក្នុងចង្កោម។

oc get service

អស់ហើយ។ ហើយមានក្រុមតែមួយ។ អ្វី​ដែល​យើង​ត្រូវ​ធ្វើ​គឺ​លាតត្រដាង​សេវាកម្ម​នេះ​សម្រាប់​ការ​ចូល​ទៅ​ក្រៅ។

ជំហានទី 3 - ធ្វើឱ្យសេវាលាតត្រដាងសម្រាប់ការចូលប្រើពីខាងក្រៅ

ដូចនៅក្នុងករណីរបស់ KUK នៅលើវេទិកា OpenShift “Hello World” របស់យើងក៏ត្រូវការរ៉ោតទ័រផងដែរ ដើម្បីដឹកនាំចរាចរណ៍ខាងក្រៅទៅកាន់សេវាកម្មមួយនៅក្នុងចង្កោម។ នៅក្នុង OpenShift វាធ្វើឱ្យវាងាយស្រួលណាស់។ ទីមួយ សមាសភាគការបញ្ជូនផ្លូវ HAProxy ត្រូវបានដំឡើងនៅក្នុងចង្កោមតាមលំនាំដើម (វាអាចត្រូវបានផ្លាស់ប្តូរទៅជា NGINX ដូចគ្នា)។ ទីពីរ មានធនធានពិសេស និងអាចកំណត់រចនាសម្ព័ន្ធបានខ្ពស់ហៅថា Routes ដែលនឹកឃើញដល់វត្ថុ Ingress នៅក្នុង Kubernetes ចាស់ៗដ៏ល្អ (តាមពិត ផ្លូវរបស់ OpenShift មានឥទ្ធិពលយ៉ាងខ្លាំងលើការរចនាវត្ថុ Ingress ដែលឥឡូវនេះអាចប្រើក្នុង OpenShift) ប៉ុន្តែសម្រាប់ "ជំរាបសួរ" របស់យើង ពិភពលោក" ហើយស្ទើរតែគ្រប់ករណីផ្សេងទៀត ផ្លូវស្តង់ដារគឺគ្រប់គ្រាន់សម្រាប់យើងដោយគ្មានការកំណត់បន្ថែម។

ដើម្បីបង្កើត FQDN ដែលអាចកំណត់បានសម្រាប់ “Hello World” (បាទ OpenShiift មាន DNS ផ្ទាល់ខ្លួនសម្រាប់កំណត់ផ្លូវតាមឈ្មោះសេវាកម្ម) យើងគ្រាន់តែបង្ហាញសេវាកម្មរបស់យើង៖

oc expose service quarkus-hello-world

ប្រសិនបើអ្នកក្រឡេកមើលផ្លូវដែលបានបង្កើតថ្មីនោះ អ្នកអាចស្វែងរក FQDN និងព័ត៌មានផ្លូវផ្សេងទៀតនៅទីនោះ៖

oc get route

ហើយចុងក្រោយ យើងចូលប្រើសេវាកម្មរបស់យើងពីកម្មវិធីរុករក៖

ប៉ុន្តែ​ឥឡូវ​នេះ​ពិត​ជា​ងាយ​ស្រួល​មែន!

យើងស្រឡាញ់ Kubernetes និងអ្វីគ្រប់យ៉ាងដែលបច្ចេកវិទ្យានេះអនុញ្ញាតឱ្យអ្នកធ្វើ ហើយយើងក៏ចូលចិត្តភាពសាមញ្ញ និងភាពស្រាលផងដែរ។ Kubernetes ត្រូវ​បាន​រចនា​ឡើង​ដើម្បី​ផលិត​ធុង​ចែកចាយ​ដែល​អាច​ធ្វើ​មាត្រដ្ឋាន​បាន​យ៉ាង​ងាយ​ស្រួល​ក្នុង​ការ​ធ្វើ​ប្រតិបត្តិការ ប៉ុន្តែ​ភាព​សាមញ្ញ​របស់​វា​មិន​គ្រប់គ្រាន់​ដើម្បី​នាំ​កម្មវិធី​ចូល​ទៅ​ក្នុង​ការ​ផលិត​សព្វ​ថ្ងៃ​នេះ​ទេ។ នេះគឺជាកន្លែងដែល OpenShift ចូលមកលេង រក្សាពេលវេលា និងផ្តល់ជូននូវ Kubernetes ដែលផ្តោតលើអ្នកអភិវឌ្ឍន៍។ កិច្ចខិតខំប្រឹងប្រែងជាច្រើនត្រូវបានបណ្តាក់ទុនដើម្បីកែសម្រួលវេទិកា OpenShift ពិសេសសម្រាប់អ្នកអភិវឌ្ឍន៍ រួមទាំងការបង្កើតឧបករណ៍ដូចជា S2I, ODI, Developer Portal, OpenShift Operator Framework, IDE integration, Developer Catalogs, Helm integration, monitoring និងជាច្រើនទៀត។

យើងសង្ឃឹមថាអត្ថបទនេះគួរឱ្យចាប់អារម្មណ៍ និងមានប្រយោជន៍សម្រាប់អ្នក។ ហើយអ្នកអាចស្វែងរកធនធាន សម្ភារៈ និងរបស់ផ្សេងទៀតដែលមានប្រយោជន៍សម្រាប់ការអភិវឌ្ឍន៍នៅលើវេទិកា OpenShift នៅលើវិបផតថល។ អ្នកអភិវឌ្ឍន៍ Red Hat.

ប្រភព: www.habr.com