Како Quarkus комбинира императивно и реактивно програмирање

Оваа година планираме сериозно да развиеме теми за контејнери, Cloud-Native Java и Кубернети. Логичното продолжение на овие теми ќе биде приказна за рамката на Кваркус, веќе сметано на Хабре. Денешната статија е помалку за дизајнот на „субатомска супербрза Јава“, а повеќе за ветувањето што Quarkus го носи на Enterprise.

Java и JVM сè уште се екстремно популарни, но кога се работи со технологии без сервер и микросервиси мајчин облак, Java и другите JVM јазици се користат сè помалку бидејќи заземаат премногу простор во меморијата и се премногу бавни за вчитување, што ги прави слабо прилагоден за употреба со краткотрајни контејнери. За среќа, оваа ситуација сега почнува да се менува благодарение на Quarkus.

Супербрзата субатомска Java достигна ново ниво!

42 изданија, 8 месеци работа во заедницата и 177 неверојатни програмери - резултатот од сето тоа беше објавувањето во ноември 2019 година Кваркус 1.0, издание кое означува важна пресвртница во развојот на проектот и нуди многу одлични карактеристики и способности (можете да прочитате повеќе за нив во најава).

Денес ќе ви покажеме како Quarkus ги комбинира императивните и реактивните модели на програмирање во едно реактивно јадро. Ќе започнеме со кратка историја, а потоа ќе одиме во детали за тоа што е реактивното јадро на дуализмот на Кваркус и како Јава-Програмерите можат да ги искористат овие поволности.

Микроуслуги, архитектури водени од настани и без серверот-функции – сето тоа, како што велат, денес е во пораст. Неодамна, создавањето на архитектури насочени кон облак стана многу полесно и подостапно, но проблемите остануваат - особено за развивачите на Java. На пример, во случај на функции и микросервиси без сервер, постои итна потреба да се намали времето за стартување, да се намали потрошувачката на меморија и сепак да се направи нивниот развој поудобен и попријатен. Java направи неколку подобрувања во последниве години, како што е подобрена ергономска функционалност за контејнерите и така натаму. Сепак, сè уште е предизвик да се натера Java да работи правилно во контејнер. Така, ќе започнеме со разгледување на некои од вродените сложености на Java, кои се особено акутни кога се развиваат Java-ориентирани контејнерски апликации.

Прво, да ја погледнеме историјата.

Потоци и контејнери

Почнувајќи со верзијата 8u131, Java почна повеќе или помалку да поддржува контејнери поради подобрувањата во функционалноста на ергономијата. Конкретно, JVM сега знае на колку процесорски јадра работи и може да ги конфигурира нишките базени - вообичаено базени за раздвојување / спојување - соодветно. Се разбира, ова е одлично, но да речеме дека имаме традиционална веб-апликација која користи HTTP сервлети и работи во Tomcat, Jetty итн. Како резултат на тоа, оваа апликација ќе му даде на секое барање посебна нишка и ќе дозволи да ја блокира оваа нишка додека чека операции за влез/излез, на пример, при пристап до базата на податоци, датотеки или други услуги. Односно, големината на таквата апликација не зависи од бројот на достапни јадра, туку од бројот на истовремени барања. Дополнително, ова значи дека квотите или ограничувањата во Kubernetes на бројот на јадра нема да бидат од голема помош овде, и работата на крајот ќе заврши со пригушување.

Исцрпување на меморијата

Темите се меморија. И ограничувањата на меморијата во контејнер во никој случај не се лек. Само почнете да го зголемувате бројот на апликации и нишки и порано или подоцна ќе наидете на критично зголемување на фреквенцијата на префрлување и, како резултат на тоа, деградација на перформансите. Исто така, ако вашата апликација користи традиционални рамки за микросервис, или се поврзува со база на податоци, или користи кеширање или на друг начин користи меморија, очигледно ви е потребна алатка која ви овозможува да погледнете внатре во JVM и да видите како тој управува со меморијата без да ја убие. Самиот JVM (на пример, XX:+UseCGroupMemoryLimitForHeap). И иако, од Java 9, JVM научи да прифаќа cгрупи и соодветно да се прилагодува, резервирањето и управувањето со меморијата останува прилично сложена работа.

Квоти и ограничувања

Јава 11 воведе поддршка за квоти на процесорот (како PreferContainerQuotaForCPUCount). Kubernetes исто така нуди поддршка за ограничувања и квоти. Да, сето ова има смисла, но ако апликацијата повторно ја надмине доделената квота, повторно завршуваме со големината - како што е случајот со традиционалните Java апликации - одредена од бројот на јадра и со распределба на посебна нишка за секоја барање, тогаш има малку смисла во сето ова.
Дополнително, ако користите квоти и ограничувања или функциите за намалување на платформата во основата на Kubernetes, проблемот исто така не се решава сам по себе. Едноставно трошиме повеќе ресурси за решавање на првичниот проблем или на крајот претеруваме. И ако тоа е систем со големо оптоварување во јавен јавен облак, речиси сигурно на крајот користиме повеќе ресурси отколку што навистина ни се потребни.

И што да се прави со сето ова?

Едноставно кажано, користете асинхрони и неблокирани В/И библиотеки и рамки како Netty, Врт.x или Ака. Тие се многу посоодветни за работа во контејнери поради нивната реактивна природа. Благодарение на неблокирачкиот влез/излез, истата нишка може да обработува повеќе истовремени барања. Додека едно барање чека за I/O резултати, нишката што ја обработува се ослободува и ја презема друго барање. И кога конечно ќе пристигнат I/O резултатите, обработката на првото барање продолжува. Со испреплетена обработка на барања во рамките на истата нишка, можете да го намалите вкупниот број на нишки и да ја намалите потрошувачката на ресурси за обработка на барањата.

Со неблокирачки I/O, бројот на јадра станува клучен параметар бидејќи го одредува бројот на I/O нишки кои можат да се извршуваат паралелно. Кога се користи правилно, ова ви овозможува ефективно да го дистрибуирате оптоварувањето помеѓу јадрата и да се справите со поголеми оптоварувања со помалку ресурси.

Како, тоа ли е се?

Не, има нешто друго. Реактивното програмирање помага за подобро искористување на ресурсите, но има и своја цена. Конкретно, кодот ќе треба да се преработи според принципите на неблокирање и да се избегнува блокирање на влезни/излезни нишки. И ова е сосема поинаков модел на развој и извршување. И иако тука има многу корисни библиотеки, сепак тоа е радикална промена во вообичаениот начин на размислување.

Прво, треба да научите како да пишувате код што работи асинхроно. Откако ќе почнете да користите неблокирачки влез/излез, треба експлицитно да наведете што треба да се случи кога ќе се добие одговор на барање. Едноставното блокирање и чекање веќе нема да функционира. Наместо тоа, можете да пренесувате повратни повици, да користите реактивно програмирање или продолжување. Но, тоа не е сè: за да користите неблокирачки I/O, потребни ви се и сервери што не блокираат и клиенти, по можност насекаде. Во случајот со HTTP, сè е едноставно, но има и бази на податоци, датотечни системи и многу повеќе.

И иако вкупната реактивност од крај до крај ја максимизира ефикасноста, таквата промена може да биде тешко да се оправда во пракса. Затоа, можноста за комбинирање на реактивен и императивен код станува предуслов за:

1. Ефикасно користете ресурси во најоптоварените области на софтверскиот систем;
2. Користете поедноставен стилски код во неговите преостанати делови.

Ви го претставуваме Кваркусот

Всушност, ова е суштината на Quarkus - да се комбинираат реактивни и императивни модели во една единствена средина за извршување.

Quarkus се базира на Vert.x и Netty, со низа реактивни рамки и екстензии на врвот за да му помогнат на развивачот. Quarkus е дизајниран за градење не само HTTP микросервиси, туку и архитектури управувани од настани. Поради својата реактивна природа, тој работи многу ефикасно со системите за пораки (Apache Kafka, AMQP, итн.).

Трикот е како да се користи истиот реактивен мотор и за императивен и за реактивен код.

Кваркус го прави ова брилијантно. Изборот помеѓу императив и реактивен е очигледен - користете реактивен кернел и за двете. Она со што тој навистина помага е брзиот, неблокирачки код кој се справува со речиси сè што минува низ нишката на циклусот на настани, ака IO нишка. Но, ако имате класични REST или апликации од клиентска страна, Quarkus има императивен програмски модел на готов. На пример, поддршката за HTTP во Quarkus се заснова на употреба на неблокирачки и реактивен мотор (Eclipse Vert.x и Netty). Сите HTTP барања што ги добива вашата апликација прво се пренесуваат низ циклус на настани (IO Thread), а потоа се испраќаат до делот од кодот што управува со барањата. Во зависност од дестинацијата, кодот за управување со барањата може да се повика во посебна нишка (т.н. работник нишка, што се користи во случај на сервлети и Jax-RS) или да се користи изворната I/O нишка (реактивна рута).

Конекторите на системот за пораки користат клиенти што не блокираат што работат на врвот на моторот Vert.x. Затоа, можете ефективно да испраќате, примате и обработувате пораки од среден софтвер системи за пораки.

На сајтот Quarkus.io Еве неколку добри упатства кои ќе ви помогнат да започнете со Quarkus:

• Користење на реактивни рути
• Реактивни SQL клиенти
• Користење на Apache Kafka со реактивни пораки
• Користење на AMQP со реактивни пораки
• Користење Vertx API

Создадовме и онлајн практични упатства за да ве научиме на различни аспекти на реактивното програмирање само во прелистувач, без потреба од IDE и без потреба од компјутер. Можете да ги најдете овие лекции тука.

Корисни ресурси

• 4 причини да го пробате Quarkus
• Веб-страница на проектот Quarkus - кваркус.io
• Проектот Quarkus на GitHub - github.com/quarkusio/quarkus
• Проектот Кваркус Твитер – twitter.com/QuarkusIO
• Разговор за проектот Quarkus - quarcusio.zulipchat.com
• Форуми на проектот Quarkus - group.google.com/forum/#!форум/quarkus-dev

10 видео лекции за Quarkus за да се запознаете со темата

Како што велат на веб-страницата Quarkus.io, Кваркус - Дали Кубернети-ориентиран Java stack, приспособен за GraalVM и OpenJDK HotSpot и склопен од најдобрите Java библиотеки и стандарди.

За да ви помогнеме да ја разберете темата, избравме 10 видео упатства кои опфаќаат различни аспекти на Quarkus и примери за неговата употреба:

1. Воведување на Quarkus: The Next Generation Java Framework for Kubernetes

Од Томас Кварнстром и Џејсон Грин
Целта на проектот Quarkus е да се создаде Java платформа за Kubernetes и околини без сервери и да се комбинираат реактивни и императивни модели на програмирање во единствена околина за извршување, така што програмерите можат флексибилно да го менуваат нивниот пристап кога работат со широк опсег на дистрибуирани апликациски архитектури. Дознајте повеќе во воведното предавање подолу.

2. Кваркус: Супербрза субатомска Јава

Од: Бур Сатер
Овој видео туторијал од DevNation Live демонстрира како да се користи Quarkus за да се оптимизираат претпријатијата Java апликации, API, микросервиси и функции без сервер во околина Kubernetes/OpenShift, што ги прави многу помали, побрзи и поскалабилни.

3. Quarkus и GraalVM: забрзување на Hibernate до супер брзини и намалување до субатомски големини

Автор: Сане Гриноверо
Од презентацијата ќе дознаете како настанал Quarkus, како функционира и како ви овозможува да направите сложени библиотеки, како што е Hibernate ORM, компатибилни со мајчин слики на GraalVM.

4. Научете да развивате апликации без сервер

Автор: Мартин Лутер
Видеото подолу покажува како да креирате едноставна Java апликација користејќи Quarkus и да ја распоредите како апликација без сервер на Knative.

5. Кваркус: Забавувајте се со кодирање

Автор: Едсон Јанага
Видео водич за создавање на вашиот прв проект Quarkus, кој ќе ви овозможи да разберете зошто Quarkus ги освојува срцата на програмерите.

6. Јава и контејнери - каква ќе биде нивната заедничка иднина

Објавено од Марк Литл
Оваа презентација ја воведува историјата на Јава и објаснува зошто Quarkus е иднината на Јава.

7. Кваркус: Супербрза субатомска Јава

Автор: Димитрис Андреадис
Преглед на предностите на Quarkus кои добија признание од програмерите: едноставност, ултра високи брзини, најдобри библиотеки и стандарди.

8. Кваркус и субатомски ракетни системи

Автор: Клемент Ескофиер
Преку интеграција со GraalVM, Quarkus обезбедува ултра-брзо развојно искуство и субатомско опкружување за време на траење. Авторот зборува за реактивната страна на Quarkus и како да се користи за да се изградат реактивни и стриминг апликации.

9. Кваркус и брз развој на апликации во Eclipse MicroProfile

Автор: Џон Клинган
Со комбинирање на Eclipse MicroProfile и Quarkus, програмерите можат да создадат целосно опремени апликации за MicroProfile со контејнери кои се стартуваат за десетици милисекунди. Видеото содржи детали за тоа како да се кодира контејнеризирана апликација MicroProfile за распоредување на платформата Kubernetes.

10. Јава, верзија „Турбо“.

Автор: Маркус Биел
Авторот покажува како да се користи Quarkus за да се создадат супер-мали, супер-брзи Java контејнери кои овозможуваат вистински откритија, особено во средини без сервери.

Извор: www.habr.com