Այս տարի մենք նախատեսում ենք լրջորեն զարգացնել կոնտեյներային թեմաները, и . Այս թեմաների տրամաբանական շարունակությունը կլինի պատմություն Quarkus-ի շրջանակի մասին, արդեն Հաբրեի վրա։ Այսօրվա հոդվածը ավելի քիչ է վերաբերում «ենթատոմային գերարագ Java»-ի նախագծմանը, և ավելի շատ այն խոստմանը, որ Quarkus-ը բերում է Enterprise-ին:
Java-ն և JVM-ը դեռևս չափազանց տարածված են, բայց առանց սերվերի տեխնոլոգիաների և ամպային մայրենի միկրոծառայությունների հետ աշխատելիս Java-ն ու JVM-ի այլ լեզուներն ավելի ու ավելի քիչ են օգտագործվում, քանի որ դրանք չափազանց շատ հիշողություն են զբաղեցնում և շատ դանդաղ են բեռնվում, ինչը ստիպում է դրանք: վատ պիտանի կարճատև բեռնարկղերի հետ օգտագործման համար: Բարեբախտաբար, այս իրավիճակը այժմ սկսում է փոխվել Quarkus-ի շնորհիվ:
Գերարագ ենթաատոմային Java-ն հասել է նոր մակարդակի:
42 թողարկում, 8 ամիս համայնքային աշխատանք և 177 զարմանալի մշակողներ. այս ամենի արդյունքը թողարկվել է 2019 թվականի նոյեմբերին։ , թողարկում, որը նշանավորում է նախագծի զարգացման կարևոր փուլը և առաջարկում է շատ հետաքրքիր առանձնահատկություններ և հնարավորություններ (դրանց մասին ավելին կարող եք կարդալ այստեղ՝ ).
Այսօր մենք ձեզ ցույց կտանք, թե ինչպես է Quarkus-ը համատեղում հրամայական և ռեակտիվ ծրագրավորման մոդելները մեկ ռեակտիվ միջուկի մեջ: Մենք կսկսենք հակիրճ պատմությունից, այնուհետև մանրամասն կանդրադառնանք, թե որն է Քվարկուսի ռեակտիվ միջուկային դուալիզմը և ինչպես -Կառուցողները կարող են օգտվել այս առավելություններից:
, и -գործառույթներ. այս ամենը, ինչպես ասում են, այսօր վերելք է ապրում: Վերջերս ամպակենտրոն ճարտարապետությունների ստեղծումը շատ ավելի հեշտ և հասանելի է դարձել, բայց խնդիրները մնում են՝ հատկապես Java ծրագրավորողների համար: Օրինակ, առանց սերվերի գործառույթների և միկրոծառայությունների դեպքում հրատապ անհրաժեշտություն կա կրճատել գործարկման ժամանակը, նվազեցնել հիշողության սպառումը և, այնուամենայնիվ, դրանց զարգացումն ավելի հարմար և հաճելի դարձնել: Java-ն մի քանի բարելավումներ է կատարել վերջին տարիներին, ինչպիսիք են բեռնարկղերի էրգոնոմիկայի բարելավված ֆունկցիոնալությունը և այլն: Այնուամենայնիվ, Java-ն բեռնարկղում ճիշտ աշխատելու համար դեռևս դժվար է: Այսպիսով, մենք կսկսենք դիտարկելով Java-ի բնորոշ բարդությունները, որոնք հատկապես սուր են բեռնարկղային ուղղվածությամբ Java հավելվածներ մշակելիս:
Նախ, եկեք նայենք պատմությանը:
Հոսքեր և բեռնարկղեր
Սկսած 8u131 տարբերակից, Java-ն սկսեց քիչ թե շատ աջակցել բեռնարկղերին՝ շնորհիվ էրգոնոմիկայի ֆունկցիոնալության բարելավումների: Մասնավորապես, JVM-ն այժմ գիտի, թե քանի պրոցեսորային միջուկով է աշխատում, և կարող է համապատասխանաբար կարգավորել թելերի լողավազանները՝ սովորաբար պատառաքաղ/միանալու լողավազաններ: Իհարկե, սա հիանալի է, բայց ենթադրենք, որ մենք ունենք ավանդական վեբ հավելված, որն օգտագործում է HTTP սերվերներ և աշխատում է Tomcat, Jetty և այլն: Արդյունքում, այս հավելվածը յուրաքանչյուր հարցումին կտրամադրի առանձին շղթա և թույլ կտա արգելափակել այս շարանը՝ սպասելով I/O գործողություններին, օրինակ՝ տվյալների բազա, ֆայլեր կամ այլ ծառայություններ մուտք գործելիս: Այսինքն՝ նման հավելվածի չափը կախված չէ առկա միջուկների քանակից, այլ միաժամանակյա հարցումների քանակից։ Բացի այդ, սա նշանակում է, որ Kubernetes-ում միջուկների քանակի քվոտաները կամ սահմանափակումներն այստեղ առանձնապես չեն օգնի, և գործը, ի վերջո, կավարտվի թուլացումով:
Հիշողության սպառում
Թելերը հիշողություն են: Իսկ ներբանկային հիշողության սահմանափակումները ոչ մի դեպքում համադարման չեն: Պարզապես սկսեք ավելացնել հավելվածների և թելերի քանակը, և վաղ թե ուշ դուք կհանդիպեք փոխարկման հաճախականության կրիտիկական աճի և, որպես հետևանք, կատարողականի վատթարացման: Բացի այդ, եթե ձեր հավելվածն օգտագործում է ավանդական միկրոծառայության շրջանակներ, կամ միանում է տվյալների շտեմարանին, կամ օգտագործում է քեշավորում, կամ այլ կերպ օգտագործում է հիշողությունը, ձեզ ակնհայտորեն անհրաժեշտ է գործիք, որը թույլ է տալիս նայել JVM-ի ներսում և տեսնել, թե ինչպես է այն կառավարում հիշողությունը՝ առանց այն սպանելու: JVM-ն ինքը (օրինակ՝ XX:+UseCGroupMemoryLimitForHeap): Եվ չնայած Java 9-ից ի վեր JVM-ն սովորել է ընդունել cgroups և համապատասխանաբար հարմարվել, հիշողության պահպանումն ու կառավարումը մնում է բավականին բարդ խնդիր:
Քվոտաներ և սահմանափակումներ
Java 11-ը ներկայացրեց աջակցություն պրոցեսորի քվոտաներին (ինչպես PreferContainerQuotaForCPUCount): Kubernetes-ն առաջարկում է նաև սահմանափակումների և քվոտաների աջակցություն: Այո, այս ամենն իմաստ ունի, բայց եթե հավելվածը կրկին գերազանցում է հատկացված քվոտան, մենք կրկին հայտնվում ենք չափերով, ինչպես դա ավանդական Java հավելվածների դեպքում է, որը որոշվում է միջուկների քանակով և յուրաքանչյուրի համար առանձին թելի հատկացումով: խնդրանք, ուրեմն այս ամենի մեջ քիչ իմաստ կա։
Բացի այդ, եթե դուք օգտագործում եք քվոտաներ և սահմանափակումներ կամ Kubernetes-ի հիմքում ընկած հարթակի ընդլայնման գործառույթները, ապա խնդիրն ինքնին չի լուծվում: Մենք պարզապես ավելի շատ ռեսուրսներ ենք ծախսում սկզբնական խնդիրը լուծելու վրա կամ վերջում գերծախսում ենք: Եվ եթե դա բարձր բեռնվածության համակարգ է հանրային հանրային ամպի մեջ, մենք գրեթե անկասկած կօգտագործենք ավելի շատ ռեսուրսներ, քան մեզ իրականում անհրաժեշտ է:
Իսկ ի՞նչ անել այս ամենի հետ։
Պարզ ասած՝ օգտագործեք ասինխրոն և չարգելափակող I/O գրադարաններ և շրջանակներ, ինչպիսիք են Netty-ը, կամ Աքքա. Նրանք շատ ավելի հարմար են տարաներում աշխատելու համար՝ իրենց ռեակտիվ բնույթի պատճառով: Շնորհիվ չարգելափակվող I/O-ի, նույն շարանը կարող է մշակել մի քանի միաժամանակյա հարցումներ: Մինչ մեկ հարցումը սպասում է I/O արդյունքներին, այն մշակող շարանը թողարկվում է և ստանձնում մեկ այլ հարցում: Եվ երբ I/O արդյունքները վերջապես գալիս են, առաջին հարցման մշակումը շարունակվում է: Միևնույն շղթայի շրջանակներում հարցումների խճճված մշակման միջոցով դուք կարող եք նվազեցնել շղթաների ընդհանուր թիվը և նվազեցնել հարցումների մշակման համար ռեսուրսների սպառումը:
Չարգելափակվող I/O-ի դեպքում միջուկների թիվը դառնում է առանցքային պարամետր, քանի որ այն որոշում է I/O թելերի քանակը, որոնք կարող են իրականացվել զուգահեռ: Ճիշտ օգտագործման դեպքում սա թույլ է տալիս արդյունավետորեն բաշխել բեռը միջուկների միջև և ավելի քիչ ռեսուրսներով կարգավորել ավելի մեծ ծանրաբեռնվածություն:
Ինչպե՞ս, այս ամենը:
Չէ, ուրիշ բան կա։ Ռեակտիվ ծրագրավորումն օգնում է ավելի լավ օգտագործել ռեսուրսները, բայց նաև ունի գին: Մասնավորապես, կոդը պետք է վերաշարադրվի չարգելափակման սկզբունքների համաձայն և խուսափել մուտքի/ելք հոսքերի արգելափակումից։ Իսկ սա մշակման և կատարման բոլորովին այլ մոդել է։ Ու թեև այստեղ կան շատ օգտակար գրադարաններ, այնուամենայնիվ դա սովորական մտածելակերպի արմատական փոփոխություն է։
Նախ, դուք պետք է սովորեք, թե ինչպես գրել կոդ, որն աշխատում է ասինխրոն: Երբ սկսեք օգտագործել չարգելափակող I/O, դուք պետք է հստակ նշեք, թե ինչ պետք է տեղի ունենա, երբ ստացվի հարցման պատասխանը: Պարզապես արգելափակելը և սպասելը այլևս չեն աշխատի: Փոխարենը, դուք կարող եք փոխանցել հետադարձ զանգեր, օգտագործել ռեակտիվ ծրագրավորում կամ շարունակություն: Բայց սա դեռ ամենը չէ. չարգելափակող I/O օգտագործելու համար անհրաժեշտ են և՛ չարգելափակող սերվերներ, և՛ հաճախորդներ, ցանկալի է ամենուր: HTTP-ի դեպքում ամեն ինչ պարզ է, բայց կան նաև տվյալների բազաներ, ֆայլային համակարգեր և շատ ավելին:
Եվ չնայած ընդհանուր ծայրից ծայր ռեակտիվությունը առավելագույնի է հասցնում արդյունավետությունը, նման տեղաշարժը կարող է դժվար լինել գործնականում: Հետևաբար, ռեակտիվ և հրամայական ծածկագրերը համատեղելու ունակությունը նախապայման է դառնում՝
- Արդյունավետ օգտագործել ռեսուրսները ծրագրային համակարգի առավել բեռնված տարածքներում.
- Օգտագործեք ավելի պարզ ոճի կոդը դրա մնացած մասերում:
Ներկայացնում ենք Quarkus-ը
Փաստորեն, սա է Quarkus-ի էությունը՝ համատեղել ռեակտիվ և հրամայական մոդելները մեկ գործարկման միջավայրում:
Quarkus-ը հիմնված է Vert.x-ի և Netty-ի վրա՝ ծրագրավորողին օգնելու համար մի շարք ռեակտիվ շրջանակներ և ընդլայնումներ: Quarkus-ը նախատեսված է ոչ միայն HTTP միկրոծառայությունների, այլև իրադարձությունների վրա հիմնված ճարտարապետություններ կառուցելու համար: Իր ռեակտիվ բնույթի շնորհիվ այն շատ արդյունավետ է աշխատում հաղորդագրությունների համակարգերի հետ (Apache Kafka, AMQP և այլն):
Խնդիրն այն է, թե ինչպես օգտագործել նույն ռեակտիվ շարժիչը և՛ հրամայական, և՛ ռեակտիվ կոդի համար:
Quarkus-ը դա անում է փայլուն: Հրամայականի և ռեակտիվության միջև ընտրությունն ակնհայտ է. երկուսի համար էլ օգտագործեք ռեակտիվ միջուկ: Այն, ինչի մեջ այն իսկապես օգնում է, արագ, չարգելափակող կոդն է, որը մշակում է գրեթե ամեն ինչ, ինչ անցնում է իրադարձությունների հանգույցի շարանը, որը կոչվում է IO թեմա: Բայց եթե ունեք դասական REST կամ հաճախորդի կողմից հավելվածներ, Quarkus-ը պատրաստ է ծրագրավորման հրամայական մոդել: Օրինակ, HTTP-ի աջակցությունը Quarkus-ում հիմնված է չարգելափակող և ռեակտիվ շարժիչի օգտագործման վրա (Eclipse Vert.x և Netty): Ձեր հավելվածի կողմից ստացված բոլոր HTTP հարցումները սկզբում փոխանցվում են իրադարձությունների հանգույցով (IO Thread), այնուհետև ուղարկվում են կոդի այն մասին, որը կառավարում է հարցումները: Կախված նպատակակետից, հարցումների կառավարման կոդը կարող է կանչվել առանձին շղթայի մեջ (այսպես կոչված աշխատանքային շարանը, որն օգտագործվում է սերվերների և Jax-RS-ի դեպքում) կամ օգտագործել աղբյուրի I/O շարանը (ռեակտիվ երթուղի):
Հաղորդագրությունների համակարգի միակցիչները օգտագործում են չարգելափակող հաճախորդներ, որոնք աշխատում են Vert.x շարժիչի վերևում: Հետևաբար, դուք կարող եք արդյունավետ կերպով ուղարկել, ստանալ և մշակել հաղորդագրություններ հաղորդագրությունների միջին ծրագրային համակարգերից:
Կայքը Ահա մի քանի լավ ձեռնարկներ, որոնք կօգնեն ձեզ սկսել Quarkus-ը.
Մենք նաև ստեղծել ենք առցանց գործնական ձեռնարկներ, որոնք կսովորեցնեն ձեզ ռեակտիվ ծրագրավորման տարբեր ասպեկտներ միայն զննարկիչով, առանց IDE-ի և համակարգչի պահանջի: Դուք կարող եք գտնել այս դասերը .
Օգտակար ռեսուրսներ
- Quarkus նախագծի կայք –
- Quarkus նախագիծը GitHub-ում –
- Quarkus նախագիծ Twitter –
- Quarkus նախագծի զրույց –
- Quarkus Project ֆորումներ – !forum/quarkus-dev
10 վիդեո դասեր Quarkus-ի մասին՝ թեմային ծանոթանալու համար
Ինչպես ասում են կայքում , - Ից -կողմնորոշված Java փաթեթ՝ հարմարեցված GraalVM-ի և OpenJDK HotSpot-ի համար և հավաքված Java-ի լավագույն գրադարաններից և ստանդարտներից:
Թեման հասկանալու համար մենք ընտրել ենք 10 վիդեո ձեռնարկներ, որոնք ընդգրկում են Quarkus-ի տարբեր ասպեկտներ և դրա օգտագործման օրինակներ.
1. Ներկայացնում ենք Quarkus. Հաջորդ սերնդի Java Framework-ը Kubernetes-ի համար
Թոմաս Քվարնստրոմի և Ջեյսոն Գրինի կողմից
Quarkus նախագծի նպատակն է ստեղծել Java հարթակ Kubernetes-ի և առանց սերվերի միջավայրերի համար, ինչպես նաև համատեղել ռեակտիվ և հրամայական ծրագրավորման մոդելները մեկ գործարկման միջավայրում, որպեսզի մշակողները կարողանան ճկուն կերպով փոխել իրենց մոտեցումները, երբ աշխատում են բաշխված հավելվածների ճարտարապետության լայն շրջանակի հետ: Իմացեք ավելին ստորև ներկայացված ներածական դասախոսությունից:
2. Քվարկուս՝ գերարագ ենթատոմային Java
Հեղինակ՝ Բուր Սաթեր
DevNation Live-ի այս վիդեո ձեռնարկը ցույց է տալիս, թե ինչպես կարելի է օգտագործել Quarkus-ը՝ օպտիմալացնելու ձեռնարկատիրական Java հավելվածները, API-ները, միկրոսերվերները և առանց սերվերի գործառույթները Kubernetes/OpenShift միջավայրում՝ դարձնելով դրանք շատ ավելի փոքր, արագ և ավելի լայնածավալ:
3. «Quarcus» և «GraalVM»՝ արագացնելով Hibernate-ը մինչև գերարագություններ և կրճատելով այն մինչև ենթաատոմային չափերը
Հեղինակ՝ Սաննե Գրինովերո
Ներկայացումից դուք կիմանաք, թե ինչպես է առաջացել Quarkus-ը, ինչպես է այն աշխատում և ինչպես է այն թույլ տալիս բարդ գրադարաններ, ինչպիսին է Hibernate ORM-ը, համատեղելի GraalVM-ի բնիկ պատկերների հետ:
4. Սովորեք մշակել առանց սերվերի հավելվածներ
Հեղինակ՝ Մարտին Լյութեր
Ստորև բերված տեսանյութը ցույց է տալիս, թե ինչպես կարելի է ստեղծել պարզ Java հավելված՝ օգտագործելով Quarkus-ը և տեղադրել այն որպես առանց սերվերի հավելված Knative-ում:
5. Քվարկուս. Զվարճացեք կոդավորումը
Հեղինակ՝ Էդսոն Յանագա
Ձեր առաջին Quarkus նախագիծը ստեղծելու վիդեո ուղեցույց, որը թույլ է տալիս հասկանալ, թե ինչու է Quarkus-ը շահում ծրագրավորողների սրտերը:
6. Java և կոնտեյներներ. ինչպիսին կլինի նրանց համատեղ ապագան
Տեղադրել է Մարկ Լիթլը
Այս շնորհանդեսը ներկայացնում է Java-ի պատմությունը և բացատրում, թե ինչու է Quarkus-ը Java-ի ապագան:
7. Քվարկուս՝ գերարագ ենթատոմային Java
Հեղինակ՝ Դիմիտրիս Անդրեադիս
Quarkus-ի առավելությունների ակնարկ, որոնք ճանաչում են ստացել մշակողների կողմից՝ պարզություն, գերբարձր արագություն, լավագույն գրադարաններ և ստանդարտներ:
8. Քվարկուս և ենթաատոմային հրթիռային համակարգեր
Հեղինակ՝ Կլեմենտ Էսկոֆիե
GraalVM-ի հետ ինտեգրվելու միջոցով Quarkus-ը տրամադրում է գերարագ զարգացման փորձ և ենթաատոմային գործարկման միջավայր: Հեղինակը խոսում է Quarkus-ի ռեակտիվ կողմի և այն մասին, թե ինչպես կարելի է այն օգտագործել ռեակտիվ և հոսքային հավելվածներ ստեղծելու համար:
9. Քվարկուս և հավելվածների արագ զարգացում Eclipse MicroProfile-ում
Հեղինակ՝ Ջոն Քլինգան
Համատեղելով Eclipse MicroProfile-ը և Quarkus-ը, ծրագրավորողները կարող են ստեղծել լիարժեք կոնտեյներային MicroProfile հավելվածներ, որոնք գործարկվում են տասնյակ միլիվայրկյանների ընթացքում: Տեսանյութը մանրամասնում է, թե ինչպես կոդավորել կոնտեյներային MicroProfile հավելվածը՝ Kubernetes հարթակում տեղակայելու համար:
10. Java, «Turbo» տարբերակ
Հեղինակ՝ Մարկուս Բիլ
Հեղինակը ցույց է տալիս, թե ինչպես կարելի է օգտագործել Quarkus-ը՝ ստեղծելու գերփոքր, գերարագ Java կոնտեյներներ, որոնք հնարավորություն են տալիս իրական բեկումներին, հատկապես առանց սերվերի միջավայրերում:
Source: www.habr.com