🥇Как Quarkus съчетава императивно и реактивно програмиране

Тази година планираме сериозно да разработим теми за контейнери, Облачна Java и Kubernetes. Логично продължение на тези теми ще бъде вече една история за рамката Quarkus разглеждан на Хабре. Днешната статия е по-малко за дизайна на „субатомната супербърза Java“ и повече за обещанието, което Quarkus носи на Enterprise.

Java и JVM все още са изключително популярни, но когато се работи с безсървърни технологии и облачни микроуслуги, Java и други JVM езици се използват все по-малко, защото заемат твърде много място в паметта и са твърде бавни за зареждане, което ги прави не е подходящ за използване с контейнери с кратък живот. За щастие тази ситуация сега започва да се променя благодарение на Quarkus.

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

42 издания, 8 месеца работа в общността и 177 невероятни разработчици - резултатът от всичко това беше изданието през ноември 2019 г. Кваркус 1.0, версия, която бележи важен крайъгълен камък в развитието на проекта и предлага много страхотни функции и възможности (можете да прочетете повече за тях в съобщение).

Днес ще ви покажем как Quarkus комбинира императивни и реактивни модели на програмиране в едно реактивно ядро. Ще започнем с кратка история и след това ще навлезем в подробности за това какво представлява дуализмът на реактивното ядро на 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, Vert.x или Акка. Те са много по-подходящи за работа в контейнери поради тяхната реактивна природа. Благодарение на неблокиращия I/O, една и съща нишка може да обработва множество едновременни заявки. Докато една заявка чака 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.io Ето няколко добри урока, които да ви помогнат да започнете с Quarkus:

Също така създадохме онлайн практически уроци, за да ви научим на различни аспекти на реактивното програмиране само в браузър, без необходимост от IDE и без компютър. Можете да намерите тези уроци тук.

Полезни ресурси

4 причини да опитате Quarkus
Уебсайт на проекта Quarkus – quarkus.io
Проект Quarkus в GitHub – github.com/quarkusio/quarkus
Проект Quarkus Twitter – twitter.com/QuarkusIO
Чат по проекта Quarkus – quarkusio.zulipchat.com
Форуми на проекта Quarkus – groups.google.com/forum/#!форум/quarkus-dev

10 видео урока за Quarkus, за да се запознаете с темата

Както се казва в сайта Quarkus.io, Кваркус – това са Kubernetes-ориентиран Java стек, пригоден за GraalVM и OpenJDK HotSpot и събран от най-добрите Java библиотеки и стандарти.

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

1. Представяне на Quarkus: Следващото поколение Java Framework за Kubernetes

От Томас Кварнстром и Джейсън Грийн
Целта на проекта Quarkus е да създаде Java платформа за Kubernetes и безсървърни среди и да комбинира реактивни и императивни програмни модели в една среда за изпълнение, така че разработчиците да могат гъвкаво да променят своя подход, когато работят с широка гама от разпределени архитектури на приложения. Научете повече в уводната лекция по-долу.

2. Quarkus: Супербърза субатомна Java

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

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

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

4. Научете се да разработвате приложения без сървър

Автор: Мартин Лутър
Видеото по-долу показва как да създадете просто Java приложение с помощта на Quarkus и да го разположите като приложение без сървър на Knative.

5. Quarkus: Забавлявайте се с кодирането

Автор: Едсън Янага
Видео ръководство за създаване на вашия първи проект Quarkus, което ви позволява да разберете защо Quarkus печели сърцата на разработчиците.

6. Java и контейнери – какво ще бъде тяхното съвместно бъдеще

Публикувано от Марк Литъл
Тази презентация представя историята на Java и обяснява защо Quarkus е бъдещето на Java.

7. Quarkus: Супербърза субатомна Java

Автор: Димитрис Андреадис
Преглед на предимствата на Quarkus, които са получили признание от разработчиците: простота, свръхвисоки скорости, най-добрите библиотеки и стандарти.

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

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

9. Quarkus и бързо разработване на приложения в Eclipse MicroProfile

Автор: Джон Клинган
Чрез комбиниране на Eclipse MicroProfile и Quarkus, разработчиците могат да създават пълнофункционални контейнерни MicroProfile приложения, които се стартират за десетки милисекунди. Видеоклипът разглежда подробно как да кодирате контейнеризирано приложение MicroProfile за внедряване на платформата Kubernetes.

10. Java, "Turbo" версия

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

Източник: www.habr.com

Как Quarkus съчетава императивно и реактивно програмиране