တောင်းပန်ပါတယ်၊ OpenShift၊ ကျွန်ုပ်တို့သည် သင့်အား အလုံအလောက်လေးမြတ်ခြင်းမရှိခဲ့ဘဲ သင့်အား ပေါ့ပေါ့တန်တန်လက်ခံခဲ့သည်။

ကျွန်ုပ်တို့၏ဝန်ထမ်းများသည် Kubernetes တွင် အပလီကေးရှင်းဖွံ့ဖြိုးတိုးတက်မှုနှင့် OpenShift တွင် ထိုသို့သောဖွံ့ဖြိုးတိုးတက်မှုဆိုင်ရာ သီးခြားအသေးစိတ်အချက်များအကြောင်း သုံးစွဲသူများနှင့် စကားစမြည်ပြောဆိုမှုများ အများအပြားရှိသောကြောင့် ဤပို့စ်ကို ရေးသားခဲ့ခြင်းဖြစ်သည်။

Kubernetes သည် Kubernetes မျှသာဖြစ်သည်ဟူသော စာတမ်းဖြင့် ကျွန်ုပ်တို့ များသောအားဖြင့် စတင်ကြပြီး OpenShift သည် Microsoft AKS သို့မဟုတ် Amazon EKS ကဲ့သို့ Kubernetes ပလပ်ဖောင်းတစ်ခု ဖြစ်နေပါပြီ။ ဤပလပ်ဖောင်းတစ်ခုစီတိုင်းသည် ပစ်မှတ်ပရိသတ်ကို ရည်ရွယ်သည့် ၎င်း၏ကိုယ်ပိုင်အားသာချက်များရှိသည်။ ထို့နောက်တွင်၊ သီးခြားပလပ်ဖောင်းများ၏ အားသာချက်များနှင့် အားနည်းချက်များကို နှိုင်းယှဉ်ပြောဆိုမှုအဖြစ် ပြောင်းလဲသွားပါသည်။

ယေဘုယျအားဖြင့်၊ "နားဆင်ပါ၊ OpenShift တွင် သို့မဟုတ် AKS တွင်၊ EKS တွင်၊ အချို့သော စိတ်ကြိုက် Kubernetes တွင် သို့မဟုတ် မည်သည့် Kubernetes တွင်မဆို မည်သည့်နေရာတွင်မဆို ကုဒ်ကို run ရန် ကိစ္စမရှိပါ။ (အတိုချုပ်ပြောရရင် KUK လို့ ခေါ်ရအောင်) "အဲဒါက တကယ်ကို ရိုးရှင်းပါတယ်၊ ဟိုမှာရော ဟိုမှာပါ"

ထို့နောက် ကျွန်ုပ်တို့သည် အရိုးရှင်းဆုံး “Hello World” ကိုယူရန် စီစဉ်ထားပြီး မည်သည့်အရာသည် သာမန်နှင့် KUC နှင့် Red Hat OpenShift Container Platform (နောင်တွင်၊ OCP သို့မဟုတ် ရိုးရိုး OpenShift) အကြား ကွာခြားချက်ကို ပြသရန် ၎င်း၏နမူနာကို အသုံးပြုပါသည်။

သို့သော်၊ ကျွန်ုပ်တို့ ဤပို့စ်ကိုရေးသောအခါတွင်၊ ကျွန်ုပ်တို့သည် OpenShift ကိုအသုံးပြုရာတွင် ကြာရှည်စွာအသုံးခံလာပြီဖြစ်ကြောင်း ကျွန်ုပ်တို့ သိရှိနားလည်လာပြီး ၎င်းသည် မည်သို့ကြီးထွားလာသည်နှင့် Kubernetes ဖြန့်ဖြူးမှုထက် များစွာပို၍သာလွန်သော အံ့သြဖွယ်ပလပ်ဖောင်းတစ်ခုအဖြစ်သို့ ပြောင်းလဲသွားသည်ကို သိရှိလိုက်ရပါသည်။ ကျွန်ုပ်တို့သည် OpenShift ၏ ရင့်ကျက်မှုနှင့် ရိုးရှင်းမှုကို ဦးစားပေးပြီး ၎င်း၏ထက်မြက်မှုကို မျက်ခြည်ပြတ်သွားတတ်သည်။

ယေဘူယျအားဖြင့်၊ တက်ကြွသောနောင်တအတွက်အချိန်ရောက်လာပြီ၊ ယခုကျွန်ုပ်တို့သည် KUK နှင့် OpenShift တွင်ကျွန်ုပ်တို့၏ “Hello World” ၏တာဝန်ပေးခြင်းကို အဆင့်ဆင့်နှိုင်းယှဉ်ပြီး တတ်နိုင်သမျှ ဓမ္မဓိဋ္ဌာန်ကျကျလုပ်ဆောင်ပါမည် (ကောင်းပြီ၊ တစ်ခါတစ်ရံတွင်ပြသခြင်းဖြင့်မှလွဲ၍ ဘာသာရပ်အပေါ် ပုဂ္ဂိုလ်ရေး သဘောထား။) ဤကိစ္စနှင့်ပတ်သက်ပြီး သဘောထားအမြင်သက်သက်ကို စိတ်ဝင်စားပါက ဖတ်ရှုနိုင်ပါသည်။ ဒီမှာ (EN). ပြီးတော့ ဒီပို့စ်မှာ အဖြစ်မှန်နဲ့ အချက်အလက်တွေကိုသာ စွဲမြဲနေမယ်။

ပြွတ်

ထို့ကြောင့် ကျွန်ုပ်တို့၏ “Hello World” သည် အစုအဖွဲ့များ လိုအပ်သည်။ ဆာဗာများ၊ စာရင်းသွင်းမှုများ၊ ကွန်ရက်များ၊ ဒေတာလွှဲပြောင်းခြင်း စသည်ဖြင့် အခကြေးငွေမယူရန် မည်သည့်အများပြည်သူ cloud များကိုမဆို "မရှိ" ဟု ချက်ချင်းပြောပါမည်။ ထို့ကြောင့်၊ ကျွန်ုပ်တို့သည် ရိုးရှင်းသော single-node အစုအဝေးကို ရွေးချယ်သည်။ မီနီကူဘီ (KUK အတွက်) နှင့် Code အဆင်သင့်ကွန်တိန်နာ (OpenShift အစုအဝေးအတွက်)။ ဤရွေးချယ်စရာနှစ်ခုလုံးသည် တပ်ဆင်ရန် အမှန်တကယ်လွယ်ကူသော်လည်း သင့်လက်ပ်တော့တွင် အရင်းအမြစ်များစွာ လိုအပ်မည်ဖြစ်သည်။

KUK-e တွင် စည်းဝေးပွဲ

ဒါကြောင့်ထိုပြည်၌သင်တို့သည်သွားပါ။

အဆင့် 1 - ကျွန်ုပ်တို့၏ကွန်တိန်နာပုံတည်ဆောက်ခြင်း။

ကျွန်ုပ်တို့၏ “Hello World” ကို minikube သို့ အသုံးပြုခြင်းဖြင့် စတင်ကြပါစို့။ ဒီလိုလုပ်ဖို့သင်လိုအပ်ပါလိမ့်မယ်:

1. 1. Docker ကို ထည့်သွင်းပါ။
2. 2. Git ကို install လုပ်ပါ။
3. 3. ထည့်သွင်းထားသော Maven (တကယ်တော့၊ ဤပရောဂျက်သည် mvnw binary ကို အသုံးပြုထားသောကြောင့် ၎င်းမပါဘဲ သင်လုပ်ဆောင်နိုင်သည်)။
4. 4. တကယ်တော့၊ အရင်းအမြစ်ကိုယ်တိုင်က i.e. repository clone github.com/gcolman/quarkus-hello-world.git

ပထမအဆင့်မှာ Quarkus ပရောဂျက်တစ်ခုကို ဖန်တီးရန်ဖြစ်သည်။ Quarkus.io နဲ့ တစ်ခါမှ မလုပ်ဖူးရင် ထိတ်လန့်မနေပါနဲ့ - လွယ်ပါတယ်။ သင်သည် ပရောဂျက်တွင် သင်အသုံးပြုလိုသော အစိတ်အပိုင်းများ (RestEasy၊ Hibernate၊ Amazon SQS၊ Camel စသည်) ကို ရွေးချယ်ပြီး သင်၏ပါဝင်မှုမရှိဘဲ Quarkus ကိုယ်တိုင်က maven archetype ကို configure ပြီး github တွင် အရာအားလုံးကို ထည့်သွင်းပါ။ ဆိုလိုသည်မှာ မောက်စ်ကို တစ်ချက်နှိပ်ရုံဖြင့် ပြီးပါပြီ။ ထို့ကြောင့် ကျွန်ုပ်တို့သည် Quarkus ကိုနှစ်သက်ကြသည်။

ကျွန်ုပ်တို့၏ “Hello World” ကို ကွန်တိန်နာပုံတစ်ခုအဖြစ် တည်ဆောက်ရန် အလွယ်ကူဆုံးနည်းလမ်းမှာ လိုအပ်သည့်အလုပ်အားလုံးကို လုပ်ဆောင်ပေးမည့် Docker အတွက် quarkus-maven extensions များကို အသုံးပြုခြင်းဖြစ်သည်။ Quarkus ထွန်းကားလာသည်နှင့်အမျှ၊ ၎င်းသည် အမှန်တကယ်လွယ်ကူပြီး ရိုးရှင်းပါသည်။ container-image-docker extension ကိုထည့်ကာ maven commands များကိုအသုံးပြု၍ ပုံများကိုဖန်တီးနိုင်သည်။

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

နောက်ဆုံးတွင် Maven ကို အသုံးပြု၍ ကျွန်ုပ်တို့၏ ပုံကို တည်ဆောက်ပါသည်။ ရလဒ်အနေဖြင့်၊ ကျွန်ုပ်တို့၏ အရင်းအမြစ်ကုဒ်သည် ကွန်တိန်နာ runtime ပတ်၀န်းကျင်တွင် လုပ်ဆောင်ပြီးသော အဆင်သင့်လုပ်ထားသော ကွန်တိန်နာပုံအဖြစ်သို့ ပြောင်းလဲသွားသည်။

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

ဒါပါပဲ၊ ယခု သင်သည် ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုကို port 8080 သို့ ပုံဖော်ခြင်းဖြင့် docker run command ဖြင့် container ကို စတင်နိုင်ပါပြီ။

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

container instance စတင်ပြီးနောက်၊ ကျန်ရှိသောအရာအားလုံးသည် ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုလုပ်ဆောင်နေသည့် curl command ကိုစစ်ဆေးရန်ဖြစ်သည်-

ဒါကြောင့် အရာရာတိုင်းဟာ အလုပ်လုပ်ပြီး တကယ်ကို လွယ်ကူရိုးရှင်းပါတယ်။

အဆင့် 2 – ကျွန်ုပ်တို့၏ ကွန်တိန်နာကို ကွန်တိန်နာပုံ သိုလှောင်ခန်းသို့ ပေးပို့ပါ။

ယခုအချိန်တွင်၊ ကျွန်ုပ်တို့ဖန်တီးထားသောပုံအား ကျွန်ုပ်တို့၏ဒေသခံကွန်တိန်နာသိုလှောင်မှုတွင် ပြည်တွင်း၌ သိမ်းဆည်းထားပါသည်။ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ COOK ပတ်ဝန်းကျင်တွင် ဤပုံကို အသုံးပြုလိုပါက၊ ၎င်းကို အခြား repository အချို့တွင် ထားရှိရပါမည်။ Kubernetes တွင် ထိုသို့သောအင်္ဂါရပ်များမရှိသောကြောင့် ကျွန်ုပ်တို့သည် dockerhub ကိုသုံးပါမည်။ ဘာကြောင့်လဲဆိုတော့ ပထမအချက်က အခမဲ့ဖြစ်ပြီး ဒုတိယအချက်ကတော့ လူတိုင်းနီးပါး လုပ်ပါတယ်။

၎င်းသည် အလွန်ရိုးရှင်းပြီး သင်လိုအပ်သမျှမှာ dockerhub အကောင့်တစ်ခုဖြစ်သည်။

ထို့ကြောင့်၊ ကျွန်ုပ်တို့သည် dockerhub ကိုထည့်သွင်းပြီး ကျွန်ုပ်တို့၏ပုံကို ထိုနေရာတွင် ပေးပို့ပါ။

အဆင့် 3 – Kubernetes ကိုဖွင့်ပါ။

ကျွန်ုပ်တို့၏ "Hello World" ကိုလည်ပတ်ရန် kubernetes configuration ကိုစုဝေးရန်နည်းလမ်းများစွာရှိသည်၊ သို့သော်ကျွန်ုပ်တို့သည်၎င်းတို့အနက်မှအရိုးရှင်းဆုံးကိုအသုံးပြုပါမည်၊ ဤသည်မှာကျွန်ုပ်တို့၏ပုံစံဖြစ်သည်...

ဦးစွာ၊ minikube အစုအဝေးကို စတင်ကြပါစို့။

minikube start

အဆင့် 4 – ကျွန်ုပ်တို့၏ ကွန်တိန်နာပုံကို အသုံးပြုပါ။

ယခု ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ကုဒ်နှင့် ကွန်တိန်နာပုံကို kubernetes ဖွဲ့စည်းမှုပုံစံများအဖြစ်သို့ ပြောင်းလဲရန် လိုအပ်ပါသည်။ တစ်နည်းအားဖြင့်၊ ကျွန်ုပ်တို့သည် dockerhub ရှိ ကျွန်ုပ်တို့၏ ကွန်တိန်နာပုံအား ညွှန်ပြသည့် pod နှင့် deployment အဓိပ္ပါယ်ဖွင့်ဆိုချက်တစ်ခု လိုအပ်ပါသည်။ ၎င်းကိုလုပ်ဆောင်ရန် အလွယ်ကူဆုံးနည်းလမ်းတစ်ခုမှာ ကျွန်ုပ်တို့၏ပုံသဏ္ဍာန်ကို ညွှန်ပြသည့် ဖန်တီးမှုဖြန့်ကျက်မှု အမိန့်ကို လုပ်ဆောင်ရန်ဖြစ်သည်-

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

ဤအမိန့်ဖြင့် ကျွန်ုပ်တို့၏ကွန်တိန်နာပုံအတွက် pod specification ပါရှိသင့်သည့် ဖြန့်ကျက်ဖွဲ့စည်းမှုပုံစံတစ်ခုကို ဖန်တီးရန် ကျွန်ုပ်တို့၏ COO အား ပြောခဲ့သည်။ ဤအမိန့်သည် ကျွန်ုပ်တို့၏ minikube အစုအဝေးသို့လည်း ဤဖွဲ့စည်းပုံကို အသုံးပြုမည်ဖြစ်ပြီး၊ ကျွန်ုပ်တို့၏ ကွန်တိန်နာပုံကို ဒေါင်းလုဒ်လုပ်ပြီး အစုအဝေးတွင် ပေါ့ဒ်ကို စတင်မည့် ဖြန့်ကျက်မှုတစ်ခုကို ဖန်တီးပါမည်။

အဆင့် 5 – ကျွန်ုပ်တို့၏ ဝန်ဆောင်မှုကို ဖွင့်ပါ။

ယခု ကျွန်ုပ်တို့တွင် အသုံးပြုထားသည့် ကွန်တိန်နာပုံတစ်ပုံရှိပြီး၊ အမှန်မှာ ကျွန်ုပ်တို့၏ကုဒ်တွင် ပရိုဂရမ်ထည့်သွင်းထားသည့် ဤ Restful ဝန်ဆောင်မှုသို့ ပြင်ပဝင်ရောက်ခွင့်ကို မည်သို့စီစဉ်သတ်မှတ်ရမည်ကို စဉ်းစားရမည့်အချိန်ဖြစ်သည်။

ဤနေရာတွင် နည်းလမ်းများစွာရှိသည်။ ဥပမာအားဖြင့်၊ သင်သည် ဝန်ဆောင်မှုများနှင့် အဆုံးမှတ်များကဲ့သို့သော သင့်လျော်သော Kubernetes အစိတ်အပိုင်းများကို အလိုအလျောက်ဖန်တီးရန် expose အမိန့်ကို အသုံးပြုနိုင်သည်။ အမှန်တကယ်တော့၊ ကျွန်ုပ်တို့၏ deployment object အတွက် expose command ကို လုပ်ဆောင်ခြင်းဖြင့်၊

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

expose command ၏ "-type" option ကို ခဏလောက် အချိန်ယူကြည့်ကြပါစို့။

ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုကိုလုပ်ဆောင်ရန် လိုအပ်သောအစိတ်အပိုင်းများကို ဖော်ထုတ်ဖန်တီးသည့်အခါ၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ဆော့ဖ်ဝဲလ်သတ်မှတ်ထားသောကွန်ရက်အတွင်းတွင်ရှိသော hello-quarkus ဝန်ဆောင်မှုထံသို့ ပြင်ပမှချိတ်ဆက်နိုင်ရန်လိုအပ်ပါသည်။ နှင့် parameter ပုံစံ ဤကွန်ရက်သို့ အသွားအလာလမ်းကြောင်းပေးရန်အတွက် load balancers ကဲ့သို့သော အရာများကို ဖန်တီးပြီး ချိတ်ဆက်နိုင်စေပါသည်။

ဥပမာအားဖြင့်၊ စာဖြင့် type=LoadBalancerကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ Kubernetes အစုအဝေးသို့ ချိတ်ဆက်ရန်အတွက် အများသူငှာ cloud တွင် load balancer ကို အလိုအလျောက် ပံ့ပိုးပေးပါသည်။ ဤသည်မှာ ကောင်းမွန်သော်လည်း၊ ထိုသို့သောဖွဲ့စည်းပုံသည် သီးခြားအများပြည်သူ cloud နှင့် တင်းကြပ်စွာ ချိတ်ဆက်ထားမည်ဖြစ်ပြီး မတူညီသောပတ်ဝန်းကျင်ရှိ Kubernetes ဖြစ်ရပ်များကြားတွင် လွှဲပြောင်းရန် ပို၍ခက်ခဲလိမ့်မည်ဖြစ်ကြောင်း သင်နားလည်ရန်လိုအပ်ပါသည်။

ကျွန်ုပ်တို့၏ဥပမာ type=NodePortဆိုလိုသည်မှာ၊ ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုသည် node ၏ IP လိပ်စာနှင့် ပို့တ်နံပါတ်ဖြင့် ဝင်ရောက်ထားပါသည်။ ဤရွေးချယ်မှုသည် သင့်အား မည်သည့် အများသူငှာ တိမ်တိုက်များကိုမျှ အသုံးမပြုရန် ခွင့်ပြုသော်လည်း နောက်ထပ် အဆင့်များစွာ လိုအပ်ပါသည်။ ပထမဦးစွာ၊ သင်သည်သင်၏ကိုယ်ပိုင် load balancer လိုအပ်သည်၊ ထို့ကြောင့်ကျွန်ုပ်တို့သည်ကျွန်ုပ်တို့၏အစုအဝေးတွင် NGINX load balancer ကိုအသုံးပြုပါမည်။

အဆင့် 6 – load balancer ကို install လုပ်ပါ။

minikube တွင် ingress controller များကဲ့သို့သော ပြင်ပမှဝင်ရောက်နိုင်သောအစိတ်အပိုင်းများကိုဖန်တီးရန်ပိုမိုလွယ်ကူစေသည့်ပလပ်ဖောင်းလုပ်ဆောင်ချက်များစွာရှိသည်။ Minikube သည် Nginx ingress controller ဖြင့် ထုပ်ပိုးလာကာ ကျွန်ုပ်တို့လုပ်ရမည့်အရာမှာ ၎င်းကို enable လုပ်ပြီး configure လုပ်ရန်ဖြစ်သည်။

minikube addons enable ingress

ယခုအခါ ကျွန်ုပ်တို့၏ minikube အစုအဝေးအတွင်းတွင် လုပ်ဆောင်မည့် command တစ်ခုတည်းဖြင့် Nginx ingress controller တစ်ခုကို ဖန်တီးပါမည်။

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

အဆင့် 7 – ingress ကိုသတ်မှတ်ခြင်း။

ယခု ကျွန်ုပ်တို့သည် hello-quarkus တောင်းဆိုမှုများကို လက်ခံနိုင်စေရန် Nginx ingress controller ကို configure လုပ်ရန် လိုအပ်ပါသည်။

နောက်ဆုံးအနေနှင့်၊ ကျွန်ုပ်တို့သည် ဤဖွဲ့စည်းပုံကို အသုံးပြုရန်လိုအပ်သည်။

kubectl apply -f ingress.yml

ကျွန်ုပ်တို့သည် ဤအရာအားလုံးကို ကျွန်ုပ်တို့၏ကိုယ်ပိုင်ကွန်ပြူတာတွင် လုပ်ဆောင်နေသောကြောင့်၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ NGINX load balancer သို့ http တောင်းဆိုမှုများကို /etc/ hosts ဖိုင်သို့ ရိုးရိုးရှင်းရှင်းထည့်သွင်းပေးပါသည်။

192.168.99.100 hello-quarkus.info

ဒါပါပဲ၊ ယခု ကျွန်ုပ်တို့၏ minikube ဝန်ဆောင်မှုကို Nginx ingress controller မှတဆင့် ပြင်ပတွင် ဝင်ရောက်နိုင်ပါပြီ။

ကောင်းပြီ၊ အဲဒါက လွယ်တယ် မဟုတ်လား။ ဒါမှမဟုတ် သိပ်မများဘူးလား?

OpenShift (Code Ready Containers) တွင် လုပ်ဆောင်နေသည်

ယခု ဤအရာအားလုံးကို Red Hat OpenShift Container Platform (OCP) တွင် မည်သို့လုပ်ဆောင်သည်ကို ကြည့်ကြပါစို့။

minikube ကဲ့သို့ပင်၊ ကျွန်ုပ်တို့သည် Code Ready Containers (CRC) ပုံစံဖြင့် single-node OpenShift အစုအဝေးဒီဇိုင်းကို ရွေးချယ်ပါသည်။ ယခင်က၊ ၎င်းကို minishift ဟုခေါ်ပြီး OpenShift Origin ပရောဂျက်အပေါ် အခြေခံခဲ့သော်လည်း ယခုအခါ ၎င်းသည် CRC ဖြစ်ပြီး Red Hat ၏ OpenShift Container Platform ပေါ်တွင် တည်ဆောက်ထားသည်။

ဤတွင် ကျွန်ုပ်တို့တောင်းပန်ပါသည်- "OpenShift သည် အံ့သြဖွယ်ကောင်းသည်!"

အစပိုင်းတွင်၊ OpenShift တွင် ဖွံ့ဖြိုးတိုးတက်မှုသည် Kubernetes ပေါ်ရှိ ဖွံ့ဖြိုးတိုးတက်မှုနှင့် ကွာခြားမှုမရှိဟု ရေးရန် စိတ်ကူးထားသည်။ အနှစ်သာရအားဖြင့် ဒါက ဘယ်လိုလဲ။ ဒါပေမယ့် ဒီပို့စ်ကိုရေးတဲ့ လုပ်ငန်းစဉ်မှာ OpenShift မရှိတဲ့အခါ အပိုလှုပ်ရှားမှုတွေ ဘယ်လောက်လုပ်ရမလဲဆိုတာ သတိရမိပြီး အဲဒါက အံ့သြစရာကောင်းပါတယ်။ အရာအားလုံးကို လွယ်လွယ်ကူကူ ပြီးသွားသောအခါ ကျွန်ုပ်တို့နှစ်သက်သည်၊ ကျွန်ုပ်တို့၏ဥပမာသည် Minikube နှင့် နှိုင်းယှဉ်ပါက OpenShift တွင် အသုံးပြုရန်နှင့် လုပ်ဆောင်ရန် မည်မျှလွယ်ကူသည်က ဤပို့စ်ကို ရေးသားရန် ကျွန်ုပ်တို့အား လှုံ့ဆော်ပေးပါသည်။

လုပ်ငန်းစဉ်ကို ဖြတ်သန်းပြီး ဘာလုပ်ရမလဲဆိုတာ ကြည့်ရအောင်။

ထို့ကြောင့်၊ minikube ဥပမာတွင်၊ ကျွန်ုပ်တို့သည် Docker ဖြင့်စတင်ခဲ့သည်... စောင့်ဆိုင်းပါ၊ စက်ပေါ်တွင် Docker ထည့်သွင်းရန်မလိုအပ်တော့ပါ။

ကျွန်ုပ်တို့သည် local git မလိုအပ်ပါ။
Maven မလိုအပ်ပါ။
ပြီးတော့ မင်းလက်နဲ့ ကွန်တိန်နာပုံတစ်ခုကို ဖန်တီးဖို့ မလိုဘူး။
ပြီးတော့ ကွန်တိန်နာပုံတွေရဲ့ သိုလှောင်မှုကို သင်ရှာနေစရာမလိုပါဘူး။
ထို့အပြင် ingress controller ကိုတပ်ဆင်ရန်မလိုအပ်ပါ။
ပြီးတော့ ingress ကို configure လုပ်စရာမလိုပါဘူး။

မင်းနားလည်တယ်မဟုတ်လား ကျွန်ုပ်တို့၏အပလီကေးရှင်းကို OpenShift တွင်အသုံးပြုရန်နှင့်အသုံးပြုရန်၊ အထက်ဖော်ပြပါများထဲမှတစ်ခုမျှမလိုအပ်ပါ။ ပြီးတော့ ဖြစ်စဉ်ကိုယ်တိုင်က ဒီလိုဖြစ်ပုံရတယ်။

အဆင့် 1 – သင်၏ OpenShift အစုအဝေးကို စတင်ပါ။

ကျွန်ုပ်တို့သည် အခြေခံအားဖြင့် Minikube နှင့် တူညီသော Red Hat မှ Code Ready Containers ကို အသုံးပြုသော်လည်း ပြည့်စုံသော single-node Openshift အစုအဝေးဖြင့်သာ အသုံးပြုပါသည်။

crc start

အဆင့် 2 – အပလီကေးရှင်းကို OpenShift အစုအဝေးတွင် တည်ဆောက်ပြီး အသုံးချပါ။

ဤအဆင့်တွင် OpenShift ၏ရိုးရှင်းမှုနှင့်အဆင်ပြေမှုကို၎င်း၏ဂုဏ်အသရေအားလုံးတွင်ထင်ရှားစေသည်။ Kubernetes ဖြန့်ချီမှုများ အားလုံးကဲ့သို့ပင်၊ အစုအဖွဲ့တစ်ခုအတွင်း အက်ပ်တစ်ခုကို လုပ်ဆောင်ရန် နည်းလမ်းများစွာရှိသည်။ KUK ၏ကိစ္စတွင်ကဲ့သို့၊ ကျွန်ုပ်တို့သည် အရိုးရှင်းဆုံးကို အထူးရွေးချယ်သည်။

OpenShift သည် containerized applications များဖန်တီးခြင်းနှင့် လုပ်ဆောင်ခြင်းအတွက် ပလပ်ဖောင်းတစ်ခုအဖြစ် အမြဲတမ်းတည်ဆောက်ထားသည်။ ကွန်တိန်နာတည်ဆောက်ခြင်းသည် ဤပလပ်ဖောင်း၏ အဓိကကျသော အစိတ်အပိုင်းတစ်ခုဖြစ်သည်၊ ထို့ကြောင့် ဆက်စပ်အလုပ်များအတွက် နောက်ထပ် Kubernetes အရင်းအမြစ်များစွာရှိပါသည်။

ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏အရင်းအမြစ် (ကုဒ် သို့မဟုတ် binaries) ကိုယူရန်နှင့် OpenShift အစုအဝေးတစ်ခုပေါ်တွင် လုပ်ဆောင်သည့် ကွန်တိန်နာပုံတစ်ပုံအဖြစ်သို့ ပြောင်းလဲရန် မတူညီသောနည်းလမ်းများစွာရှိသည့် OpenShift ၏ Source 2 Image (S2I) လုပ်ငန်းစဉ်ကို အသုံးပြုပါမည်။

ဒါကိုလုပ်ဖို့ နှစ်ခုလိုတယ်။

• ကျွန်ုပ်တို့၏အရင်းအမြစ်ကုဒ်သည် git repository တွင်ရှိသည်။
• တည်ဆောက်မှုလုပ်ဆောင်မည့်အပေါ် အခြေခံ၍ Builder ပုံ။

Red Hat နှင့် ရပ်ရွာအဆင့်တွင် ထိန်းသိမ်းထားသော ထိုကဲ့သို့သော ပုံများစွာ ရှိပြီး Java application ကို တည်ဆောက်နေသောကြောင့် OpenJDK image ကို အသုံးပြုပါမည်။

OpenShift Developer graphical console နှင့် command line တို့မှ S2I build ကို သင် run နိုင်ပါသည်။ ကျွန်ုပ်တို့သည် တည်ဆောက်သူရုပ်ပုံနှင့် ကျွန်ုပ်တို့၏အရင်းအမြစ်ကုဒ်ကို ဘယ်မှာရနိုင်သည်ကို ပြောပြသည့် new-app command ကိုအသုံးပြုပါမည်။

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

ဒါပါပဲ၊ ကျွန်တော်တို့ရဲ့ application ကိုဖန်တီးထားပါတယ်။ ထိုသို့လုပ်ဆောင်ရာတွင်၊ S2I လုပ်ငန်းစဉ်သည် အောက်ပါအရာများကို လုပ်ဆောင်ခဲ့သည်။

• အပလီကေးရှင်းတည်ဆောက်ခြင်းနှင့် သက်ဆိုင်သည့်အရာအားလုံးအတွက် ဝန်ဆောင်မှုတည်ဆောက်မှုပုံစံတစ်ခုကို ဖန်တီးခဲ့သည်။
• OpenShift Build config ကိုဖန်တီးခဲ့သည်။
• ကျွန်ုပ်သည် တည်ဆောက်သူပုံကို အတွင်းပိုင်း OpenShift docker မှတ်ပုံတင်ခြင်းသို့ ဒေါင်းလုဒ်လုပ်ခဲ့သည်။
• "Hello World" ကို စက်တွင်းသိုလှောင်ခန်းသို့ ကူးထည့်သည်။
• အဲဒီမှာ maven pom ကိုတွေ့ခဲ့တယ်၊ ဒါကြောင့် maven ကိုသုံးပြီး application ကိုပြုစုခဲ့တယ်။
• စုစည်းထားသော Java အပလီကေးရှင်း ပါ၀င်သော ကွန်တိန်နာပုံအသစ်ကို ဖန်တီးပြီး ဤပုံကို အတွင်းပိုင်း ကွန်တိန်နာ မှတ်ပုံတင်ခြင်းတွင် ထည့်သွင်းပါ။
• pod၊ ဝန်ဆောင်မှု၊ စသည်တို့အတွက် သတ်မှတ်ချက်များဖြင့် Kubernetes ဖြန့်ကျက်မှုကို ဖန်တီးခဲ့သည်။
• ကွန်တိန်နာပုံကို စတင်ဖြန့်ကျက်ခဲ့တယ်။
• ဝန်ဆောင်မှု build-pod ကို ဖယ်ရှားခဲ့သည်။

ဤစာရင်းတွင် များစွာရှိသည်၊ သို့သော် အဓိကအချက်မှာ တည်ဆောက်မှုအားလုံးသည် OpenShift တွင် သီးသန့်ဖြစ်နေကြောင်း၊ အတွင်း Docker မှတ်ပုံတင်ခြင်းမှာ OpenShift အတွင်းဖြစ်ပြီး တည်ဆောက်မှုလုပ်ငန်းစဉ်သည် Kubernetes အစိတ်အပိုင်းအားလုံးကို ဖန်တီးပြီး ၎င်းတို့ကို အစုအဝေးတွင် လုပ်ဆောင်ခြင်းဖြစ်သည်။

ကွန်ဆိုးလ်တွင် S2I လွှင့်တင်မှုကို သင်မြင်သာစွာ စောင့်ကြည့်ပါက၊ တည်ဆောက်မှုပြီးမြောက်သောအခါတွင် build pod မည်ကဲ့သို့ စတင်သည်ကို သင်မြင်နိုင်သည်။

ယခု builder pod မှတ်တမ်းများကို ကြည့်ကြပါစို့။ ပထမဦးစွာ၊ ၎င်းသည် maven ၏အလုပ်နှင့်ကျွန်ုပ်တို့၏ java အပလီကေးရှင်းကိုတည်ဆောက်ရန်အတွက် ဒေါင်းလုဒ်လုပ်ပုံကိုပြသသည်။

maven တည်ဆောက်မှုပြီးမြောက်ပြီးနောက်၊ ကွန်တိန်နာပုံတည်ဆောက်မှုကို စတင်ပြီး၊ ထို့နောက် ဤတည်ဆောက်ထားသောပုံအား အတွင်းပိုင်းသိုလှောင်ခန်းသို့ ပေးပို့သည်။

ဒါပဲ၊ တည်ဆောက်မှု လုပ်ငန်းစဉ်ပြီးပါပြီ။ ယခုကျွန်ုပ်တို့၏အပလီကေးရှင်း၏ pods နှင့် ဝန်ဆောင်မှုများသည် cluster တွင်လည်ပတ်နေပြီဖြစ်ကြောင်းသေချာပါစေ။

oc get service

ဒါပါပဲ။ ပြီးတော့ အသင်းတစ်သင်းတည်းပါပဲ။ ကျွန်ုပ်တို့လုပ်ရမှာက ဤဝန်ဆောင်မှုကို ပြင်ပမှဝင်ရောက်နိုင်ရန် ဖော်ထုတ်ရန်ဖြစ်သည်။

အဆင့် 3 – ပြင်ပမှဝင်ရောက်ခွင့်အတွက် ဝန်ဆောင်မှုကို ဖော်ထုတ်ပါ။

KUC ကိစ္စကဲ့သို့ပင်၊ OpenShift ပလပ်ဖောင်းတွင် ကျွန်ုပ်တို့၏ “Hello World” သည် အစုအဝေးအတွင်းရှိ ဝန်ဆောင်မှုထံသို့ ပြင်ပလမ်းကြောင်းများကို ညွှန်ပြရန် router တစ်ခု လိုအပ်ပါသည်။ OpenShift သည် ၎င်းကို အလွန်လွယ်ကူစေသည်။ ပထမဦးစွာ၊ HAProxy လမ်းကြောင်းပြခြင်း အစိတ်အပိုင်းကို ပုံမှန်အားဖြင့် အစုအဝေးတွင် ထည့်သွင်းထားသည် (၎င်းကို တူညီသော NGINX သို့ ပြောင်းနိုင်သည်)။ ဒုတိယအနေဖြင့်၊ Routes ဟုခေါ်သော အထူးစီစဉ်သတ်မှတ်နိုင်သော အရင်းအမြစ်များရှိပြီး ကောင်းမွန်သော Kubernetes အဟောင်းတွင် Ingress အရာဝတ္ထုများကို အမှတ်ရနေသည် (တကယ်တော့ OpenShift ၏လမ်းကြောင်းများသည် ယခုအခါ OpenShift တွင်အသုံးပြုနိုင်သည့် Ingress အရာဝတ္ထုများ၏ ဒီဇိုင်းကို များစွာလွှမ်းမိုးခဲ့သည်)၊ သို့သော် ကျွန်ုပ်တို့၏ "Hello World" အတွက် နှင့် အခြားကိစ္စအားလုံးနီးပါးတွင်၊ စံလမ်းကြောင်းသည် အပိုဖွဲ့စည်းမှုမရှိဘဲ ကျွန်ုပ်တို့အတွက် လုံလောက်ပါသည်။

“Hello World” အတွက် လည်ပတ်နိုင်သော FQDN တစ်ခုကို ဖန်တီးရန် (ဟုတ်ပါသည်၊ OpenShiift တွင် ဝန်ဆောင်မှုအမည်များဖြင့် လမ်းကြောင်းပေးရန်အတွက် ၎င်း၏ကိုယ်ပိုင် DNS ပါရှိသည်)၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုကို ရိုးရိုးရှင်းရှင်းဖော်ပြပါမည်။

oc expose service quarkus-hello-world

အသစ်ဖန်တီးထားသော လမ်းကြောင်းကို ကြည့်လျှင် FQDN နှင့် အခြားလမ်းကြောင်းဆိုင်ရာ အချက်အလက်များကို ထိုနေရာတွင် ရှာတွေ့နိုင်သည်-

oc get route

နောက်ဆုံးတွင်၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုကို ဘရောက်ဆာမှ ဝင်ရောက်ကြည့်ရှုနိုင်သည်-

ဒါပေမယ့် အခုက တကယ်လွယ်သွားပြီ။

ကျွန်ုပ်တို့သည် Kubernetes နှင့် ဤနည်းပညာကို ကျွန်ုပ်တို့လုပ်ဆောင်နိုင်စေသည့်အရာအားလုံးကိုနှစ်သက်ပြီး ရိုးရှင်းမှုနှင့် လွယ်ကူမှုကိုလည်း ကျွန်ုပ်တို့နှစ်သက်ပါသည်။ Kubernetes သည် ဖြန့်ဝေနိုင်သော၊ အရွယ်တင်နိုင်သော ကွန်တိန်နာများ၏ လည်ပတ်မှုကို မယုံနိုင်လောက်အောင် ရိုးရှင်းစေရန် ဖန်တီးထားသော်လည်း ၎င်း၏ရိုးရှင်းမှုသည် ယနေ့ခေတ်တွင် အပလီကေးရှင်းများကို ထုတ်လုပ်ရန် မလုံလောက်တော့ပါ။ ဤနေရာတွင် OpenShift သည် ဆော့ဖ်ဝဲရေးသားသူအတွက် အဓိကရည်ရွယ်ပြီး Kubernetes ကို အချိန်နှင့်အညီ ပေးဆောင်ကာ ဆော့ကစားလာပါသည်။ S2I၊ ODI၊ Developer Portal၊ OpenShift Operator Framework၊ IDE ပေါင်းစည်းမှု၊ Developer Catalogues၊ Helm ပေါင်းစပ်မှု၊ စောင့်ကြည့်မှုနှင့် အခြားများစွာသော အခြားကိရိယာများ ကဲ့သို့သော ကိရိယာများဖန်တီးမှု အပါအဝင် ဆော့ဖ်ဝဲအင်ဂျင်နီယာအတွက် OpenShift ပလပ်ဖောင်းကို အံဝင်ခွင်ကျဖြစ်စေရန် ကြိုးပမ်းအားထုတ်မှုများစွာကို ရင်းနှီးမြှုပ်နှံထားပါသည်။

ဤဆောင်းပါးသည် သင့်အတွက် စိတ်ဝင်စားစရာကောင်းပြီး အသုံးဝင်မည်ဟု မျှော်လင့်ပါသည်။ ပေါ်တယ်ပေါ်တယ် OpenShift ပလပ်ဖောင်းတွင် ဖွံ့ဖြိုးတိုးတက်မှုအတွက် အသုံးဝင်သော နောက်ထပ်အရင်းအမြစ်များ၊ ပစ္စည်းများနှင့် အခြားအရာများကို သင်ရှာဖွေနိုင်သည်။ Red Hat Developers များ.

source: www.habr.com