Այս տարի մենք պլանավորում ենք լուրջ զարգացնել կոնտեյների թեմաները, և . Այս թեմաների բնական շարունակությունն կլինի Quarkus ֆрейմվորկի մասին պատմությունը, որը արդեն Habr-ում։ Այնօրվա հոդվածը վերաբերում է թեև "սուբատոմային գերարագ Java"-ի құрылվածքին, բայց ավելի շատ այն տեսահովորվումներին, որոնք Quarkus-ը բերում է Enterprise-ի մեջ:
Java-ն և JVM-ը շարունակում են բացառապես հանրաճանաչ լինել, բայց առանցսերվերային տեխնոլոգիաների և ամպակալված միկրոկառույցների հետ աշխատանքում Java-ն և մյուս լեզուները, որոնք օգտագործում են JVM,越来越 редкостная применяется, так как они занимают слишком много места в памяти и слишком медленно загружаются, из-за чего плохо подходят для использования с короткоживущими контейнерами. Хорошая новость заключается в том, что в настоящее время эта ситуация начинает меняться благодаря Quarkus.
Сверхбыстрая субатомная Java вышла на новый уровень!
42 релиза, 8 месяцев работы сообщества и 177 потрясающих разработчиков – итогом всего это стал выпуск в ноябре 2019 года , релиза, который знаменует собой важную веху в развитии проекта и предлагает массу классных функций и возможностей (подробнее о них можно прочитать в ).
Այսօր մենք կպատմենք, թե ինչպես Quarkus-ը միավորում էImperative և Reactive ծրագրավորման մոդելները միակReactive միջուկի հիման վրա։ Մենք կսկսենք կարճ պատմական ակնարկից, իսկ հետո մանրամասն կքննարկենք, թե որտեղ է Quarkus-իReactive միջուկի երկակիությունը և ինչպես -ծրագրողները կարող են օգտվել այս առավելություններից։
, և -ֆունկցիաները այսօր, ինչպես ասում են, մեջ բարձրացում են։ վերջին ժամանակներում ամպակալված կառույցների կառուցումը դարձել է гораздо проще и доступнее, однако խնդիրները պահպանվում են՝ հատկապես Java ծրագրավորողների մոտ։ Օրինակ, serverless-ֆունկցիաների և միկրոկառույցների դեպքում կա սուր անհրաժեշտություն կրճատել մեկնարկի ժամանակը, նվազեցնել հիշողության ծախսն ու կատարել դրանց մշակումը ավելի հարմար և հաճելի։ Java-ն վերջին տարում ունեցել է մի քանի բարելավումներ, օրինակ՝ կոնտեյների համար վերազինվում էր ֆունկցիաների էրոգնոմիկան։ Բայց դեռևս դժվար էJava-ն հասցնել հոգում նորմալից հեռացման, քանի որ այսօր միկրոկառույցները պահանջում են տարբեր խնդիրները։
Սկսելու համար անդրադառնանք պատմությանը։
Կարիերային և կոնտեյներների
8u131 տարբերակից սկսած, Java-ն ավելի ու ավելի սկսեց աջակցել կոնտեյներին՝ բարելավված գործառույթների շնորհիվ: Մասնավորապես, այժմ JVM-ը գիտի, թե որ Prozessor չափերի վրա է աշխատում, և կարող է համապատասխանաբար կարգավորել թիթեղների խմբեր - սովորաբար, fork/join խմբերը: Անշուշտ, դա հրաշալի է, բայց ասենք, որ մենք ունենք ավանդական վեբ կիրառություն, որը օգտագործում է HTTP սերվլետներ և գործարկվում է Tomcat-ում, Jetty-ում և նմաններում: Արդյունքում, այս կիրառումը յուրաքանչյուր հարցման համար տրամադրել է առանձնակի թիթեղ, և թույլ է տալիս նրան արգելափակվել այդ թիթեղում, երբ սպասում է մուտքային-արտաքին գործողություններին, օրինակ, տվյալների բազային, ֆայլերի կամ այլ ծառայությունների դիմելու ժամանակ: Այսինքն, այդպիսի կիրառման չափսերը չեն կախված մատչելի միջուկների թվից, այլ զուգահեռ հարցումների թվից: Բացի այդ, դա նշանակում է, որ Kubernetes-ում միջուկների քանակի քվոտաները կամ սահմանափակումները այստեղ չկան առանձնապես օգտակար, և ամեն դեպքում արդյունքում կհանդիպենք տրոտինգի:
Հանձնված հիշողություն
Թիթեղները՝ սա հիշողություն է: Եվ ներսի կոնտեյներների վրա հիշողության սահմանափակումները իրական պանացի չէին: Սկսեք ավելացնել կիրառությունների և թիթեղների թիվը, և շուտով դուք կհանդիպեք անգնահատելի հաճախականության փոփոխությունների աճի, և հետևաբար՝ կատարողականության նվազման: Բացի այդ, եթե կիրառությունը օգտագործում է ավանդական միկրոսերվիսային շրջանակներ կամ կապվում է տվյալների բազայի հետ, կամ ներգրավում է հիշողության կոշտացումը, կամ և ուրիշ ձևերով բացառում է հիշողությունը, ձեզ լիովին ակնհայտ է, որ ձեզ անհրաժեշտ է գործիք, որը թույլ է տալիս ներթափանցել JVM-ի մեջ և տեսնել, թե ինչպես է այն ղեկավարվում հիշողությամբ, և չի թույլատրում միսսել նույն JVM-ը (օրինակ, XX:+UseCGroupMemoryLimitForHeap): Եվ նույնիսկ malgré որ, սկսած Java 9-ից, JVM-ն սովորել է ճանաչել Cgroups և ի համապատասխանությամբ ադապտացվել, հիշողության պահպանումը և կառավարման գործընթացը մնում է բավականին բարդ խնդիր:
Քվոտաներ և սահմանափակումներ
Java 11-ում հայտնվեց CPU քվոտաների աջակցություն (օրինակ, PreferContainerQuotaForCPUCount): Kubernetes-ն այդպես էլ առաջարկում է սահմանափակումների և քվոտաների աջակցություն: Այո, սա ամեն ինչ ունի իմաստ, բայց, եթե կիրառությունն իսկապես դուրս է գալիս հաստատված քվոտանից, մենք կրկին վերադառնալու ենք այն, որ չափը՝ ինչպես ավանդական Java կիրառությունների դեպքում, որոշվում է միջուկների թվով և առանձնակի թիթեղ տրամադրելու համար յուրաքանչյուր հարցման համար, այսինքն՝ դրանից շատ քիչ օգուտ կա:
Ալավ դե, եթե օգտագործել սահմանափակումներ և քվոտաներ կամ հորիզոնական (scale-out) սանդղակի ֆունկցիաներ, որոնք գտնվում են Kubernetes-ի հիմքում, խնդիրը նույնպես ինքնաբերաբար չի լուծվում: Մենք պարզապես ծախսում ենք ավելի շատ ռեսուրսներ սկզբնական խնդրի լուծման վրա կամ ի վերջո հանդիպում ենք ռեսուրսների չծախսման խնդրին: Իսկ եթե դա բարձր լարման համակարգ է՝ հանրային հասանելի ամպի միջավայրում, մենք գրեթե վստահ ենք սկսում օգտագործել ավելի շատ ռեսուրսներ, քան դա իսկապես անհրաժեշտ է:
Ի՞նչ պետք է անենք դրա հետ:
Միջինում ասած, պետք է օգտագործել ասինխրոն և небլոկирող մուտքի-գնման գրադարանը և Netty տեսակի ֆрейմվարկներ, կամ Akka։ Դրանք շատ ավելի լավ են հարմարեցված կոնտեյներների մեջ աշխատելու համար իրենց ռեակտիվ բնույթի շնորհիվ։ Այդ շնորհիվ, միեւնույն սեղմումը կարող է միաժամանակ մշակել մի քանի խնդրանքներ։ Ցանկացած պահի, երբ մեկ խնդրանքը սպասում է մուտքի-գնման արդյունքների, մասնորոշող սեղմումը ազատվում է և վերցնում է մեկ այլ խնդրանք։ Իսկ երբ մուտքի-գնման արդյունքները վերջապես հասնում են, առաջին խնդրանքի մշակումն է շարունակվում։ Միեւնույն սեղմման շրջանակներում հարցումների մշակումը հերթափոխելով, կարող եք կրճատել ընդհանուր սեղմումների թիվը և նվազեցնել ռեսուրսների ծախսը հարցումների մշակման համար։
Նեխրանիս մուտքի-գնմանը, միջուկների թիվը դառնում է հիմնական պարամետր, քանի որ հենց դա որոշում է մուտքի-գնման սեղմումների թիվը, որոնք կարող են միաժամանակ իրականացվել։ Правильн օգտագործմամբ դա թույլ է տալիս արդյունավետ տարածել բեռը միջուկների միջև և արդյունավետ կերպով զբաղվել ավելի բարձր բեռներով ավելի քիչ ռեսուրսներով։
Ինչ, և դա ամենը՞։
Ոչ,还有一点值得提及。 Реактив программирование помогает лучше использовать ресурсы, но оно тоже имеет свою цену։ Переписывать код придется в соответствии с принципами неблокируемости и избегать блокировки потоков ввода-вывода։ Это совершенно другая модель разработки и выполнения։ И хотя здесь есть масса полезных библиотек, это все равно кардинальная смена привычного способа мышления։
Առաջին հերթին, դուք պետք է սովորեք գրել կարագ, որը շահագործվում է асинխրոն։ Երբ սկսում եք օգտագործել неблокирующий մուտք-հանում, դուք պետք է բացահայտորեն որոշեք, թե ինչ տեղի կունենա հարցման պատասխան ստանալու ժամանակ։ Просто բլոկավորելը և սպասելը այլևս չի կարող լինել։ Դրա փոխարեն դուք կարող եք փոխանցել հակադարձումներ, օգտագործել ռեակտիվ ծրագրավորում կամ շարունակություն։ Բայց սա դեռ ամենը չէ։ Неблокирующий մուտք-հանումն աշխատելու համար ձեզ հարկավոր են նաև неблокирующие сервեր և հաճախորդներ, և ցանկալի է հիմնական առարկաներում։ HTTP-ի դեպքում ամեն ինչ պարզ է, բայց կան նաև базы данных, ֆայլային համակարգեր և շատ ավելին։
Նաև, ամբողջական ռեակտիվությունը տալիս է առավելագույն արդյունավետություն, սակայն այս փոփոխությունը սովորաբար դժվար է իրականացնել պրակտիկայում։ Այդ պատճառով ռեակտիվ և իմպերատիվ ծածկագրերի համադրելու հնարավորությունը դառնում է անհրաժեշտ պայման։
- Արդյունավետ օգտագործել ռեսուրսները համակարգային ծրագրական համակարգի առավել ծանր բեռնման ուղղություններով։
- Օգտագործել ավելի պարզ ոճով կարագի մնացած մասերում։
Մեր ուշադրության կենտրոնում Quarkus
Իհարկե, դա Quarkus-ի սիրտն է՝ միացնել ռեակտիվ և իմպերատիվ մոդելները միեւնույն կատարողական միջավայրում։
Quarkus-ն հիմնված է Vert.x և Netty- ի վրա, որոնց վերևում օգտագործվում են մի շարք ռեակտիվ ֆрейմվորկներ և ընդլայնումներ, որոնք նախատեսված են աջակցելու ծրագրավորողներին: Quarkus-ը նախատեսված է կառուցելու ոչ միայն HTTP-միկրոհบริการներ, այլ նաև իրադարձություններով կառավարվող ճարտարապետություններ: Իր ռեակտիվ բնույթի շնորհիվ, այն շատ արդյունավետ աշխատում է հաղորդագրությունների փոխանակման համակարգերի հետ (Apache Kafka, AMQP և այլն):
Բոլորը հավակնությունները նրանում են, թե ինչպես օգտագործել նույն ռեակտիվ շարժիչը ինչպես իմպերատիվ, այնպես էլ ռեակտիվ կոդի համար:
Quarkus-ն այս հարցում հրաշալի է: Ընտրանքն between իմպերատիվ և ռեակտիվ է ակնհայտ՝ օգտագործել և՛ դրա համար, և՛ մյուսի համար ռեակտիվ միջուկ: Եվ այն, ինչում այն շատ օգնում է, դա արագ չբլոկող կոդի ունենալն է, որը մշակել է כמעט ամեն ինչ, ինչ անցնում է իրադարձության ցիկլի թելով (event-loop thread կամ IO thread): Բայց եթե դուք ունեք դասական REST հավելվածներ կամ հաճախորդի կողմի հավելվածներ, Quarkus-ն պատրաստել է իմպերատիվ ծրագրավորման մոդել: Օրինակ, Quarkus-ում HTTP աջակցությունը կառուցված է չբլոկող և ռեակտիվ շարժիչի (Eclipse Vert.x և Netty) վրա: Ձեր հավելվածին ստացվող բոլոր HTTP հարցումները սկզբում անցնում են իրադարձության ցիկլի (IO Thread) միջոցով, ապա ուղարկվում են հարցումները կառավարող կոդի այն մասին: Գտնելով, թե ուր է ուղարկվում, հարցումների կառավարման կոդը կարող է կանչվել առանձին թի, կամ օգտագործել սկզբնական մուտքային-հաղորդագրության թելը (ռեակտիվ երթուղի):
Հաղորդիչի համակարգերի քարոզորդների համար օգտագործվում են չբլոկող հաճախորդներ, որոնք աշխատում են Vert.x շարժիչի վրա: Այստեղից դուք կարող եք արդյունավետորեն ուղարկել, ստանալ և մշակել հաղորդագրություններ հաղորդագրությունների միջակայքի համակարգերից:
אתרում կուտակվել են մի քանի լավ ուղեցույցներ, որոնք կօգնեն սկսել աշխատել Quarkus-ի հետ՝
Բացի այս, մենք պատրաստել ենք առցանց գործնական դասեր՝ աշխատանքի բերումով ռեակտիվ ծրագրավորման բազմաթիվ ասպեկտների հետ, և դրանց անցնելու համար հարկավոր է միայն բրաուзер, իսկ IDE-ի կարիքը չկա՝ նաև համակարգիչ նույնպես պարտադիր չէ: Հետաքրքրական դասերը կարող եք գտնել .
Հեշտ առանձին ռեսուրսներ
- Quarkus նախագծի կայքը՝
- Quarkus նախագիծը GitHub-ում՝
- Quarkus նախագծի Twitter-ը՝
- Quarkus նախագծի ծանոթություններ՝
- Quarkus նախագծի ֆորումները՝ !forum/quarkus-dev
10 վիդեոդասեր Quarkus-ի մասին, որպեսզի թեմային ծանոթանանք
Ինչպես նշում են կայքում , նա -հիմնավորված Java ստեք, ձևավորված GraalVM և OpenJDK HotSpot-ի համար և կազմված լավագույն Java-գրադարաններից և ստանդարտներից:
Օգնելու համար ձեզ հասկանալ այս թեման, մենք ընտրել ենք 10 վիդեոդասեր, որտեղ անդրադարձվում են Quarkus-ի տարբեր ասպեկտներին ու նրա օգտագործման օրինակներին:
1. Quarkus-ը ներկայացնում է. Java-ի հաջորդ սերունդը Kubernetes-ի համար
Ա Autoren: Թոմաս Քվօհանստրոմ (Thomas Qvarnstrom) և Ջեյսոն Գրինը (Jason Greene)
Quarkus նախագծի նպատակը Java պլատֆորմ ստեղծելն է Kubernetes և serverless միջավայրերի համար, եւ միացնել ռեակտիվ և ներխուժողական ծրագրավորման մոդելները մեկ կատարողական միջավայրի շրջանակներում, որպեսզի մշակողները կարողանան հայեցակարգերը ճկունորեն փոփոխել՝ աշխատելով բաշխված ծրագրային ճարտարապետության լայն շրջանակի վրա։ Ավելին իմանալու համար տեսեք ներածական դասախոսությունը ստորև։
2. Quarkus: 超快的子原子 Java
Author: Բյուլ Սաթեր (Burr Sutter)
DevNation Live-ի առցանց դասախոսության ուսուցողական տեսանյութը ցույց է տալիս, թե ինչպես Quarkus-ը օգտագործել՝ օպտիմալացնելու Enterprise Java ծրագրերը, API-ները, միկրոհիմնոգործիչները և serverless функций Երկրորդական Kubernetes/OpenShift., երբ դրանք շատ ավելի փոքր, արագացնում են և մասշտաբելի են։
3. Quarkus և GraalVM: 速度提升和子原子大小的 Hibernate
Author: Սանե Գրինվորո (Sanne Grinovero)
Այս ներկայացման մեջ դուք կիմանաք, թե ինչպես Quarkus-ը առաջացել է, ինչպես է այն աշխատում և ինչպես թույլ է տալիս համատեղել կոմպլեքս գրադարանները, ինչպիսիք են Hibernate ORM, GraalVM-ի նատիվ պատճենների հետ։
4. Ճանաչում ենք serverless ծրագրերի մշակումը
Author: Մարտին Լյութեր (Marthen Luther)
Ներքևի տեսանյութը ցույց է տալիս, թե ինչպես ստեղծել պարզ Java ծրագիր Quarkus-ի միջոցով և տեղադրել այն Knative-ի պարագայում որպես serverless ծրագիր։
5. Quarkus: Հաճույքով կոդավորեք
Author: Էդսոն Յանագա (Edson Yanaga)
Quarkus-ի միջոցով ձեր առաջին նախագծի ստեղծման օգտակար ուղեցույցը, որը թույլ է տալիս հասկանալ, թե ինչու Quarkus-ը գրավում է մշակողների սրտերը։
6. Java եւ կոնտեյներները – ինչպիսին կլինի նրանց համատեղ ապագան
Author: Մարկ Լիտտլ (Mark Little)
Այս ներկայացումը ներկայացնում է Java-ի պատմությունն ու բացատրում, թե ինչու Quarkus-ը Java-ի ապագան է։
7. Quarkus: 超快的子原子 Java
Author: Դիմիտրիս Ադրեանդիս (Dimitris Andreadis)
Quarkus-ի առավելությունների ակնարկ, որոնք գնահատվել են մշակողների կողմից. հեշտություն, բարձր արագություններ, լավագույն գրադարաններ և ստանդարտներ։
8. Quarkus և子原子反应系统
Author: Կլեմանձ Էսքոֆիեր (Clement Escoffier)
GraalVM-ի միաձուլման շնորհիվ Quarkus-ը ապահովում է unglaublicաչուն և子原子ական կատարողական միջավայր։ Պատասխանատուն խոսում է Quarkus-ի ռեակտիվ կողմի մասին և թե ինչպես օգտվել այն՝ ռեակտիվ ծրագրերի և տվյալների հոսքերի ընթացքում։
9. Quarkus և առաջարկների արագ մշակումը Eclipse MicroProfile-ում
Author: Ջոն Կլինկան (John Clingan)
Eclipse MicroProfile-ի և Quarkus-ի միավորարման շնորհիվ մշակողները կարող են ստեղծել լիարժեք կոնտեյներային MicroProfile ծրագրեր, որոնք գործարկվում են մի քանի ամիս։ Այս տեսանյութում մանրամասն խոսվում է, թե ինչպես կոդավորել կոնտեյներային MicroProfile ծրագիրը՝ Kubernetes-ի վրա տեղադրելու համար։
10. Java, «Turbo» տարբերակը
Author: Մարկուս Բիլ (Marcus Biel)
Հեղինակը ցույց է տալիս, թե ինչպես օգտագործել Quarkus՝ իրական նպատակի համար ստեղծելու տեհռիփի փոքրիկ և արագ Java կոնտեյներ, որոնք իսկապես փոխաբերուժ կարող են մտնել, հատկապես serverless միջավայրերում:
Ընտանիք: habr.com
