🥇Как Quarkus обединява императивното и реактивното програмиране

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

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

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

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

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

Микросервизи, управлявани от събития архитектури и serverless-функции – всичко това днес, както се казва, е на възход. В последно време създаването на облачно ориентирани архитектури стана много по-лесно и достъпно, но проблемите останаха – особено за Java разработчиците. Например, при serverless функции и микросервизи на практика съществува остра необходимост да се съкрати времето за стартиране, да се намали разхода на памет и да се направи разработката им по-удобна и приятна. Java в последните години донесе някои подобрения, като подобрен функционал за контейнерите и т.н. Обаче, постигането на нормална работа на Java в контейнер все още е сложно. Затова ще започнем с разглеждане на някои от вътрешните сложности на Java, които особено остро се проявяват при разработката на контейнерно ориентирани Java приложения.

За да започнем, нека се обърнем към историята.

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

От версия 8u131, Java започна по-добре да поддържа контейнери чрез подобрения във функцията ergonomics. В частност, сега JVM знае на колко процесорни ядра работи и може съответно да настрои пуловете на потоковете - обикновено пуловете fork/join. Разбира се, това е невероятно, но да кажем, че имаме традиционно уеб приложение, което използва HTTP сервлети и се изпълнява в Tomcat, Jetty и др. В резултат на това, това приложение ще назначи отделен поток за всяка заявка и ще позволи на този поток да блокира, докато очаква операции за вход/изход, например, при достъп до БД, файлове или други услуги. Тоест, размерът на такова приложение зависи не от броя на наличните ядра, а от броя на едновременните заявки. Освен това, това означава, че квотите или лимитите в Kubernetes относно броя на ядрата тук не особено ще помогнат, и в крайна сметка всичко ще приключи с тротлинг.

Изчерпване на паметта

Потоци – това е памет. И вътре в контейнерните ограничения на паметта не са панацея. Просто започнете да увеличавате броя на приложенията и потоковете и рано или късно ще се сблъскате с критичен ръст на честотата на превключванията и, следователно, с деградация на производителността. Освен това, ако приложението използва традиционни микросервизни фреймворкове или се свързва с БД, или включва кеширане, или по друг начин допълнително изразходва памет, очевидно ви е нужен инструмент, който да надникне в JVM и да види как тя управлява паметта, без да убие самата JVM (например, XX:+UseCGroupMemoryLimitForHeap). И дори въпреки че, от Java 9 нататък, JVM научи да възприема cgroups и съответно да се адаптира, резервирането и управлението на паметта остават доста сложна работа.

Квоти и лимити

В Java 11 се появи поддръжка за CPU квоти (като PreferContainerQuotaForCPUCount). Kubernetes също предлага поддръжка за лимити и квоти. Да, всичко това има смисъл, но, ако приложението отново надвиши зададената квота, отново стигаме до това, че размерът – както в случая с традиционните Java приложения – се определя според броя на ядрата и с назначаването на отделен поток за всяка заявка, т.е. ползата от всичко това е малка.
Освен това, ако използваме квоти и лимити или функции за хоризонтално (scale-out) мащабиране на платформата, която е в основата на Kubernetes, проблемът също не се решава сам по себе си. Просто харчим повече ресурси за решаване на първоначалния проблем или в крайна сметка стигаме до преразход на ресурси. А ако това е високо натоварена система в публично достъпно облако, почти със сигурност започваме да използваме повече ресурси, отколкото наистина е необходимо.

Какво да правим с всичко това?

Просто казано, използвайте асинхронни и неблокиращи библиотеки за вход-изход и рамки като Netty, Vert.x или Akka. Те са много по-подходящи за работа в контейнери заради своята реактивна природа. Поради неблокиращия вход-изход, един и същ поток може да обработва множество едновремени заявки. Докато една заявка чака резултатите от вход-изхода, обработващият я поток се освобождава и поема друга заявка. А когато резултатите от вход-изхода най-накрая пристигнат, обработката на първата заявка продължава. Чрез редуване на обработката на заявки в рамките на един и същ поток можем да намалим общия брой потоци и да намалим разходите за ресурси при обработка на заявки.

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

Как, и това е всичко?

Не, има и нещо друго. Реактивното програмиране помага да се използват по-добре ресурсите, но също така има своята цена. В частност, кодът ще трябва да бъде пренаписан в съответствие с принципите на неблокируемост и да се избягва блокирането на потоковете за вход-изход. А това е съвсем различен модел на разработка и изпълнение. И въпреки че тук има много полезни библиотеки, това все пак е радикална промяна на обичайния начин на мислене.

На първо място, трябва да научите как да пишете код, който работи асинхронно. След като започнете да използвате неконкурентен вход-изход, вие трябва ясно да опишете какво трябва да се случи, когато получите отговора на заявката. Прекратяването и изчакването вече не е опция. Вместо това можете да предавате обратни повиквания, да използвате реактивно програмиране или continuation. Но това не е всичко: за да използвате неконкурентен вход-изход, са ви нужни и неконкурентни сървъри и клиенти, а предпочитателно навсякъде. В случая с HTTP всичко е просто, но има и бази данни, файлови системи и много други.

И макар тоталната скръстна реактивност да осигурява максимална ефективност, такъв преход може да бъде труден за усвояване на практика. Затова възможността да се съчетаят реактивен и императивен код става необходимо условие, за да:

Ефективно използвате ресурсите в най-натоварените части на софтуерната система;
Използвате по-прост стил на код в останалите части.

Представяме Quarkus

Същността на Quarkus е да обедини реактивните и императивните модели в една изпълнителна среда.

В основата на Quarkus стоят Vert.x и Netty, върху които се използва редица реактивни фреймуерци и разширения, предназначени да помогнат на разработчиците. Quarkus е предназначен за изграждане не само на HTTP микросервизи, но и на архитектури, управлявани от събития. Базиран на своята реактивна природа, той работи много ефективно със системи за обмен на съобщения (Apache Kafka, AMQP и др.).

Цялата хитрост е как да се използва един и същ реактивен двигател както за императивен, така и за реактивен код.

Quarkus се справя блестящо с това. Изборът между императивен и реактивен подход е очевиден – да се използват и двата реактивни ядра. То много помага с бърз неблокиращ код, който обработва почти всичко, преминаващо през цикъла на събития (event-loop thread, също известен като IO thread). Но ако имате класически REST приложения или клиентски приложения, Quarkus предлага императивен модел на програмиране. Например, поддръжката на HTTP в Quarkus е изградена на основата на неблокиращ и реактивен механизъм (Eclipse Vert.x и Netty). Всички HTTP заявки, получавани от вашето приложение, първо преминават през цикъла на събития (IO Thread), а след това се изпращат към частта от кода, която управлява заявките. В зависимост от целта кода за управление на заявките може да бъде извикан в рамките на отделен поток (така наречения worker thread, който се използва при сервлети и Jax-RS) или да използва оригиналния входно-изходен поток (реактивен маршрут).

За свързващите системи за предаване на съобщения се използват неблокиращи клиенти, работещи върху механизма Vert.x. Това означава, че можете ефективно да изпращате, получавате и обработвате съобщения от системи, които функционират като messaging middleware.

На сайта Quarkus.io Събрани са няколко полезни ръководства, които ще ви помогнат да започнете работа с Quarkus:

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

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

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

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

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

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

1. Представяме Quarkus: Java фреймворк от ново поколение за Kubernetes

Автори: Томас Кворнстром (Thomas Qvarnstrom) и Джейсон Грин (Jason Greene)
Целта на Quarkus е да създаде Java платформа за Kubernetes и serverless среди, а също така да обедини реактивни и императивни модели на програмиране в една единна среда за изпълнение, за да могат разработчиците да варират подхода си при работа с широк спектър от разпределени архитектури на приложения. Научете повече от въведението по-долу.

2. Quarkus: свръхбърза субатомна Java

Автор: Блюр Саттер (Burr Sutter)
Видеоурок от интернет-лекторията DevNation Live показва как да използвате Quarkus за оптимизация на корпоративни Java приложения, API, микросервизи и serverless функции в средата на Kubernetes/OpenShift, правейки ги много по-малки, по-бързи и по-мащабируеми.

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

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

4. Учим се да разработваме serverless приложения

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

5. Quarkus: кодирайте с удоволствие

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

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

Автор: Марк Литтъл (Mark Little)
Тази презентация запознава с историята на Java и обяснява защо Quarkus е бъдещето на Java.

7. Quarkus: свръхбърза субатомна Java

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

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

Автор: Клемент Ескофьер (Clement Escoffier)
Благодарение на интеграцията с GraalVM, Quarkus осигурява свръхбързо преживяване при разработката и субатомна среда за изпълнение. Авторът говори за реактивната страна на Quarkus и как да я използвате при създаването на реактивни приложения и приложения за стрийминг.

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

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

10. Java, версия "Турбо"

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