Quarkus သည် မရှိမဖြစ်လိုအပ်သော နှင့် ဓာတ်ပြုမှု ပရိုဂရမ်ကို ပေါင်းစပ်ပုံ

ယခုနှစ်တွင် ကျွန်ုပ်တို့သည် ကွန်တိန်နာအခင်းအကျင်းများကို အလေးအနက်ထား၍ တီထွင်ဖန်တီးရန် စီစဉ်ထားသည်။ Cloud-Native Java и Kubernetes. ဤအကြောင်းအရာများ၏ ကျိုးကြောင်းဆီလျော်သော ဆက်စပ်မှုတစ်ခုသည် Quarkus မူဘောင်နှင့်ပတ်သက်၍ ဇာတ်လမ်းတစ်ပုဒ်ဖြစ်နေပြီဖြစ်သည်။ စဉ်းစား Habre ပေါ်တွင် ယနေ့ဆောင်းပါးသည် "subatomic superfast Java" ၏ဒီဇိုင်းနှင့် Quarkus မှ Enterprise သို့ပေးသောကတိအကြောင်းပိုမိုနည်းပါးသည်။

Java နှင့် JVM တို့သည် အလွန်ရေပန်းစားနေသေးသော်လည်း serverless နည်းပညာများနှင့် cloud-native microservices များဖြင့် လုပ်ဆောင်သောအခါတွင်၊ Java နှင့် အခြားသော JVM ဘာသာစကားများသည် memory space များလွန်း၍ load လုပ်ရန် နှေးကွေးလွန်းသောကြောင့် ၎င်းတို့ကို အသုံးပြုမှု နည်းပါးလာပြီး၊ သက်တမ်းတိုသော ကွန်တိန်နာများနှင့် အသုံးပြုရန် မသင့်တော်ပါ။ ကံကောင်းစွာဖြင့်၊ ဤအခြေအနေသည် Quarkus ကြောင့် ယခု စတင်ပြောင်းလဲနေပြီဖြစ်သည်။

Superfast subatomic Java သည် အဆင့်အသစ်သို့ ရောက်ရှိသွားပါပြီ။

ထုတ်ဝေမှု ၄၂ ခု၊ ရပ်ရွာအလုပ် ၈ လနှင့် အံ့သြဖွယ် developer 42 ခု - ၎င်းအားလုံး၏ရလဒ်သည် 8 ခုနှစ် နိုဝင်ဘာလတွင် ထုတ်ဝေခဲ့သည် Quarkus ၂ပရောဂျက်၏ ဖွံ့ဖြိုးတိုးတက်မှုတွင် အရေးပါသော မှတ်တိုင်တစ်ခုအဖြစ် အမှတ်အသားပြုသည့် ထုတ်ဝေမှုတစ်ခုဖြစ်ပြီး အေးမြသောအင်္ဂါရပ်များနှင့် စွမ်းဆောင်ရည်များစွာကို ပေးဆောင်သည် (၎င်းတို့အကြောင်း ပိုမိုဖတ်ရှုနိုင်သည် ကြေငြာချက်).

ယနေ့တွင် Quarkus သည် မရှိမဖြစ်လိုအပ်သော နှင့် ဓာတ်ပြုမှုဆိုင်ရာ ပရိုဂရမ်းမင်းပုံစံများကို တစ်ခုတည်းသော reactive core သို့ မည်သို့ပေါင်းစပ်ကြောင်းပြသပါမည်။ ကျွန်ုပ်တို့သည် သမိုင်းအကျဉ်းဖြင့် စတင်ပြီး Quarkus ၏ ဓာတ်ပြုမှု core dualism သည် အဘယ်အရာနှင့် မည်သို့မည်ပုံအကြောင်း အသေးစိတ်ကို လေ့လာပါမည်။ ဂျာဗား-Developers များသည် ဤအကျိုးကျေးဇူးများကို အသုံးချနိုင်သည်။

မိုက်ခရိုဝန်ဆောင်မှုများ, ဗိသုကာလက်ရာများကို မောင်းနှင်သည့်ဖြစ်ရပ် и serverless-functions - ဒါတွေအားလုံးဟာ ဒီနေ့ခေတ်မှာ ထွန်းကားလာတဲ့ အတိုင်းပါပဲ။ မကြာသေးမီက၊ cloud-centric ဗိသုကာများဖန်တီးမှုသည် ပိုမိုလွယ်ကူပြီး ပိုမိုလွယ်ကူလာသော်လည်း အထူးသဖြင့် Java developer များအတွက် ပြဿနာများ ရှိနေဆဲဖြစ်သည်။ ဥပမာအားဖြင့်၊ serverless functions နှင့် microservices များတွင်၊ startup time ကိုလျှော့ချရန်၊ memory သုံးစွဲမှုကို လျှော့ချရန်နှင့် ၎င်းတို့၏ ဖွံ့ဖြိုးတိုးတက်မှုကို ပိုမိုအဆင်ပြေစေပြီး ပျော်ရွှင်ဖွယ်ဖြစ်စေရန် အရေးတကြီးလိုအပ်ပါသည်။ Java သည် ကွန်တိန်နာများအတွက် ergonomics လုပ်ဆောင်နိုင်စွမ်း စသည်တို့ကဲ့သို့ မကြာသေးမီနှစ်များအတွင်း တိုးတက်မှုများစွာကို ပြုလုပ်ခဲ့သည်။ သို့သော်လည်း Java ကို ကွန်တိန်နာတစ်ခုတွင် ကောင်းစွာအလုပ်လုပ်နိုင်ရန် ခက်ခဲနေဆဲဖြစ်သည်။ ထို့ကြောင့် container-oriented Java အပလီကေးရှင်းများကို တီထွင်ရာတွင် အထူးသဖြင့် စူးရှသော Java ၏ မွေးရာပါ ရှုပ်ထွေးမှုများကို ကြည့်ရှုခြင်းဖြင့် စတင်ပါမည်။

ပထမဆုံး သမိုင်းကို လေ့လာကြည့်ရအောင်။

ချောင်းများနှင့် ကွန်တိန်နာများ

ဗားရှင်း 8u131 မှစတင်၍ Java သည် ergonomics လုပ်ဆောင်နိုင်စွမ်းကို မြှင့်တင်မှုများကြောင့် ကွန်တိန်နာများကို အနည်းနှင့်အများ ပံ့ပိုးပေးလာသည်။ အထူးသဖြင့်၊ JVM သည် ယခုအခါ ၎င်းသည် ပရိုဆက်ဆာ core မည်မျှလည်ပတ်နေသည်ကို သိရှိပြီး thread pools—ပုံမှန်အားဖြင့် fork/join pools—နှင့်အညီ၊ ဟုတ်ပါတယ်၊ ဒါကကောင်းတယ်၊ ဒါပေမယ့် HTTP ဆာဗာတွေကိုသုံးပြီး Tomcat၊ Jetty စသည်တို့မှာ အလုပ်လုပ်တဲ့ သမားရိုးကျဝဘ်အက်ပ်တစ်ခုလို့ ဆိုကြပါစို့။ ရလဒ်အနေဖြင့်၊ ဤအပလီကေးရှင်းသည် သီးခြားစာတွဲတစ်ခုစီကို တောင်းဆိုမည်ဖြစ်ပြီး၊ ဥပမာ၊ ဒေတာဘေ့စ်၊ ဖိုင်များ သို့မဟုတ် အခြားဝန်ဆောင်မှုများကို ဝင်ရောက်သည့်အခါတွင် I/O လုပ်ဆောင်ချက်များကို စောင့်ဆိုင်းနေချိန်တွင် ၎င်းအား ပိတ်ဆို့ရန် ခွင့်ပြုမည်ဖြစ်သည်။ ဆိုလိုသည်မှာ၊ ထိုကဲ့သို့သော အပလီကေးရှင်းတစ်ခု၏ အရွယ်အစားသည် ရရှိနိုင်သော cores အရေအတွက်ပေါ်တွင်မူတည်ခြင်းမရှိသော်လည်း တစ်ပြိုင်နက်တည်း တောင်းဆိုမှုအရေအတွက်ပေါ်တွင် မူတည်ပါသည်။ ထို့အပြင်၊ ဆိုလိုသည်မှာ cores အရေအတွက်ဆိုင်ရာ Kubernetes ရှိ ခွဲတမ်းများ သို့မဟုတ် ကန့်သတ်ချက်များသည် ဤနေရာတွင် များစွာအထောက်အကူဖြစ်လိမ့်မည်မဟုတ်ကြောင်းနှင့် ယင်းကိစ္စသည် နောက်ဆုံးတွင် ပိတ်ဆို့ခြင်းတွင် အဆုံးသတ်သွားမည်ဖြစ်သည်။

မှတ်ဉာဏ်ကုန်ခန်းခြင်း။

Threads များသည် Memory ဖြစ်သည်။ ကွန်တိန်နာအတွင်းမှတ်ဉာဏ်ကန့်သတ်ချက်များသည် panacea မဟုတ်ပါ။ အပလီကေးရှင်းများနှင့် လိုင်းနံပါတ်များကို တိုးမြှင့်လိုက်ရုံဖြင့် မကြာမီ သို့မဟုတ် နောက်ပိုင်းတွင် သင်သည် ကူးပြောင်းမှုအကြိမ်ရေအတွက် အရေးပါသော တိုးမြင့်လာသည်နှင့် ရလဒ်အနေဖြင့် စွမ်းဆောင်ရည် ကျဆင်းသွားမည်ဖြစ်သည်။ ထို့အပြင်၊ အကယ်၍ သင့်အပလီကေးရှင်းသည် သမားရိုးကျ microservice frameworks များကိုအသုံးပြုသည်၊ သို့မဟုတ် database နှင့်ချိတ်ဆက်သည်၊ သို့မဟုတ် caching ကိုအသုံးပြုသည် သို့မဟုတ် memory up ကိုအသုံးပြုပါက၊ သင်သည် JVM အတွင်းသို့ကြည့်ရှုရန်နှင့်၎င်းကိုမသတ်ဘဲ memory ကိုမည်သို့စီမံခန့်ခွဲသည်ကိုသိသာထင်ရှားသော tool တစ်ခုလိုအပ်ပါသည်။ JVM ကိုယ်တိုင် (ဥပမာ၊ XX:+UseCGroupMemoryLimitForHeap)။ Java 9 မှစတင်၍ JVM သည် cgroups များကိုလက်ခံကာ လိုက်လျောညီထွေဖြစ်အောင် လိုက်လျောညီထွေဖြစ်အောင် သင်ယူခဲ့ပြီး memory ကို သိမ်းဆည်းခြင်းနှင့် စီမံခန့်ခွဲခြင်းမှာ ရှုပ်ထွေးသောကိစ္စတစ်ခုအဖြစ် ကျန်ရှိနေဆဲဖြစ်သည်။

ခွဲတမ်းများနှင့် ကန့်သတ်ချက်များ

Java 11 သည် CPU ခွဲတမ်း (PreferContainerQuotaForCPUCount ကဲ့သို့) အတွက် ပံ့ပိုးမှုကို မိတ်ဆက်ပေးခဲ့သည်။ Kubernetes သည် ကန့်သတ်ချက်များနှင့် ခွဲတမ်းများအတွက် ပံ့ပိုးမှုပေးပါသည်။ ဟုတ်ကဲ့၊ ဒါတွေအားလုံးဟာ အဓိပ္ပာယ်ရှိပါတယ်၊ ဒါပေမယ့် အပလီကေးရှင်းက ခွဲတမ်းခွဲတမ်းကို ထပ်ပြီးကျော်လွန်နေတယ်ဆိုရင်၊ အစဉ်အလာ Java အပလီကေးရှင်းတွေလိုပဲ - cores အရေအတွက်နဲ့ တစ်ခုစီအတွက် သီးခြား thread တစ်ခုစီခွဲဝေမှုနဲ့အတူ အရွယ်အစားနဲ့ အဆုံးသတ်ပါတယ်။ တောင်းဆိုတာက ဒါတွေအားလုံးမှာ အဓိပ္ပာယ်နည်းနည်းရှိတယ်။
ထို့အပြင်၊ သင်သည် Kubernetes အခြေခံပလပ်ဖောင်း၏ ခွဲတမ်းနှင့် ကန့်သတ်ချက်များကို အသုံးပြုပါက ပြဿနာသည် သူ့ဘာသာသူ ဖြေရှင်းမည်မဟုတ်ပါ။ မူရင်းပြဿနာကို ဖြေရှင်းရန် သို့မဟုတ် ငွေပိုသုံးစွဲခြင်းအတွက် ကျွန်ုပ်တို့သည် အရင်းအမြစ်များကို ပိုမိုသုံးစွဲပါသည်။ အများသူငှာ အများသူငှာ cloud တွင် high-load system ဖြစ်ပါက၊ ကျွန်ုပ်တို့သည် အမှန်တကယ် လိုအပ်သည်ထက် အရင်းအမြစ်များကို ပိုမိုအသုံးပြုခြင်းမှာ သေချာပါသည်။

ဒါတွေအားလုံးနဲ့ ဘာလုပ်ရမလဲ။

ရိုးရိုးရှင်းရှင်းပြောရလျှင်၊ Netty ကဲ့သို့ အဆက်မပြတ်ဖြစ်စေပြီး ပိတ်ဆို့ခြင်းမဟုတ်သော I/O စာကြည့်တိုက်များနှင့် မူဘောင်များကို အသုံးပြုပါ။ Vert.x သို့မဟုတ် Akka ၎င်းတို့သည် ၎င်းတို့၏ ဓာတ်သဘာဝကြောင့် ကွန်တိန်နာများတွင် အလုပ်လုပ်ရန် ပိုမိုသင့်လျော်ပါသည်။ ပိတ်ဆို့ခြင်းမဟုတ်သော I/O ကြောင့် တူညီသောစာတွဲသည် တစ်ပြိုင်နက် တောင်းဆိုချက်များစွာကို လုပ်ဆောင်နိုင်သည်။ တောင်းဆိုချက်တစ်ခုသည် I/O ရလဒ်များကို စောင့်ဆိုင်းနေချိန်တွင်၊ ၎င်းကို အပ်ဒြပ်ကို ထုတ်ယူပြီး အခြားတောင်းဆိုချက်တစ်ခုမှ လွှဲပြောင်းရယူသည်။ I/O ရလဒ်များ နောက်ဆုံးရောက်လာသောအခါ၊ ပထမတောင်းဆိုချက်ကို ဆက်လက်လုပ်ဆောင်နေပါသည်။ တူညီသောစာတွဲအတွင်း တောင်းဆိုမှုများကို ကြားဖြတ်လုပ်ဆောင်ခြင်းဖြင့်၊ သင်သည် စာတွဲများ၏ စုစုပေါင်းအရေအတွက်ကို လျှော့ချနိုင်ပြီး တောင်းဆိုမှုများကို လုပ်ဆောင်ရန်အတွက် အရင်းအမြစ်သုံးစွဲမှုကို လျှော့ချနိုင်သည်။

ပိတ်ဆို့ခြင်းမဟုတ်သော I/O ဖြင့်၊ cores အရေအတွက်သည် ပြိုင်တူလုပ်ဆောင်နိုင်သည့် I/O thread များ၏ အရေအတွက်ကို ဆုံးဖြတ်ပေးသောကြောင့် အဓိက ကန့်သတ်ဘောင်တစ်ခု ဖြစ်လာသည်။ မှန်ကန်စွာအသုံးပြုသောအခါ၊ ၎င်းသည် သင့်အား cores များကြားဝန်အား ထိရောက်စွာဖြန့်ဝေနိုင်ပြီး အရင်းအမြစ်နည်းနည်းဖြင့် ပိုမိုမြင့်မားသောအလုပ်များကို ကိုင်တွယ်နိုင်စေမည်ဖြစ်သည်။

အဲဒါ ဘယ်လိုလဲ။

မဟုတ်ပါ၊ အခြားတစ်ခုရှိသေးသည်။ Reactive programming သည် အရင်းအမြစ်များကို ပိုမိုကောင်းမွန်စွာအသုံးပြုရန် ကူညီပေးသော်လည်း စျေးနှုန်းဖြင့်လည်း ရရှိပါသည်။ အထူးသဖြင့်၊ ပိတ်ဆို့ခြင်းမပြုသည့်အခြေခံမူများနှင့်အညီ ကုဒ်ကို ပြန်လည်ရေးသားရမည်ဖြစ်ပြီး I/O လိုင်းများကို ပိတ်ဆို့ခြင်းမှ ရှောင်ကြဉ်ပါ။ ၎င်းသည် ဖွံ့ဖြိုးတိုးတက်မှုနှင့် အကောင်အထည်ဖော်မှု၏ လုံးဝကွဲပြားခြားနားသော ပုံစံတစ်ခုဖြစ်သည်။ ဤနေရာတွင် အသုံးဝင်သော စာကြည့်တိုက်များ အများအပြားရှိသော်လည်း ၎င်းသည် ပုံမှန်တွေးခေါ်ပုံတွင် အစွန်းရောက်ပြောင်းလဲမှုတစ်ခု ဖြစ်နေဆဲဖြစ်သည်။

ပထမဦးစွာ၊ သင်သည် asynchronously အလုပ်လုပ်သောကုဒ်ကိုမည်သို့ရေးရမည်ကိုလေ့လာရန်လိုအပ်သည်။ ပိတ်ဆို့ခြင်းမပြုသော I/O ကို သင်စတင်အသုံးပြုသည်နှင့်တစ်ပြိုင်နက်၊ တောင်းဆိုချက်တစ်ခုအား တုံ့ပြန်မှုတစ်ခုလက်ခံရရှိသည့်အခါတွင် ဖြစ်ပေါ်လာမည့်အရာများကို ပြတ်သားစွာ သတ်မှတ်ရန် လိုအပ်သည်။ ပိတ်ဆို့ခြင်းနှင့် စောင့်ဆိုင်းရုံဖြင့် အလုပ်မဖြစ်တော့ပါ။ ယင်းအစား၊ သင်သည် ဖုန်းခေါ်ဆိုမှုများကို ကျော်ဖြတ်နိုင်သည်၊ တုံ့ပြန်မှု ပရိုဂရမ်းမင်း သို့မဟုတ် ဆက်လုပ်မှုကို အသုံးပြုနိုင်သည်။ ဒါပေမယ့် ဒါတွေအားလုံးတော့ မဟုတ်ပါဘူး။- ပိတ်ဆို့ခြင်းမဟုတ်သော I/O ကို အသုံးပြုရန်၊ နေရာတိုင်းတွင် ပိတ်ဆို့ခြင်းမဟုတ်သော ဆာဗာများနှင့် ဖောက်သည်များ လိုအပ်ပါသည်။ HTTP ကိစ္စတွင်၊ အရာအားလုံးသည် ရိုးရှင်းသော်လည်း ဒေတာဘေ့စ်များ၊ ဖိုင်စနစ်များနှင့် အခြားအရာများစွာလည်း ရှိသေးသည်။

စုစုပေါင်း အဆုံးမှ အဆုံး ဓာတ်ပြုမှုသည် ထိရောက်မှု အမြင့်ဆုံးဖြစ်သော်လည်း၊ ထိုသို့သော ပြောင်းလဲမှုသည် လက်တွေ့တွင် ဝမ်းစာအတွက် ခက်ခဲနိုင်သည်။ ထို့ကြောင့်၊ reactive နှင့် imperative code ကိုပေါင်းစပ်နိုင်မှုသည်-

1. ဆော့ဖ်ဝဲလ်စနစ်၏ တင်ဒါအများဆုံးနေရာများတွင် အရင်းအမြစ်များကို ထိရောက်စွာအသုံးပြုပါ။
2. ၎င်း၏ကျန်ရှိသောအပိုင်းများတွင် ပိုမိုရိုးရှင်းသောပုံစံကုဒ်ကို အသုံးပြုပါ။

Quarkus ကို မိတ်ဆက်ခြင်း။

တကယ်တော့၊ ဒါက Quarkus ရဲ့ အနှစ်သာရဖြစ်ပြီး runtime ပတ်၀န်းကျင်တစ်ခုအတွင်း ဓာတ်ပြုမှုနဲ့ မရှိမဖြစ်မော်ဒယ်တွေကို ပေါင်းစပ်ဖို့ပါပဲ။

Quarkus သည် ဆော့ဖ်ဝဲရေးသားသူကိုကူညီရန် အပေါ်မှတုံ့ပြန်မှုဘောင်များနှင့် တိုးချဲ့မှုများများစွာပါရှိသော Vert.x နှင့် Netty ကိုအခြေခံထားသည်။ Quarkus သည် HTTP microservices များသာမက event-driven ဗိသုကာများကို တည်ဆောက်ရန်အတွက် ဒီဇိုင်းထုတ်ထားသည်။ ၎င်း၏ ဓာတ်ပြုမှုသဘောသဘာဝကြောင့် ၎င်းသည် စာတိုပေးပို့ခြင်းစနစ်များ (Apache Kafka၊ AMQP စသည်ဖြင့်) နှင့် အလွန်ထိရောက်စွာ အလုပ်လုပ်ပါသည်။

လှည့်ကွက်မှာ imperative နှင့် reactive code နှစ်ခုလုံးအတွက် တူညီသော ဓာတ်ပြုအင်ဂျင်ကို အသုံးပြုနည်းဖြစ်သည်။

Quarkus က ဒါကို ပြောင်မြောက်စွာ လုပ်တယ်။ imperative နှင့် reactive အကြား ရွေးချယ်မှုမှာ ထင်ရှားသည် - နှစ်ခုလုံးအတွက် reactive kernel ကို အသုံးပြုပါ။ ၎င်းသည် အမှန်တကယ် ကူညီပေးသည့်အရာမှာ event-loop thread (aka IO thread) မှတဆင့် ဖြတ်သန်းသွားသော အရာအားလုံးနီးပါးကို မြန်ဆန်ပြီး ပိတ်ဆို့ခြင်းမဟုတ်သော ကုဒ်ဖြစ်သည်။ သို့သော် သင့်တွင် ဂန္ထဝင် REST သို့မဟုတ် client-side application များရှိပါက Quarkus တွင် မရှိမဖြစ်လိုအပ်သော ပရိုဂရမ်းမင်းပုံစံတစ်ခု အသင့်ရှိနေပါသည်။ ဥပမာအားဖြင့်၊ Quarkus ရှိ HTTP ပံ့ပိုးမှုသည် ပိတ်ဆို့ခြင်းမဟုတ်သော ဓာတ်ပြုအင်ဂျင် (Eclipse Vert.x နှင့် Netty) ကို အသုံးပြုခြင်းအပေါ် အခြေခံသည်။ သင့်အပလီကေးရှင်းမှရရှိသော HTTP တောင်းဆိုချက်အားလုံးကို ဖြစ်ရပ်ကွင်းဆက် (IO Thread) မှတဆင့် ဦးစွာဖြတ်သန်းပြီးနောက် တောင်းဆိုမှုများကို စီမံခန့်ခွဲသည့်ကုဒ်၏အစိတ်အပိုင်းသို့ ပေးပို့သည်။ ဦးတည်ရာပေါ် မူတည်၍ တောင်းဆိုမှုစီမံခန့်ခွဲမှုကုဒ်ကို သီးခြား thread (အလုပ်သမားချည်မျှင်ဟုခေါ်သော၊ servlets နှင့် Jax-RS များတွင်အသုံးပြုသည်) သို့မဟုတ် အရင်းအမြစ် I/O thread (တုံ့ပြန်မှုလမ်းကြောင်း) ကို အသုံးပြုနိုင်သည်။

စာတိုပေးပို့ခြင်းစနစ် ချိတ်ဆက်သူများသည် Vert.x အင်ဂျင်၏ထိပ်တွင် လုပ်ဆောင်နေသော ပိတ်ဆို့ခြင်းမဟုတ်သော ကလိုင်းယင့်များကို အသုံးပြုသည်။ ထို့ကြောင့်၊ သင်သည် စာတိုပေးပို့ခြင်း အလယ်တန်းဆော့ဖ်ဝဲစနစ်များမှ မက်ဆေ့ချ်များကို ထိရောက်စွာ ပေးပို့ခြင်း၊ လက်ခံခြင်းနှင့် လုပ်ဆောင်ခြင်းတို့ ပြုလုပ်နိုင်သည်။

အဆိုပါ site ကို Quarkus.io ဤသည်မှာ Quarkus နှင့်စတင်ရန်ကူညီရန် သင်ခန်းစာကောင်းအချို့ဖြစ်သည်။

• Reactive Routes ကိုအသုံးပြုခြင်း။
• Reactive SQL ဖောက်သည်များ
• Reactive Messaging ဖြင့် Apache Kafka ကိုအသုံးပြုခြင်း။
• Reactive Messaging ဖြင့် AMQP ကိုအသုံးပြုခြင်း။
• Vertx API ကို အသုံးပြုခြင်း။

ဘရောက်ဆာတစ်ခုတွင် IDE မလိုအပ်ဘဲ၊ ကွန်ပြူတာ မလိုအပ်ဘဲ တုံ့ပြန်မှုဆိုင်ရာ ပရိုဂရမ်များကို သင်ပေးရန်အတွက်လည်း အွန်လိုင်းလက်တွေ့သင်ခန်းစာများကို ဖန်တီးထားပါသည်။ ဒီသင်ခန်းစာတွေကို သင်ရှာတွေ့နိုင်ပါတယ်။ ဒီမှာ.

အသုံးဝင်သောအရင်းအမြစ်တွေကို

• Quarkus စမ်းကြည့်ရန် အကြောင်းရင်း 4 ခု
• Quarkus ပရောဂျက်ဝဘ်ဆိုဒ် - quarkus.io
• GitHub ရှိ Quarkus ပရောဂျက် github.com/quarkusio/quarkus
• Quarkus ပရောဂျက် Twitter - twitter.com/QuarkusIO
• Quarkus ပရောဂျက် စကားပြောခန်း - quarkusio.zulipchat.com
• Quarkus ပရောဂျက်ဖိုရမ်များ – groups.google.com/forum/#!forum/quarkus-dev

အကြောင်းအရာနှင့်ရင်းနှီးစေရန် Quarkus တွင် ဗီဒီယိုသင်ခန်းစာ 10 ခု

ဝဘ်ဆိုဒ်မှာ သူတို့ပြောသလိုပါပဲ။ Quarkus.io, quarkus - ဒီ Kubernetes-oriented Java stack၊ GraalVM နှင့် OpenJDK HotSpot အတွက် အံဝင်ခွင်ကျဖြစ်ပြီး အကောင်းဆုံး Java စာကြည့်တိုက်များနှင့် စံချိန်စံညွှန်းများမှ စုစည်းထားသည်။

ခေါင်းစဉ်ကို နားလည်ကူညီရန်၊ Quarkus ၏ ရှုထောင့်အမျိုးမျိုးနှင့် ၎င်း၏အသုံးပြုမှုနမူနာများကို ဖုံးအုပ်ထားသော ဗီဒီယိုသင်ခန်းစာ ၁၀ ခုကို ရွေးချယ်ထားပါသည်။

1. Quarkus ကို မိတ်ဆက်ခြင်း- Kubernetes အတွက် နောက်မျိုးဆက် Java Framework

Thomas Qvarnstrom နှင့် Jason Greene တို့မှ
Quarkus ပရောဂျက်၏ ရည်ရွယ်ချက်မှာ Kubernetes နှင့် serverless ပတ်၀န်းကျင်အတွက် Java ပလပ်ဖောင်းကို ဖန်တီးရန်နှင့် တုံ့ပြန်မှုနှင့် မရှိမဖြစ်လိုအပ်သော ပရိုဂရမ်းမင်းပုံစံများကို တစ်ခုတည်းသော runtime ပတ်၀န်းကျင်သို့ ပေါင်းစပ်ရန်ဖြစ်ပြီး developer များသည် ဖြန့်ဝေထားသော application architectures အများအပြားဖြင့် လုပ်ဆောင်သည့်အခါ ၎င်းတို့၏ချဉ်းကပ်ပုံများကို လိုက်လျောညီထွေပြောင်းလဲနိုင်စေရန်ဖြစ်သည်။ အောက်ဖော်ပြပါ မိတ်ဆက်ဟောပြောပွဲတွင် ပိုမိုလေ့လာပါ။

2. Quarkus- အလွန်မြန်သော Subatomic Java

By: Burr Sutter
DevNation Live မှ ဤဗီဒီယိုသင်ခန်းစာသည် လုပ်ငန်းသုံး Java အက်ပ်လီကေးရှင်းများ၊ APIs၊ microservices နှင့် Kubernetes/OpenShift ပတ်ဝန်းကျင်ရှိ ဆာဗာမဲ့လုပ်ဆောင်ချက်များကို ပိုကောင်းအောင်ပြုလုပ်ရန် Quarkus ကိုအသုံးပြုပုံကို သရုပ်ပြပြီး ၎င်းတို့ကို ပိုမိုသေးငယ်၊ မြန်စေပြီး ပိုမိုအတိုင်းအတာတစ်ခုအထိ လုပ်ဆောင်နိုင်စေသည်။

3. Quarkus နှင့် GraalVM- Hibernate ကို စူပါအမြန်နှုန်းများအထိ အရှိန်မြှင့်ကာ ၎င်းအား အက်တမ်ပိုင်းအရွယ်အစားအထိ ကျုံ့သွားသည်

ရေးသားသူ- Sanne Grinovero
တင်ဆက်မှုမှ Quarkus ဖြစ်ပေါ်လာပုံ၊ ၎င်းသည် အလုပ်လုပ်ပုံနှင့် မူရင်း GraalVM ပုံများနှင့် တွဲဖက်အသုံးပြုနိုင်သော Hibernate ORM ကဲ့သို့သော ရှုပ်ထွေးသောစာကြည့်တိုက်များကို ဖန်တီးနိုင်ပုံတို့ကို သင်လေ့လာနိုင်မည်ဖြစ်သည်။

4. ဆာဗာမဲ့အက်ပ်လီကေးရှင်းများ ဖွံ့ဖြိုးတိုးတက်ရန် လေ့လာပါ။

ရေးသားသူ- မာတင်လူသာ
အောက်ပါဗီဒီယိုတွင် Quarkus ကို အသုံးပြု၍ ရိုးရှင်းသော Java အပလီကေးရှင်းကို ဖန်တီးပြီး Knative တွင် ဆာဗာမဲ့အက်ပ်တစ်ခုအဖြစ် အသုံးချပုံကို ပြသထားသည်။

5. Quarkus- ပျော်ရွှင်စွာ coding လုပ်ပါ။

ရေးသားသူ- Edson Yanaga
သင်၏ပထမဆုံး Quarkus ပရောဂျက်ကို ဖန်တီးရန် ဗီဒီယိုလမ်းညွှန်တစ်ခု၊ Quarkus သည် developer များ၏ အသည်းနှလုံးကို အဘယ်ကြောင့်အနိုင်ရကြောင်း နားလည်နိုင်စေမည်ဖြစ်သည်။

6. Java နှင့် containers - ၎င်းတို့၏ အနာဂတ် အတူတကွ ဖြစ်လာမည်

Mark Little မှရေးသားခဲ့သည်
ဤတင်ပြချက်သည် Java ၏သမိုင်းကြောင်းကို မိတ်ဆက်ပြီး Quarkus သည် Java ၏အနာဂတ် အဘယ်ကြောင့်ဖြစ်သည်ကို ရှင်းပြသည်။

7. Quarkus- အလွန်မြန်သော Subatomic Java

ရေးသားသူ- Dimitris Andreadis
ဆော့ဖ်ဝဲရေးသားသူများထံမှ အသိအမှတ်ပြုမှုရရှိခဲ့သည့် Quarkus ၏ အားသာချက်များကို ခြုံငုံသုံးသပ်ချက်- ရိုးရှင်းမှု၊ အလွန်မြင့်မားသောမြန်နှုန်းများ၊ အကောင်းဆုံးစာကြည့်တိုက်များနှင့် စံနှုန်းများ။

8. Quarkus နှင့် subatomic ဒုံးပျံစနစ်များ

ရေးသားသူ- Clement Escoffier
GraalVM နှင့် ပေါင်းစပ်ခြင်းဖြင့် Quarkus သည် အလွန်မြန်ဆန်သော ဖွံ့ဖြိုးတိုးတက်မှုအတွေ့အကြုံနှင့် subatomic runtime ပတ်ဝန်းကျင်ကို ပေးဆောင်ပါသည်။ စာရေးဆရာသည် Quarkus ၏တုံ့ပြန်မှုဘက်ခြမ်းနှင့် reactive နှင့် streaming အက်ပ်လီကေးရှင်းများကိုတည်ဆောက်ရန်မည်သို့အသုံးပြုရမည်ကိုပြောဆိုထားသည်။

9. Quarkus နှင့် Eclipse MicroProfile တွင် လျင်မြန်သော အပလီကေးရှင်း ဖွံ့ဖြိုးတိုးတက်မှု

ရေးသားသူ- John Clingan
Eclipse MicroProfile နှင့် Quarkus တို့ကို ပေါင်းစပ်ခြင်းဖြင့်၊ developer များသည် မီလီစက္ကန့် ဆယ်ဂဏန်းအတွင်း လွှင့်တင်နိုင်သော အပြည့်အ၀ပါဝင်သည့် MicroProfile အပလီကေးရှင်းများကို ဖန်တီးနိုင်သည်။ Kubernetes ပလပ်ဖောင်းတွင် အသုံးပြုရန်အတွက် ကွန်တိန်နာတင်ထားသော MicroProfile အပလီကေးရှင်းကို ကုဒ်လုပ်နည်းကို ဗီဒီယိုတွင် အသေးစိတ်ဖော်ပြထားသည်။

10. Java၊ "Turbo" ဗားရှင်း

ရေးသားသူ- Marcus Biel
စာရေးဆရာသည် အထူးသဖြင့် ဆာဗာမရှိသောပတ်ဝန်းကျင်များတွင် အမှန်တကယ်အောင်မြင်မှုများရရှိစေသည့် အလွန်သေးငယ်ပြီး အလွန်မြန်ဆန်သော Java ကွန်တိန်နာများကို ဖန်တီးရန် စာရေးသူသည် Quarkus ကိုအသုံးပြုပုံကို ပြသထားသည်။

source: www.habr.com