I Är planerar vi att pÄ allvar utveckla Àmnena kring containrar, och . En logisk fortsÀttning pÄ dessa Àmnen blir att berÀtta om ramverket Quarkus, som redan pÄ Habré. Dagens artikel handlar inte sÄ mycket om strukturen av "subatomÀr superhjÀlpsam Java", utan om de möjligheter som Quarkus för med sig i företagssammanhang.
Java och JVM Àr fortfarande extremt populÀra, men vid arbete med serverlösa teknologier och molnorienterade mikrotjÀnster anvÀnds Java och andra sprÄk för JVM alltmer sÀllan, eftersom de tar för mycket minne och har för lÄng laddningstid, vilket gör dem mindre lÀmpliga för kortlivade containrar. Lyckligtvis börjar denna situation förÀndras tack vare Quarkus.
SubatomÀr superhjÀlpsam Java har nÄtt en ny nivÄ!
42 versioner, 8 mĂ„naders arbete frĂ„n gemenskapen och 177 fantastiska utvecklare â resultatet av allt detta blev lanseringen av , en release som markerar en viktig milepĂŠl i projektets utveckling och erbjuder en massa coola funktioner och möjligheter (mer om dem kan lĂ€sas i ).
Idag kommer vi att berÀtta hur Quarkus förenar modeller av imperativ och reaktiv programmering baserat pÄ en enhetlig reaktiv kÀrna. Vi börjar med en kort tillbakablick pÄ historien och gÄr sedan igenom i detalj vad dualiteten hos Quarks reaktiva kÀrna innebÀr och hur -utvecklare kan dra nytta av dessa fördelar.
, och -funktioner â allt detta Ă€r idag, som man sĂ€ger, pĂ„ uppgĂ„ng. PĂ„ senare tid har skapandet av molnorienterade arkitekturer blivit mycket enklare och mer tillgĂ€ngligt, men problemen kvarstĂ„r â sĂ€rskilt för Java-utvecklare. Till exempel, nĂ€r det gĂ€ller serverlösa funktioner och mikrotjĂ€nster finns det ett akut behov av att minska starttiden, minska minnesanvĂ€ndningen och göra deras utveckling mer praktisk och trevlig. Java har under de senaste Ă„ren gjort flera förbĂ€ttringar, sĂ„som förbĂ€ttrad ergonomik för containrar och sĂ„ vidare. Men det Ă€r fortfarande inte lĂ€tt att fĂ„ Java att fungera normalt i en container. DĂ€rför börjar vi med att titta pĂ„ nĂ„gra av de interna svĂ„righeterna med Java, som sĂ€rskilt tydligt uppstĂ„r vid utveckling av containerorienterade Java-applikationer.
LÄt oss börja med historien.
Strömmar och behÄllare
FrĂ„n och med version 8u131 har Java mer eller mindre börjat stödja behĂ„llare genom förbĂ€ttringar i ergonomifunktionaliteten. Specifikt vet JVM nu hur mĂ„nga processorkĂ€rnor den körs pĂ„ och kan dĂ€rmed anpassa trĂ„dpoolerna â vanligtvis fork/join-pooler. Det Ă€r sĂ€kert bra, men anta att vi har en traditionell webbapplikation som anvĂ€nder HTTP-servlets och körs i Tomcat, Jetty och liknande. Som ett resultat kommer denna applikation att tilldela en separat trĂ„d för varje begĂ€ran och lĂ„ta den blockera denna trĂ„d medan den vĂ€ntar pĂ„ in- och utoperationer, till exempel vid Ă„tkomst till databaser, filer eller andra tjĂ€nster. Det innebĂ€r att storleken pĂ„ en sĂ„dan applikation beror inte pĂ„ antalet tillgĂ€ngliga kĂ€rnor utan pĂ„ antal samtidiga begĂ€rningar. Dessutom betyder detta att kvoter eller grĂ€nser i Kubernetes för antalet kĂ€rnor knappt kommer att hjĂ€lpa, och i slutĂ€ndan kommer det att sluta med dĂ€mpning.
Minnesutarmning
TrĂ„dar Ă€r minne. Och interna behĂ„llarbegrĂ€nsningar för minne Ă€r lĂ„ngt ifrĂ„n en universal lösning. Börja bara öka antalet applikationer och trĂ„dar, och förr eller senare kommer du att stöta pĂ„ en kritisk ökning av vĂ€xelfrekvensen och dĂ€rmed en nedgĂ„ng i prestanda. Dessutom, om applikationen anvĂ€nder traditionella mikrotjĂ€nstarkitekturer eller ansluter till databaser, eller anvĂ€nder caching, eller pĂ„ nĂ„got annat sĂ€tt ytterligare förbrukar minne, behöver du uppenbarligen ett verktyg som lĂ„ter dig titta in i JVM och se hur den hanterar minnet utan att skada sjĂ€lva JVM (till exempel XX:+UseCGroupMemoryLimitForHeap). Ăven om JVM frĂ„n och med Java 9 har lĂ€rt sig att ta hĂ€nsyn till cgroups och anpassa sig dĂ€refter, Ă€r minnesreservation och hantering fortfarande en ganska komplicerad sak.
Kvoter och grÀnser
Java 11 introducerade stöd för CPU-kvoter (som PreferContainerQuotaForCPUCount). Kubernetes erbjuder ocksĂ„ stöd för grĂ€nser och kvoter. Ja, allt detta ger mening, men om applikationen igen överskrider den tilldelade kvoten, Ă„terkommer vi till att storleken â som i fallet med traditionella Java-applikationer â bestĂ€ms av antalet kĂ€rnor och tilldelning av en separat trĂ„d för varje begĂ€ran, vilket innebĂ€r att det inte Ă€r mycket vits med allt detta.
Dessutom, om vi anvÀnder kvoter och grÀnser eller funktioner för horisontell (scale-out) skalning av plattformen som ligger bakom Kubernetes, löser inte problemet sig sjÀlvt. Vi slösar bara mer resurser pÄ att lösa det ursprungliga problemet, eller i slutÀndan kommer vi att hamna i en situation med resursslöseri. Och om detta Àr ett högbelastat system i en offentlig molntjÀnst, börjar vi nÀstan sÀkert anvÀnda mer resurser Àn vad som verkligen behövs.
Vad ska man göra med allt detta?
Enkelt sagt, anvÀnd asynkrona och icke-blockerande bibliotek för in- och utdata samt ramverk som Netty, eller Akka. De Àr mycket bÀttre anpassade för att fungera i containrar pÄ grund av sin reaktiva natur. Tack vare icke-blockerande in- och utdata kan samma trÄd hantera flera samtidiga förfrÄgningar. Medan en förfrÄgan vÀntar pÄ in- och utdataresultat, frigörs den trÄd som behandlar den och kan ta sig an en annan förfrÄgan. Och nÀr resultaten av in- och utdata slutligen kommer in fortsÀtter bearbetningen av den första förfrÄgan. Genom att vÀxla mellan att bearbeta förfrÄgningar inom samma trÄd kan vi minska det totala antalet trÄdar och minska resursanvÀndningen vid bearbetning av förfrÄgningar.
Vid icke-blockerande in- och utdata blir antalet kÀrnor en nyckelparameter, eftersom det definierar hur mÄnga in- och utdata-trÄdar som kan utföras parallellt. Vid korrekt anvÀndning möjliggör detta en effektiv belastningsfördelning mellan kÀrnorna och att hantera högre belastningar med fÀrre resurser.
Och, Àr det allt?
Nej, det finns mer. Reaktiv programmering hjĂ€lper till att bĂ€ttre utnyttja resurser, men har ocksĂ„ sin kostnad. Specifikt mĂ„ste koden skrivas om enligt principerna för icke-blockerande och undvika blockering av in- och utdata-trĂ„dar. Och det Ă€r en helt annan utvecklings- och exekveringsmodell. Ăven om det finns mĂ„nga anvĂ€ndbara bibliotek hĂ€r, Ă€r det Ă€ndĂ„ en radikal förĂ€ndring av det vanliga sĂ€ttet att tĂ€nka.
För det första mÄste du lÀra dig att skriva kod som körs asynkront. SÄ snart du börjar anvÀnda icke-blockerande in- och utdata mÄste du tydligt ange vad som ska hÀnda nÀr svaret pÄ en förfrÄgan kommer in. Att bara blockera och vÀnta gÄr inte lÀngre. IstÀllet kan du skicka tillbaka samtal, anvÀnda reaktiv programmering eller continuation. Men det Àr inte allt: för att anvÀnda icke-blockerande in- och utdata behöver du Àven icke-blockerande servrar och klienter, helst överallt. För HTTP Àr det enkelt, men det finns ocksÄ databaser, filsystem och mycket mer.
Och Àven om total genomgÄende reaktivitet ger maximal effektivitet kan en sÄdan förÀndring vara svÄr att smÀlta i praktiken. DÀrför blir möjligheten att kombinera reaktiv och imperativ kod ett nödvÀndigt villkor för att:
- Effektivt anvÀnda resurser pÄ de mest belastade delarna av det programvarusystemet;
- AnvÀnda enklare kodstil i de andra delarna.
Vi presenterar Quarkus
Det Ă€r egentligen innebörden av Quarkus â att förena reaktiva och imperativa modeller inom en och samma körmiljö.
KÀrnan i Quarkus bygger pÄ Vert.x och Netty, ovanpÄ vilka ett antal reaktiva ramverk och tillÀgg anvÀnds för att hjÀlpa utvecklaren. Quarkus Àr avsedd för att bygga inte bara HTTP-mikrotjÀnster, utan Àven hÀndelsehanterade arkitekturer. Tack vare sin reaktiva natur fungerar den mycket effektivt med meddelandesystem (Apache Kafka, AMQP etc.).
Hela tricket ligger i hur man anvÀnder samma reaktiva motor för bÄde imperativ och reaktiv kod.
Quarkus hanterar detta utmĂ€rkt. Valet mellan imperativ och reaktiv Ă€r tydligt â anvĂ€nd det reaktiva kĂ€rnan för bĂ„da. Det hjĂ€lper enormt med snabb, icke-blockerande kod som hanterar nĂ€stan allt som passerar genom hĂ€ndelse-loopens trĂ„d (event-loop thread, Ă€ven kĂ€nd som IO-thread). Men om du har klassiska REST-appar eller klientbaserade applikationer stĂ„r Quarkus redo med en imperativ programmeringsmodell. Till exempel byggs HTTP-stödet i Quarkus pĂ„ anvĂ€ndningen av en icke-blockerande och reaktiv motor (Eclipse Vert.x och Netty). Alla HTTP-förfrĂ„gningar som mottas av din applikation passerar först genom hĂ€ndelse-loopen (IO Thread) och skickas sedan till den del av koden som hanterar förfrĂ„gningar. Beroende pĂ„ destination kan koden för hantering av förfrĂ„gningar köras i en separat trĂ„d (den sĂ„ kallade worker thread, anvĂ€nds för servlets och Jax-RS) eller anvĂ€nda den ursprungliga in- och utströmmen (reaktiv rutt).
För meddelandeöverföringssystemens kopplingar anvÀnds icke-blockerande klienter som arbetar ovanpÄ Vert.x-motorn. DÀrför kan du effektivt skicka, ta emot och bearbeta meddelanden frÄn meddelandemiddleware-system.
PÄ webbplatsen ett antal bra guider har sammanstÀllts för att hjÀlpa dig att komma igÄng med Quarkus:
Dessutom har vi förberett online praktiska lektioner för att bekanta dig med olika aspekter av reaktiv programmering, för att genomföra dem behövs bara en webblÀsare, ingen IDE krÀvs och datorn Àr inte nödvÀndig. Du kan hitta dessa lektioner .
Nyttiga resurser
- Quarkus-projektets webbplats â
- Quarkus-projektet pĂ„ GitHub â
- Quarkus-projektets Twitter â
- Quarkus-projektets chatt â
- Quarkus-projektets forum â !forum/quarkus-dev
10 videolektioner om Quarkus för att förstÄ Àmnet
Som nÀmns pÄ webbplatsen , en logisk kanal -orienterad Java-stack, skrÀddarsydd för GraalVM och OpenJDK HotSpot och byggd av de bÀsta Java-biblioteken och standarderna.
För att hjÀlpa dig att förstÄ Àmnet har vi valt ut 10 videolektioner dÀr olika aspekter av Quarkus och exempel pÄ dess anvÀndning behandlas:
1. Introduktion till Quarkus: Java-ramverket för nÀsta generation för Kubernetes
Författare: Thomas Qvarnstrom och Jason Greene
MÄlet med Quarkus-projektet Àr att skapa en Java-plattform för Kubernetes och serverless-miljöer, och att kombinera reaktiva och imperativa programmeringsmodeller inom en gemensam körmiljö, sÄ att utvecklare kan variera sina angreppssÀtt flexibelt nÀr de arbetar med en bred uppsÀttning distribuerade applikationsarkitekturer. LÀr dig mer i den introducerande förelÀsningen nedan.
2. Quarkus: super snabb subatomÀr Java
Författare: Burr Sutter
Videolektionen frÄn webbinarium DevNation Live visar hur man anvÀnder Quarkus för att optimera företags Java-applikationer, API:er, mikrotjÀnster och serverless-funktioner i Kubernetes/OpenShift-miljö, vilket gör dem mycket mindre, snabbare och mer skalbara.
3. Quarkus och GraalVM: vi överklockar Hibernate till superhastigheter och komprimerar till subatomÀra storlekar
Författare: Sanne Grinovero
FrÄn presentationen fÄr du veta hur Quarkus uppstod, hur det fungerar och hur det gör komplexa bibliotek som Hibernate ORM kompatibla med GraalVM-nativebilder.
4. LĂ€r dig att utveckla serverless-applikationer
Författare: Marthen Luther
I videon nedan visas hur man skapar en enkel Java-applikation med Quarkus och distribuerar den som en serverless-applikation pÄ Knative.
5. Quarkus: koda med glÀdje
Författare: Edson Yanaga
Videoguide för att skapa ditt första Quarkus-projekt, som ger en förstÄelse för varför Quarkus vinner utvecklares hjÀrtan.
6. Java och containrar â hur ser deras gemensamma framtid ut?
Författare: Mark Little
Denna presentation ger en inblick i Java:s historia och förklarar varför Quarkus Àr framtiden för Java.
7. Quarkus: super snabb subatomÀr Java
Författare: Dimitris Andreadis
Ăversikt över fördelarna med Quarkus som har fĂ„tt erkĂ€nnande frĂ„n utvecklare: enkelhet, extremt hög hastighet, bĂ€sta bibliotek och standarder.
8. Quarkus och subatomÀra reaktiva system
Författare: Clement Escoffier
Tack vare integrationen med GraalVM erbjuder Quarkus en supersnabb utvecklingsupplevelse och en subatomÀr körmiljö. Författaren talar om den reaktiva sidan av Quarkus och hur den anvÀnds för att skapa reaktiva applikationer och applikationer med strömmande data.
9. Quarkus och snabb applikationsutveckling i Eclipse MicroProfile
Författare: John Clingan
Genom att kombinera Eclipse MicroProfile och Quarkus kan utvecklare skapa fullt fungerande MicroProfile-containerapplikationer som startar pÄ bara nÄgra tiotal millisekunder. I videon gÄr vi noggrant igenom hur man kodar en containerapplikation MicroProfile för distribution pÄ Kubernetes-plattformen.
10. Java, version "Turbo"
Författare: Marcus Biel
Författaren visar hur man anvÀnder Quarkus för att skapa supersmÄ och supersnabba Java-containrar, vilket möjliggör ett verkligt genombrott, sÀrskilt i serverless-miljöer.
KĂ€lla: habr.com
