Գնահատել նախագիծը
← Բոլոր հրապարակումները

Java ֆրեյմվորքների համեմատություն cloud-native միջավայրերի համար

Մեր բլոգում նոր շարք է սկսվում։ Այն նվիրված է Java-ի երկու ֆրեյմվորքների՝ Quarkus-ին և Micronaut-ին, որոնք դիրքավորվում են որպես Spring Boot-ի այլընտրանք։ Սպասեք արդյունավետության թեստեր միկրոսերվիսների տարբեր բեռնվածությունների դեպքում՝ թե՛ իմպերատիվ, թե՛ ռեակտիվ ոճով, և շատ ավելին։ Ստորև շարքի բացման հոդվածն է։

20 րոպե
MicronautJavaQuarkuscloud-nativeSpring Boot

Ոչ վաղ անցյալում Java էկոհամակարգում հայտնվեցին Spring Boot-ի երկու արագ զարգացող այլընտրանքներ, որոնք երկուսն էլ պայքարում են շուկայի ավելի մեծ մասի համար։ Դրանք Quarkus-ն ու Micronaut-ն են, և ի տարբերություն Spring Boot-ի՝ երկուսն էլ սկզբից ևեթ նախագծվել են native image-ների և cloud-native համակարգերի հաշվառմամբ։ Հենց դրա համար էլ ստեղծվեց Spring Native-ը։ Համացանցում հասանելի համեմատությունների մեծ մասում Quakus-ն ու Micronaut-ը դրվում են Spring Boot-ի կողքին, բայց native image-ները դիտարկման չեն առնվում։

Այս հոդվածը բացում է այդ ֆրեյմվորքներին նվիրված շարք։ Սպասեք բազմաթիվ բենչմարկների, որոնք չափում են արդյունավետությունը միկրոսերվիսների տարբեր բեռնվածությունների դեպքում՝ թե՛ իմպերատիվ, թե՛ ռեակտիվ մոտեցմամբ։ Կքննարկենք ֆրեյմվորքները, գրաֆիկները և նույնիսկ գործող հավելվածները Spring-ից տեղափոխելու ուղեցույցները։

Ինչն էր դրդել ստեղծողներին

Շատերն են օգտագործել Spring-ը, և այն հայտնի է որպես հուսալի ու հարմար գործիք, սակայն խնդիրներից զերծ չէ։ Դրանցից մեկը runtime reflection-ի վրա նրա ուժեղ կախվածությունն է, որը կարող է երկարացնել հավելվածի գործարկման ժամանակը և մեծացնել հիշողության սպառումը։

Ահա թե ինչու ստեղծվեցին Quarkus-ն ու Micronaut-ը՝ Java լեզվի տեսանկյունից լրացնելու բացը cloud-native հավելվածներում։ Այդ ֆրեյմվորքները միկրոսերվիսների համար բավականաչափ թեթև պահելու համար պետք է խուսափել runtime reflection-ից։ Այս նպատակին հասան՝ համադրելով GraalVM-ը, AOT կոդի գեներացիան և native image-ները, ինչը կրճատեց ինչպես հավելվածի գործարկման ժամանակը, այնպես էլ հիշողության ծավալը։

Spring-ի ազդեցությունը

Quarkus-ն ու Micronaut-ը երկուսն էլ ոգեշնչվել են Spring Boot-ից, քանի որ անիմաստ էր նորից հայտնագործել անիվը։ Հաճախ օգտագործվող annotation-ներից շատերն ունեն համարժեքներ Quarkus-ում և Micronaut-ում, թեև միշտ չէ, որ նույնական են։ Արդյունքում Spring Framework-ից այս ֆրեյմվորքներին անցնելը բարդ ուսումնական կորագիծ չի պահանջում։

Ինչպես նշվեց վերևում, Quarkus-ն ու Micronaut-ը ներառում են մոդուլներ, որոնք աջակցում են Spring-ի որոշ մեխանիզմների և annotation-ների, ինչը հեշտացնում է Spring-ից միգրացիան։ Այդ մոդուլները գործում են՝ Spring-ի annotation-ները փոխարինելով ֆրեյմվորքի սեփականներով։ Այս հարմարությունը, սակայն, գին ունի՝ ավելի շատ սպասարկում, ինչը երկարաժամկետ հեռանկարում կարող է բարձրացնել հավելվածի պահպանման ընդհանուր արժեքը։

Quarkus-ի թիմն առաջ գնաց ու հրապարակեց «Quarkus for Spring Developers» վերնագրով էլեկտրոնային գիրք, որը ծրագրավորողներին ծանոթացնում է Quarkus-ին և խորհուրդներ տալիս, թե ինչպես արագ ու անցավ անցնել Spring-ից։

Ի՞նչ ընդհանուր բան ունեն Quarkus-ն ու Micronaut-ը

Երկու ֆրեյմվորքներն էլ շատ մոդուլային են, ուստի կարող ենք ընտրել միայն այն մոդուլները, որոնք իսկապես պետք են մեր նախագծին։ Նրանք կիրառում են նաև «convention over configuration» սկզբունքը, ինչը նշանակում է, որ Quarkus-ն ու Micronaut-ը կարելի է նախագծին ավելացնել պարզապես որպես dependency հայտարարելով, և սահուն աշխատելու համար դրանց շատ քիչ կոնֆիգուրացիա է պետք։

Կենտրոնական հնարավորություններից է Inversion of Control (IOC) container-ը. իրագործումները որոշ չափով տարբերվում են, բայց շատ ընդհանրություններ ունեն։ Dependency Injection-ի (DI) և IOC-ի ճիշտ օգտագործումը մեր կոդը դարձնում է ավելի հեշտ թեստավորվող, փոփոխություններին ավելի բաց և թույլ կապակցված։

Native image-ների՝ reflection-ի վրա դրած սահմանափակումները շրջանցելու համար Micronaut-ն ու Quarkus-ը երկուսն էլ Ahead-of-Time (AOT) կոմպիլյացիա են օգտագործում այն գործընթացների փոխարեն, որոնք այլապես կոդ կգեներացնեին runtime-ում։ Սա նվազեցրեց թե՛ հավելվածի հիշողության ծավալը, թե՛ գործարկման ժամանակը։ Սա հատկապես արժեքավոր է serverless միջավայրերում, որտեղ միկրոսերվիսների օրինակները դինամիկ կերպով ավելացվում և պակասեցվում են՝ կախված բեռի բաշխման պահանջներից։ Իմ փորձով՝ ինտեգրացիոն թեստերը native image-ների դեպքում շատ ավելի արագ են աշխատում, ինչը կրճատում է մշակման և տեղակայման ժամանակը։

Այս ֆրեյմվորքների տրամադրած մեխանիզմներն օգտագործելու սովորական եղանակը կոդի annotate անելն է։ Նման դեկորատորները հաճախ հիմնվում են պրոքսիների վրա, այսինքն՝ օբյեկտների, որոնք գտնվում են բուն օբյեկտի և client-ի միջև։ Պրոքսիները գեներացվում են նախապես (AOT), այլ ոչ թե կառուցվում են runtime-ում runtime պրոքսիների կամ CGLIB-ի միջոցով։ Ասպեկտ-կողմնորոշված ծրագրավորման (AOP) հայտնի դեկորատորներից է @Transactional annotation-ը, որը նշում է, որ մեթոդը կամ դասը մասնակցում է տրանզակցիայի։

Այս հավելվածները կարելի է կոնֆիգուրացնել մի քանի եղանակով։ Հասանելի են կոնֆիգուրացիոն ֆայլերը, config սերվերները և միջավայրի փոփոխականները, ինչը հեշտացնում է դրանց վերաբերմունքը որպես ռեսուրսների Kubernetes-ում կամ տեղակայման այլ մոտեցումներում։

Այժմ, երբ գիտենք, թե ինչ ընդհանուր բան ունեն Quarkus-ն ու Micronaut-ը, կարող ենք նայել, թե ինչպես են տարբերվում դրանց իրագործումները։ Առաջին հայացքից այդ տարբերությունները կարող են աննկատ մնալ կամ աննշան թվալ, քանի որ թաքնված են ամուր աբստրակցիայի շերտի հետևում։

Ընդհանուր մոդուլները և իրագործումները մի հայացքով

Spring Boot native image-ներով

Spring-ի առաջին թողարկումը թվագրվում է 2002 թվականով, և այն մինչ օրս սպասարկում է Pivotal-ը (այժմ՝ VMware-ի մաս)։ 2021 թվականի մարտին Spring-ը բետա հասանելիություն տվեց նոր մոդուլի՝ Spring Native-ի, որը թույլ է տալիս Spring-ին կառուցել native image-ներ և օգտագործել ahead-of-time (AOT) կոմպիլյացիա։ Spring Boot 3.0.0-ը, որը GraalVM Native Image-ի աջակցությամբ ընդհանուր հասանելի է 2022 թվականի նոյեմբերից, փոխարինում է փորձնական Spring Native նախագծին։ Սակայն Spring Boot-ի և Spring Cloud-ի ոչ բոլոր ընդլայնումներն են լիովին աջակցվում։

Վեբ սերվեր

Spring Boot 3.0.0-ն աջակցում է servlet-ներ Tomcat-ի, Jetty-ի կամ Undertow-ի վրա։ Webflux մոդուլով և ռեակտիվ մոտեցմամբ Web բաղադրիչն աջակցվում է Jetty-ի վրա, իսկ Websocket-ները՝ Tomcat-ի, Jetty 9-ի, Undertow-ի և Reactor Netty-ի կողմից։

Սերիալիզացիա

Լռելյայն JSON և XML տվյալների սերիալիզացիան ու դեսերիալիզացիան կատարում է Jackson-ը։ Spring-ը կարող է նաև Gson-ը օգտագործել որպես JSON սերիալիզատոր։ Սակայն եթե ձեր հավելվածին պետք է HATEOAS (Hypermedia as the Engine of Application State), պետք է մնաք Jackson-ի վրա, քանի որ Gson-ն այնտեղ չի աջակցվում։

REST API հաղորդակցության փոխարեն կարելի է նաև GraphQL օգտագործել՝ Spring GraphQL մոդուլի շնորհիվ։

Տվյալների բազա

Native image-ները լիովին չեն աջակցում տվյալների բոլոր մոդուլները, բայց դեռ կան մի քանիսը, որոնցից կարելի է ընտրել, այն է՝ Spring Data JDBC, Spring Data R2DBC և Spring Data JPA։ JPA-ի դեպքում պարտադիր է Hibernate-ի build-time bytecode enhancement plugin-ը։ Spring-ի լռելյայն JDBC connection pool-ը HikariCP-ն է։ Հիշեք, որ այդ բոլորը սոսկ աբստրակցիաներ են իրական տվյալների բազայի միացման վրա։ Այս պահին Spring-ն աջակցում է միայն այն տվյալների բազաների connector-ներին, որոնց մետատվյալները գտնվում են GraalVM Reachability Metadata Repository-ում կամ տրամադրվում են օգտագործողի կողմից։ Աջակցվող տվյալների բազաների թվում են Postgres, MySQL և H2։

NoSQL-ի համար հասանելի են հետևյալ տվյալների բազաները՝ ElasticSearch, Neo4j, Redis և MongoDB։ Այստեղ չնշված NoSQL մոդուլների փաստաթղթերը կարդալիս հանդիպեցի մի քանի նշումների, որոնք զգուշացնում էին, որ որոշ հնարավորություններ կարող են ձախողվել, քանի որ հիմնվում են CGlib պրոքսիի վրա։ Ուստի դրանք պետք է ինքներդ ստուգեք։

Cloud

Այս wiki էջը նկարագրում է Spring Cloud մոդուլների սահմանափակումները։ Այդուհանդերձ, ստորև կանդրադառնանք նաև այլ մոդուլների, քանի որ էջը ամեն ինչ չի ընդգրկում. ոչ բոլոր մոդուլներն են ստեղծված Spring Cloud թիմի կողմից։

Cloud պրովայդերների և cloud-native ճարտարապետության հետ ինտեգրման համար կան մոդուլներ թե՛ GCP-ի, թե՛ Azure-ի համար, ուստի օգտագործողներն ընտրության հնարավորություն ունեն։ Wiki-ն թվարկում է, թե որ հնարավորություններն են աջակցվում native կոմպիլյացիայի դեպքում։ AWS-ն ունի բաց milestone Spring 3.0.0-ի համար, իսկ native աջակցության առաջընթացին կարելի է հետևել այստեղ։

Spring Cloud Function-ը լրացուցիչ առաջարկում է ինտեգրում AWS lambda-ի, Azure functions-ի և GCP-ի հետ։ Ցավոք, Spring Cloud Kubernetes-ը դեռ չի աջակցվում։

Tracing-ի և մետրիկաների համար Micrometer-ը միակ տարբերակն է։ Spring Cloud Sleuth-ը Spring 2.X-ում աշխատում է Spring Native-ի հետ միասին, բայց Spring Boot 3.0.0-ում չի աջակցվում, քանի որ տեղափոխվել է Micrometer Tracing-ի մեջ։

Սերվիսների հայտնաբերման համար կարող ենք օգտագործել նաև Eureka Client-ը, թեև Eureka Server-ը չի աջակցվում։

Ամփոփում

Թեև Spring-ը հասուն գործիք է, կարծում եմ՝ այն ունի մրցակիցների համեմատ ամենամեծ թերությունը։ Նրա մի քանի մոդուլներ գրված կամ նախագծված չեն եղել native կոմպիլյացիան նկատի ունենալով։ Արդյունքում դրանցից որոշները native image-ներում լրացուցիչ կոնֆիգուրացիա են պահանջում, ունեն սահմանափակումներ կամ դեռ չեն աջակցվում։ Դրան գումարած՝ native image-ներ կոմպիլյացնելիս մի քանի խնդրի հանդիպեցի, որոնցից մի քանիսը պայմանավորված էին Macbook-ի M1 չիպով։ Պարզ հավելվածի կոմպիլյացիան buildpack-ներով կարող էր տևել ավելի քան 10 րոպե, իսկ երբեմն ընդհանրապես չէր ավարտվում։

Micronaut

Micronaut-ը ստեղծվել է 2018 թվականի մայիսին Գրեմ Ռոչերի (Graeme Rocher) կողմից, որը հայտնի է որպես Grails ֆրեյմվորքի հեղինակ։ Object Computing-ի հետ միասին նա Micronaut-ի համար հիմնադրամ ստեղծեց, որը համախմբում է հայտնի ընկերությունների՝ JetBrains-ի, Microsoft-ի և Amazon-ի ծրագրավորողներին՝ այն զարգացնելու համար։ Ֆրեյմվորքն ունի խիստ մոդուլային դիզայն, և նրա հեղինակները նշում են, որ IOC container-ը կարելի է օգտագործել որպես ինքնուրույն գրադարան՝ առանց Micronaut-ի որևէ այլ հնարավորության։ Այն աջակցում է Java, Kotlin և Groovy լեզուներին։

Վեբ սերվեր

Micronaut-ի վեբ սերվերը լռելյայն servlet-ներ չի օգտագործում. այն կառուցված է Netty Framework-ի վրա՝ թե՛ արգելափակող, թե՛ չարգելափակող IO-ի համար։ Netty-ն ասինխրոն, իրադարձություններով կառավարվող ֆրեյմվորք է, որի առանձնահատկությունն այն է, որ կարող է մեկ thread-ով սպասարկել բազմաթիվ client-ների։ Դասական servlet-ները, ընդհակառակը, յուրաքանչյուր client-ի համար ստեղծում են առանձին thread, որը մնում է արգելափակված մինչև հարցման ավարտը։ Servlet-ները շարունակում են հասանելի մնալ Micronaut Servlet-ի միջոցով, որն աջակցում է Tomcat, Jetty և Undertow։

HTTP սերվերին ավելի ուշադիր նայելիս տեսնում ենք, որ Micronaut-ը, ճիշտ Spring-ի նման, իրագործում է URI template-ների RFC-6570 սպեցիֆիկացիան, ինչպես նաև RFC-491-ը՝ հատուկ HTTP մեթոդների համար։

Սերիալիզացիա

Micronaut-ը նույնպես հենվում է Jackson-ի վրա որպես իր լռելյայն JSON և XML սերիալիզատոր՝ կոնֆիգուրացված օգտագործելու Bean Introspection API-ն, ինչը վերացնում է reflection-ի անհրաժեշտությունը։ Դրան գումարած՝ Micronaut Serialization մոդուլը կառուցված է Bean Introspection API-ի վրա։ Այն մշակում է նաև Jackson, JSON-B և BSON annotation-ները։ Ինձ ամենից շատ դուր է գալիս այն, որ annotation-ները վավերացվում են կոմպիլյացիայի ժամանակ։ Օրինակ, եթե @JsonFormat-ում սխալ ամսաթվի ձևաչափ գրեք, կոմպիլյացիան ձախողվում է սխալով։

Հեղինակները ուշադրություն են դարձրել նաև անվտանգությանը. միայն @Serdeable-ով annotate արված դասերը կարող են սերիալիզացվել կամ դեսերիալիզացվել։ Սա թույլ չի տալիս սերիալիզացնել այն օբյեկտները, որոնք չենք ուզում բացահայտել, օրինակ՝ entity-ները։ Այն դասերը, որոնք ինքներս չենք կարող annotate անել, կարելի է ներմուծել @SerdeImport annotation-ով, որը սովորաբար դրվում է Application դասի վրա։

REST API հաղորդակցության փոխարեն GraphQL կարելի է օգտագործել Micronaut GraphQL մոդուլի միջոցով։

Տվյալների բազա

Micronaut Data-ն, որը Spring Data-ի համարժեքն է, աշխատում է բազմաթիվ JDBC դրայվերների հետ, այդ թվում՝ H2, Postgres, Oracle, MariaDB, MySQL և MS SQLServer։ Դրանցից որևէ մեկն օգտագործելու համար պարզապես ավելացնում եք այն որպես dependency, և Micronaut Data-ն ավտոմատ կոնֆիգուրացնում է այն։ Spring Data-ից հիմնական տարբերությունն այն է, որ Micronaut Data-ն ընդհանրապես խուսափում է reflection-ից և runtime պրոքսիներից և հարցումների տիպային անվտանգությունը ստուգում է կոմպիլյացիայի ժամանակ։ Connection pooling-ի համար Micronaut-ն օգտագործում է Apache DBCP2, Oracle UCP, HikariCP և Tomcat։ Կա նաև Jooq-ի ինտեգրում՝ Java-ում տիպային անվտանգ հարցումներ գրելու համար։

Micronaut Hibernate Reactive-ը և Micronaut R2DBC-ն թույլ են տալիս ռեակտիվ հաղորդակցություն տվյալների բազայի հետ աջակցվող դրայվերների միջոցով, ինչպիսիք են H2, PostgreSQL, MySQL, MariaDB և SQL Server։

Ընդգրկված են նաև տարածված NoSQL տվյալների բազաները, այդ թվում՝ MongoDB, Cassandra, DynamoDB, Redis, Neo4j և Elastic Search։

Cloud

Micronaut-ը ինտեգրվում է cloud ծառայությունների ավելի լայն շրջանակի հետ, քան Spring-ը՝ native image-ների դեպքում։ Այն ընդգրկում է բոլոր խոշոր cloud պրովայդերներին և նրանց ծառայությունները, ինչպիսիք են AWS, GCP, Azure և Oracle Cloud։ Այն տրամադրում է նաև Micronaut Object Storage՝ տվյալների bucket-ների վրա աբստրակցիա, որն աշխատում է վերը թվարկված cloud-ների հետ։

Kubernetes-ն ունի իր սեփական ինտեգրումը, որը սահմանափակվում է սերվիսների հայտնաբերմամբ, config map-երի և secret-ների client-ներով և Kubernetes Java SDK-ի պաշտոնական client-ի վրա կառուցված շերտով։

Micronaut-ն աջակցում է Ribbon-ին և Hystrix-ին՝ Netflix-ի երկու գրադարանների, որոնք ստեղծված են cloud-ի համար։ Ribbon-ը client-side load balancer է, իսկ Hystrix-ն ապահովում է սխալների և ուշացումների հանդուրժողականություն այնպիսի մեխանիզմներով, ինչպիսին circuit breaker-ն է։ Նոր նախագծերի համար Hystrix-ը, սակայն, չէի խորհուրդ տա, քանի որ 2018 թվականից այն գտնվում է միայն սպասարկման ռեժիմում։ Resilience4j-ը ողջամիտ փոխարինող է և ունի իր սեփական ինտեգրումը Micronaut-ի հետ, թեև Micronaut-ի թիմը այդ ինտեգրումը չի սպասարկում։

Micronaut Tracing մոդուլը ևս մեկ աբստրակցիա է, որն աջակցում է Jaeger-ին և Zipkin-ին, որոնք երկուսն էլ իրագործում են Open Tracing API-ն։ Նախագիծը աջակցում է նաև OpenTelemetry-ին։

Վերջին cloud աբստրակցիան Micronaut Service discovery-ն է՝ Eureka-ի, Consul-ի և Spring Cloud Config Server-ի աջակցությամբ։ Spring մոդուլների ինտեգրման շնորհիվ այդ լուծումից անմիջապես հրաժարվելու կարիք չկա. կարող ենք նոր սերվիսները կառուցել Micronaut-ով և հին սերվիսները տեղափոխել աստիճանաբար։

Ամփոփում

Micronaut-ն առաջարկում է բազմաթիվ ինտեգրումներ, որոնք աշխատում են native image-ներում և լավ իմաստով շատ առումներով նման է Spring-ին։ Նրա թիմը նպատակ ունի reflection-ը հասցնել զրոյի և պատրաստ է ստեղծել սեփական լուծումներ, երբ կարծում է, որ կարող է ավելի լավը անել։ Այդ ջանքերի շնորհիվ Micronaut-ը ապահովում է մրցակիցներից զգալիորեն ավելի ուժեղ տիպային անվտանգություն։

Quarkus

Quarkus-ը ստեղծվել է 2019 թվականի մարտին RedHat-ի կողմից՝ ընկերության, որը հայտնի է իր Linux արտադրանքներով և այնպիսի գործիքներով, ինչպիսիք են Ansible-ը և Openshift-ը, ինչպես նաև Java-ի համար իր OpenJDK build-ով։ Այն RedHat-ի ստեղծած երեք գործիքներից ամենանորն է։ Նրա մշակողները Quarkus-ը ներկայացնում են որպես Kubernetes-native ֆրեյմվորք, օպտիմալացված ցածր հիշողության սպառման և արագ գործարկման համար։ Այն աջակցում է Java, Kotlin և Scala լեզուներին, ընդ որում Scala-ն պահանջում է առանձին մոդուլ և լրացուցիչ կոնֆիգուրացիա։

GraalVM-ն ունի Quarkus-ի համար նախատեսված առանձին դիստրիբուտիվ՝ Mandrel անունով, որը ստեղծվել է սպասարկումը հեշտացնելու համար։ Mandrel-ը կառուցված է ստանդարտ OpenJDK-ի և Red Hat Enterprise Linux-ի գրադարանների վրա, այլ ոչ թե Labs OpenJDK-ի։ Այն ամբողջությամբ կենտրոնացած է native image-ների մշակման վրա և հեռացնում է GraalVM-ի այն մասերը, որոնք Quarkus-ին պետք չեն, օրինակ՝ Truffle Framework-ը և Polyglot-ը։

Վեբ սերվեր

Quarkus-ն աջակցում է թե՛ ռեակտիվ, թե՛ իմպերատիվ ծրագրավորում, և երկուսն էլ իրագործված են Vert.x-ի վրա, որը սպասարկում է Eclipse Foundation-ը։ Quarkus-ը ներառում է նաև Undertow-ի հարմարեցված տարբերակ, որն աշխատում է Vert.x-ի վրա և հնարավորություն է տալիս օգտագործել Servlet-ներ։

Իր HTTP շերտի համար Quarkus-ն օգտագործում է RESTEasy-ը՝ RedHat-ի սերտիֆիկացված իրագործումը JAX-RS սպեցիֆիկացիայի։ RESTEasy-ն իրագործում է նաև MicroProfile REST Client API-ը, որը թույլ է տալիս ծրագրավորողներին կառուցել տիպային անվտանգ client-ներ իրենց API-ների համար։ Ինտերֆեյսի վրա ճիշտ JAX-RS annotation-ներ դնելով՝ ծրագրավորողները ստանում են REST Client օրինակ և կարող են կանչել controller-ը այնպես, կարծես այն ուղղակիորեն կանչում են։ Սա պարզեցնում է RESTful վեբ սերվիսների կառուցումն ու սպասարկումը Quarkus հավելվածում։

Սերիալիզացիա

Quarkus-ը JSON սերիալիզացիայի սեփական մեխանիզմ չի տրամադրում և փոխարենը հենվում է Jackson-ի և JSON-B-ի վրա։ XML սերիալիզացիան պահանջում է նախագծին ավելացնել quarkus-resteasy-jaxb և quarkus-resteasy մոդուլները։

Ավանդական REST API-ի այլընտրանքով Quarkus-ը թույլ է տալիս օգտագործել GraphQL՝ SmallRye GraphQL-ի միջոցով։

Տվյալների բազա

Quarkus-ն աշխատում է բազմաթիվ JDBC դրայվերների հետ, ինչպիսիք են DB2, Derby, H2, MariaDB, Microsoft SQL Server, MySQL, Oracle և PostgreSQL։ Connection pooling-ը կառավարվում է Agroal-ով, և տվյալների բազայի հետ աշխատելու երեք եղանակ կա՝ սովորական JDBC, JPA՝ Hibernate Framework-ով և Panache։ Panache-ն առաջարկում է Repository Pattern կամ Active Record, վերջինս Java էկոհամակարգում բավականին անսովոր մոտեցում է։ Reactive Hibernate-ը, որը կարելի է համադրել Panache-ի հետ, աջակցում է SQL տվյալների բազաներ, ինչպիսիք են Db2, PostgreSQL, MariaDB/MySQL, Microsoft SQL Server և Oracle։

Աջակցվում են NoSQL տվյալների բազաներից մի քանիսը, այդ թվում՝ MongoDB, Cassandra, Elastic Search, DynamoDB, Neo4j և Redis։ Յուրաքանչյուրն ունի իր նվիրված Quarkus մոդուլը։ MongoDB-ն լրացուցիչ աշխատում է նաև Panache-ի հետ։

Cloud

Quarkus-ը տրամադրում է առանձին ընդլայնում՝ Kubernetes, OpenShift և Knative ռեսուրսներ գեներացնելու, դրանք կոնֆիգուրացնելու և Kubernetes API-ն օգտագործելու համար։ OpenShift-ի առանձին ընդլայնումը փաթաթում է Kubernetes-ը և container-image-s2i-ը։ Միասին վերցրած՝ OpenShift–Quarkus ինտեգրումը ուժեղ գործիքակազմ է տալիս հավելվածները Kubernetes միջավայրում կառավարելու և տեղակայելու համար։

Խոշոր cloud պրովայդերները, ինչպիսիք են AWS-ը, Azure-ը և GCP-ն, ունեն ինտեգրումներ, որոնք հեշտացնում են նրանց ծառայությունների օգտագործումը. դրանցից մեկը Funqy-ն է։ Funqy-ն առաջարկում է ընդհանուր ինտերֆեյս այնպիսի ֆունկցիաներ գրելու համար, որոնք կարելի է տեղակայել տարբեր serverless հարթակներում, այդ թվում՝ AWS Lambda, Azure Functions, Google Cloud Functions, Knative և Knative Events (Cloud Events)։

Micrometer-ը գործիք է հավելվածի արդյունավետությունը հետևելու և չափելու համար։ Այն հավաքում է runtime մետրիկաներ և դրանք բացահայտում OpenMetrics-ին համապատասխանող endpoint-ով, որից Prometheus-ը կարող է դրանք հավաքել՝ վերահսկելու և վերլուծելու համար։

SmallRye Strock-ը Quarkus-ում սերվիսների հայտնաբերման միակ ինքնուրույն տարբերակն է, բայց Kubernetes-ի նման cloud հարթակում կարող եք հենվել նաև հենց հարթակի առաջարկած սերվիսների հայտնաբերման վրա։ Ճիշտ Micronaut-ի նման՝ Spring Cloud Config Server-ն աջակցվում է, ուստի Spring էկոհամակարգը կարելի է փոխարինել քայլ առ քայլ։

Telemetry-ի և tracing-ի համար կարող եք ընտրել OpenTelemetry կամ OpenTracing, բայց OpenTracing-ը այժմ deprecated է, և նրա մշակողները խորհուրդ չեն տալիս այն օգտագործել։

Ամփոփում

Quarkus-ը ճկուն ֆրեյմվորք է, որը լավ ինտեգրվում է RedHat-ի այլ գործիքների հետ։ Եթե արդեն ծանոթ եք RedHat-ի գործիքակազմին կամ մտադիր եք այն օգտագործել ձեր նախագծում, Quarkus-ը կարող է խելամիտ ընտրություն լինել։ Նկատի ունեցեք նաև, որ Mandrel-ը՝ Quarkus-ի ենթանախագիծը, հետագայում կարող է լրացուցիչ հնարավորություններ կամ բարելավումներ բերել, որոնք այն կարող են տարբերակել սովորական GraalVM-ի վրա կառուցված ֆրեյմվորքներից։

Build գործիքներ

Յուրաքանչյուր ֆրեյմվորք ստանդարտ build գործիքներ է աջակցում՝ Maven և Gradle, իսկ որոշները ավելացնում են լրացուցիչ plugin-ներ cloud-native հավելվածներ կառուցելու համար։ Մի հնարավորություն, որը բոլորն ունեն, native image-ներ կառուցելն է Buildpacks-ով։ Buildpacks-ով native image կառուցելը պահանջում է Docker, սակայն ձեռքով տեղադրվող native գործիքներ պետք չեն։

Micronaut-ն ու Quarkus-ն առաջարկում են plugin-ներ, որոնք ինտեգրվում են native գործիքների հետ, բայց այդ գործիքները պետք է տեղադրվեն ձեռքով։ Spring Native-ը native գործիքների ներկառուցված աջակցություն չունի, թեև կան օրինակներ, որոնք ցույց են տալիս, թե ինչպես դրանք օգտագործել։ Նկատի ունեցեք, որ native գործիքները չեն կարող կատարել cross-compilation, ուստի դրանք պետք է տեղադրել յուրաքանչյուր հարթակում, որի համար ուզում եք build անել։

Quarkus-ի մեջ ինձ տպավորում է այն, որ այն աջակցում է container-ներ կառուցելու ևս երկու եղանակ՝ Jib և S2i, որոնցից վերջինը կարող է container-ներ կառուցել OpenShift կլաստերում։

Նախագծի սկզբնավորում

Յուրաքանչյուր ֆրեյմվորք ունի նոր նախագիծ ստեղծելու իր եղանակները, ինչպես նաև լրացուցիչ գործիքներ և հնարավորություններ, որոնք հարմարավետ են դարձնում նրա հետ ամենօրյա աշխատանքը։

Starter կայքը

Յուրաքանչյուր ֆրեյմվորք ունի պարզ կայք, որը գեներացնում է zip ֆայլ՝ նախագծի կաղապարով։ Այդ կայքերում կարելի է սահմանել նախագծի անունը, ֆրեյմվորքի և Java-ի տարբերակները, ծրագրավորման լեզուն, build գործիքը և ֆրեյմվորքը ընդլայնող ցանկացած լրացուցիչ մոդուլ։ Դրանցից ոչ մեկը այս հարցում առանձնանում չէ, քանի որ բոլորն էլ գրեթե նույն հնարավորություններն են տրամադրում։

Jetbrains Intellij

JetBrains-ի այս հանրաճանաչ IDE-ում միայն Ultimate տարբերակը կարող է ուղղակիորեն ստեղծել այս նախագծերը՝ առանց լրացուցիչ plugin-ների։ Այն ունի նաև լրացուցիչ հնարավորություններ, որոնք արագացնում են նախագծում նավիգացիան և մշակումը։

Quarkus-ը ֆրեյմվորքներից միակն է, որն ունի IntelliJ Community Edition-ի (CE) համար պաշտոնական plugin՝ «Quarkus Tools» անունով։ RedHat-ի ստեղծած այս plugin-ը հեշտացնում է նոր Quarkus նախագծերի ստեղծումը և առաջարկում կոդի օգնություն։ IntelliJ-ի plugin manager-ը թվարկում է նաև համայնքի ստեղծած plugin-ներ Spring Boot-ի և Quarkus-ի համար, բայց Micronaut-ի համար ոչ մի plugin գտնել չկարողացա։

CLI

Նախագծեր ստեղծելու գործիքներից բացի ֆրեյմվորքները տրամադրում են նաև հրամանների շարք՝ հավելվածները թեստավորելու և տեղակայելու համար։ Այդ հրամանները գնում են ավելի հեռու, քան նախագծի գեներացիան, և ավելացնում են լրացուցիչ հնարավորություններ ձեր նախագծերը կառավարելու և դրանց հետ աշխատելու համար։

GraalVM

Բոլոր ֆրեյմվորքները հենվում են GraalVM-ի վրա, ուստի բոլորը կիսում են native image կոմպիլյացիայի սահմանափակումները։ Մենք հրաժարվում ենք JVM-ի (Java Virtual Machine) ամենամեծ ուժեղ կողմից՝ write once, run anywhere։ Serverless միջավայրերում, սակայն, այս թերությունը քիչ նշանակություն ունի, քանի որ image-ները սովորաբար կոնտեյներացվում են, օրինակ՝ Docker-ում։ Մնացած սահմանափակումները ուշադրության են արժանի, քանի որ դրանք շատ ավելի են ազդում այն բանի վրա, թե ինչպես ենք գրում մեր native հավելվածները։

  • Native image-ը ներառում է միայն այն կոդը, որին հասնում է ստատիկ վերլուծությունը հավելվածի մուտքի կետից սկսած։ Մնացած ամեն ինչ հեռացվում է, եթե hint ֆայլերում չնշեք, թե հավելվածի որ մասերը պետք է պահպանվեն։ GraalVM Hint Processor-ը կարող է նման ֆայլեր ավտոմատ գեներացնել annotation-ներից։ Այս սահմանափակումները հիմնականում վերաբերում են այնպիսի մեխանիզմներին, ինչպիսիք են reflection-ը, դինամիկ պրոքսին, սերիալիզացիան և դասերի դինամիկ բեռնումը։ Ուստի գրադարան ընդունելուց առաջ ստուգեք, որ ձեր օգտագործած հնարավորությունները աշխատում են native image-ներում։
  • Classpath-ը ֆիքսվում է build-ի ժամանակ և հետագայում չի կարող փոփոխվել
  • Native Image-ը չի աջակցում JVMTI, Java Agents, JMX, JFR կամ bytecode-ի վրա հիմնված այլ գործիքներ
  • Որոշ deprecated մեթոդներ, օրինակ՝ Thread.stop()-ը Java.lang. Thread-ից, չեն աջակցվում

Սա native image-ների սահմանափակումներից միայն մի ընտրանի է՝ նրանք, որոնք ես համարում եմ ամենակարևորը։ Ավելի ամբողջական նկարագրության համար անցեք անմիջապես մշակողի կայք։ Հիշեք, որ սահմանափակումները GraalVM-ի զարգացմանը զուգընթաց փոխվում են, ուստի արժե հետևել դրանց։

Փաստաթղթեր

Իմ փորձով՝ Spring-ի և Micronaut-ի փաստաթղթերը ամենալիարժեքն են՝ ամեն ֆրեյմվորքի աշխատանքը սովորելու և տարբերությունները նկատելու համար։ Quarkus-ի փաստաթղթերը, կարծում եմ, զգալիորեն հետ են մնում։ Ինձ համար լավագույնը մանրամասն փաստաթղթերն են, որոնք կազմում են համահունչ ամբողջություն՝ կառուցվածքավորված և դասավորված գրքի նման։ Դա հանգստացնում է, որ եթե ամեն ինչ կարդամ հեղինակների նախատեսած հաջորդականությամբ, կարևոր ոչինչ չեմ բաց թողնի։ Օրինակներով ձեռնարկները պետք է միայն լրացնեն փաստաթղթերը, այլ ոչ թե կազմեն դրանց հիմքը։

Micronaut-ին արժանի է գովասանք private API-ին նվիրված ամբողջ բաժնի համար, որը բացատրում է, թե ինչ է կատարվում ներսում։ Մեխանիզմները նկարագրված են նաև բավականաչափ մանրամասն։ Դրա շնորհիվ ինձ երբեք չի հարկավորվել փորփրել նախագծի սկզբնական կոդը՝ ֆրեյմվորքի մեխանիզմների աշխատանքն ավելի խորը հասկանալու համար։ Նրանք վարում են նաև սեփական վեբինարների շարք, որը հասանելի է YouTube-ում։

Quarkus-ում փաստաթղթերը կառուցված են ձեռնարկների շուրջ։ Դրանց միջև տեղաշարժվելը բավականին հոգնեցնող է, և ուսումնական հստակ ուղի նախանշված չէ։ Փաստաթղթերը չեն բացատրում, թե ինչպես է ֆրեյմվորքը աշխատում ներսից, և ես միակը չեմ, ով դա նկատել է. GitHub-ում բացվել է առանձին issue՝ այս հարցին անդրադառնալու համար։ Ցավոք, այն մնացել է բաց 2 տարի, և ոչինչ չի վկայում, որ մշակողները մտադիր են փաստաթղթերը ընդլայնել այդ ուղղությամբ։

Այն բանի օրինակներից մեկը, ինչ Quarkus-ը թողնում է չասված, bean scope-ի անորոշ բացատրությունն է, որը core մոդուլի մաս է կազմում։ Quarkus-ն ունի bean scope, որն արտահայտվում է @Singleton annotation-ով։ Այն նման է Spring-ից ծանոթ @Scope(“singleton”)-ին՝ մեկ կարևոր տարբերությամբ. այն client-proxy չի օգտագործում։ Սա ինձ մտածելու տվեց՝ արդյոք դեկորատորները կամ interceptor-ները աշխատում են @Singleton scope-ի հետ։ Փաստաթղթերը դրա պատասխանը չտվեցին, ուստի ստիպված եղա ինքս ստուգել debugger-ով։ Պարզվեց, որ @Transactional-ի նման annotation-ների դեպքում պրոքսի իսկապես օգտագործվում է, սակայն subclass պրոքսին ոչ մի տեղ չի հիշատակվում՝ բացի AOT գեներատորների սկզբնական կոդից։

Ամփոփում

Ինձ համար դժվար է այս ֆրեյմվորքներից որևէ մեկին հստակ հաղթող հայտարարել։ Ինչպես մեր ոլորտում ամեն ինչի դեպքում, այն կախված է հանգամանքներից, քանի որ յուրաքանչյուր նախագիծ ունի իր պահանջներն ու առաջնահերթությունները։ Մի թիմի համար տվյալ հնարավորության կոնկրետ իրագործումը կարող է վճռորոշ լինել, մեկ այլ թիմի համար ամենակարևորը վստահությունն է, որ սպասարկողը կշարունակի զարգացնել և աջակցել ֆրեյմվորքը երկար տարիներ։ Ամեն դեպքում, ֆրեյմվորք ընտրելուց առաջ գրեք ձեր պահանջները և դրանց միջոցով որոշեք, թե որ տարբերակն է ձեզ համապատասխանում։

Սրանով ավարտվում է շարքի ներածությունը։ Եթե կարծում եք, որ ինչ-որ բան բացակայում է, կամ ցանկանում եք, որ խորանանք կոնկրետ թեմայի մեջ, գրեք մեզ մեկնաբանություններում։