Spring Boot հավելվածի միգրացիան native image-ի. ինչպե՞ս է դա արվում
Ծանոթացեք GraalVM Native Image-ի աջակցությանը և տեղափոխեք բարդ Spring Boot հավելված՝ RealWorld հավելվածը, որը շատ ավելի բարդ է, քան պարզ «Hello World» օրինակը։
Այս անգամ դիտարկում ենք GraalVM Native Image-ի աջակցությունը։ Այս հնարավորության մասին բազմաթիվ հոդվածներ են գրվել։ Ցավոք, դրանցից շատերը հնացել են, քանի որ spring boot հավելվածների native image-ները նախկինում գեներացվում էին spring-native մոդուլով, որը հետագայում հռչակվել է հնացած (deprecated)։ Դրանից բացի, նյութերի մեծ մասը native image-ի գեներացումը ցույց է տալիս շատ պարզ հավելվածների վրա, ինչը կարող է թաքցնել որոշ մանրամասներ։ Այստեղ կցուցադրենք, թե ինչպես կատարել այս միգրացիան hello world-ից ավելի մեծ բանի համար։
Ի՞նչ է պլանը
Ինչպես նշվեց, մեր նպատակն է ցույց տալ, թե ինչպես spring boot հավելվածը տեղափոխել native հավելվածի։ Գուցե հարցնեք՝ «Ինչո՞ւ եմ ես ուզում, որ իմ հավելվածը աշխատի որպես native image»։ Դե… երկու հիմնական դրդապատճառներն են հավելվածի ավելի արագ գործարկումը (ո՞վ չէր ուզենա արտադրական հավելված, որը գործարկվում է մի քանի միլիվայրկյանում) և հիշողության ավելի փոքր սպառումը։ Այս մոտեցումը նաև թերություններ ունի, և միգրացիայի ընթացքում ինքներդ կտեսնեք, թե որտեղ են ամենամեծ դժվարությունները։ Բայց վերադառնանք պլանին։
Նախ պետք է ունենալ տեղափոխելու հավելված, և այն պետք է իրական լինի, ոչ թե աննշան hello world։ Չափազանց պարզ հավելվածը կարող է թաքցնել որոշ կարևոր մանրամասներ։ Այն զրոյից գրելու փոխարեն վերցնենք RealWorld հավելվածներից մեկը, որը հիմնվում է spring boot-ի բազմաթիվ մոդուլների վրա։ Սա թույլ է տալիս կենտրոնանալ բացառապես այն փոփոխությունների վրա, որոնք անհրաժեշտ են հավելվածը native-ի կոմպիլյացնելու համար։ Միգրացիայի համար կա հիանալի թեկնածու՝ համայնքի իրականացումը, որն աշխատում է java 17-ի և spring boot 3.0-ի վրա։ Մենք կհարմարեցնենք այս հավելվածը, որպեսզի հնարավոր լինի կառուցել նրա native image-ը։ Հավելվածը հիմնվում է մեր նախագծերում տարածված բազմաթիվ մոդուլների վրա, ինչպիսիք են spring-boot-starter-jpa-ն, spring-boot-starter-security-ն, spring-boot-starter-web-ը, hibernate-ը, h2 տվյալների բազան և ավելի փոքր գործիքներ, օրինակ Lombok-ը, ուստի այն պետք է բավարար լինի ցույց տալու համար, թե որ խնդիրները կարող են առաջանալ միգրացիայի ընթացքում։
Դրանից հետո միասին կանցնենք միգրացիայի միջով՝ ներկայացնելով լավագույն փորձը և ձեր հավելվածներում հանդիպելիք միգրացիոն որոշ խնդիրների լուծման եղանակներ։
Մինչև միգրացիան
Եթե մտադիր եք ձեր spring boot հավելվածը կառուցել որպես native image, սկսեք հայտնի սահմանափակումների մասին այս փաստաթղթին ծանոթանալուց՝ ստուգելու համար, թե արդյոք ձեր հավելվածը հիմնվում է այնտեղ նշվածներից որևէ բանի վրա։ Եթե ձեր հավելվածում ինչ-որ բան դեռ չի աջակցվում, կարող եք կամ սպասել պաշտոնական աջակցությանը, կամ այդ կոնկրետ բանը փոխարինել ուրիշ բանով։ Օրինակ՝ քանի որ log4j2-ը native image-երում չի աշխատում, native image կառուցելու փորձից առաջ պետք է անցնեք logback-ի։
Միգրացիայի քայլերը
Հետևյալ բաժինները քայլ առ քայլ ներկայացնում են միգրացիայի գործընթացը։
Մեր հավելվածի կառուցվածքը
Նախ մի փոքր ծանոթանանք հավելվածի կառուցվածքին։
├── api
├── build
├── build.gradle.kts
├── database
├── gradle
├── gradlew
├── gradlew.bat
├── settings.gradle.kts
└── src
- api – պարունակում է open api սահմանումը, մեր api-ին հարցումները՝ որպես postman collection, և փոքր սկրիպտ, որը թեստավորում է api-ն newman-ով. մենք այն կօգտագործենք հավելվածը թեստավորելու համար
- build – թղթապանակ, որը պարունակում է կառուցման բոլոր արտեֆակտները
- build.gradle.kts, settings.gradle.kts – gradle նախագծի կոնֆիգուրացիան՝ գրված kotlin dsl-ով (ի դեպ, գիտեի՞ք, որ kotlin dsl-ը այժմ լռելյայն է նոր gradle կառուցումների համար)
- gradle, gradlew, gradlew.bat – gradle wrapper-ը
- database – թղթապանակ, որը պարունակում է տվյալների բազայի սխեման
- src – հավելվածի սկզբնական կոդը
Նախապայմաններ
Native Build Tools-ով native image-եր կառուցելու համար մեզ անհրաժեշտ է GraalVM դիստրիբուտիվ։ Խնդրում եմ, խնդրում եմ, կառավարեք ձեր դիստրիբուտիվները sdkman-ով, այլ ոչ թե ձեռքով ներբեռնելով։ Մենք կօգտագործենք GraalVM-ի վրա հիմնված Liberica դիստրիբուտիվը՝ 22.3.2.r17 տարբերակը
$ sdk install java 22.3.2.r17-nik
$ sdk use java 22.3.2.r17-nik
Գործարկեք ձեր հավելվածը AOT-ով
Native image-ի կոմպիլյացիային անմիջապես անցնելու փոխարեն նախ պետք է ստուգենք, որ հավելվածը ճիշտ է աշխատում JVM-ի վրա՝ AOT-ով գեներացված սկզբնավորման կոդով։ Այս կերպ հնարավոր սխալները հայտնվում են շատ ավելի շուտ, քան եթե գործարկեինք native image-ի կոմպիլյացիայի ամբողջ գործընթացը։
Սկզբում պետք է միացնենք սկզբնավորման կոդի գեներացումը։ Ինչո՞ւ։ Ինչպես հավանաբար գիտեք, spring-ը հավելվածի գործարկման ժամանակ շատ աշխատանք է կատարում, և այդ աշխատանքից ոչինչ չի կարող կատարվել աշխատանքի ժամանակ (runtime), եթե ուզում եք native image։ Հենց դրա համար է սկզբնավորման կոդի գեներացման փուլը. այն ամենը, ինչ սովորական spring հավելվածը անում է runtime-ում, թարգմանվում է կառուցման ժամանակ գեներացված կոդի։
Լավ, gradle-ով այս կոդը գեներացնելու համար պետք է միայն plugins բաժնում ավելացնել org.graalvm.buildtools.native պլագինը։
plugins {
java
id("com.diffplug.spotless") version "6.18.0"
id("org.springframework.boot") version "3.0.5"
id("io.spring.dependency-management") version "1.1.0"
id("org.graalvm.buildtools.native") version "0.9.20"
}
Հաջորդը կառուցում ենք հավելվածը։
$ ./gradlew build
Եվ ահա մեր առաջին փոքր սխալը։
Execution failed for task ':spotlessJavaCheck'.
> The following files had format violations:
build/generated/aotSources/com/github/gavlyukovskiy/boot/jdbc/decorator/DataSourceDecoratorAutoConfiguration__BeanDefinitions.java
Ըստ երևույթին, spotless-ը ստուգում է build թղթապանակում գեներացված իմ դասերն էլ… spotless-ի կոնֆիգուրացիայի փոքր ճշգրտումը անջատում է դա։
spotless {
java {
target("src/main/java/**/*.java")
palantirJavaFormat()
indentWithSpaces()
Այժմ կարող ենք նորից գործարկել ./gradlew build։ Հավելվածն այժմ կառուցվում է AOT-ով գեներացված կոդի հետ։ Փորձենք գործարկել այն AOT-ով գեներացված սկզբնավորման կոդով, ինչը արվում է spring.aot.enabled հատկությունը միացնելով։
$ java -Dspring.aot.enabled=true -jar ./build/libs/realworld.jar
Տեղեկամատյանների (logs) հենց սկզբում պետք է տեսնենք, որ գործարկվում է AOT-ով մշակված հավելվածը։
Starting AOT-processed RealworldApplication using Java 17.0.7 with PID....
Համոզվելու համար, որ ամեն ինչ կարգին է, կարող ենք գործարկել api թեստերը։
$ ./api/run-api-tests.sh
Թվում է՝ ամեն ինչ աշխատում է։ Առայժմ լավ է։
Անցնենք native-ին
Առաջին փորձ
Երբ ձեր հավելվածը սահուն աշխատում է AOT-ով գեներացված կոդով, կարող ենք փորձել կառուցել այն native ռեժիմում։ Բայց… հավանաբար դա չէ, որ պետք է անեք առաջինը։ Ահա թե ինչու։ Native կոմպիլյացիան սկսելու համար պետք է միայն գործարկել.
$ ./gradlew nativeCompile
Սուրճի ժամանակն է… Գործընթացը տևում է մի քանի րոպե։
source
BUILD SUCCESSFUL in 4m 24s
Վերջապես մեր native image-ը պատրաստ է!!!! Գործարկենք այն։
$ ./build/native/nativeCompile/realworld
Եվ այն կոտրվեց…
Caused by: java.lang.ExceptionInInitializerError: null
at com.github.gavlyukovskiy.boot.jdbc.decorator.p6spy.P6SpyConfiguration.init(P6SpyConfiguration.java:112) ~[realworld:na]
Այսինքն՝ մեր կախվածությունների մեջ ինչ-որ տեղ կա կոդ, որը չի կարողացել սկզբնավորել որոշ փոփոխականներ։ Դա թողնում է null օբյեկտ, որին հետագայում դիմում է կոդը, ուստի առաջանում է NullPointerException։ Ինչո՞ւ սկզբնավորում տեղի չունեցավ։ Վերադառնանք սկզբին…
Հիմնական պատճառը, թե ինչու ենք ուզում native հավելված, այն է, որ այն մեզ տալիս է երկու հիանալի հատկություն՝ հավելվածի արագ գործարկում և հիշողության փոքր սպառում։ Դրանք ապահովելու համար GraalVM-ը գործում է փակ աշխարհի ենթադրությամբ (closed-world assumption), որի դեպքում ամբողջ կոդը պետք է հայտնի լինի կառուցման ժամանակ։ Դրա պատճառով վերջնական հավելվածը պարունակում է միայն այն դասերը, որոնք մեր հավելվածն իրոք օգտագործում է (հիշողության փոքր սպառում)։ Բացի այդ, կոմպիլյացիայի ընթացքում native-image կոմպիլյատորը գիտի նաև, թե որ օբյեկտներն են ստեղծվում հավելվածի գործարկման ժամանակ, և նախապես լցնում է heap-ը դրանցով. հենց դրանից է գալիս արագ գործարկումը։
Վերադառնանք խնդրին։ Կառուցման ժամանակ native-image կոմպիլյատորը չկարողացավ հայտնաբերել, որ մենք որոշ դասեր բեռնում ենք դինամիկ կերպով, ուստի դրանք դուրս թողեց վերջնական հավելվածից։ Այդ դասերը բեռնելու համար պատասխանատու կոդը փոփոխականը դրեց null, և runtime-ում մենք ստացանք NullPointerException։
Ինչպե՞ս լուծել։ Քանի որ դասին դիմում են reflection-ով, պետք է կոմպիլյատորին ասենք բեռնել այն կառուցման ժամանակ և այն հասանելի դարձնել մեր հավելվածին runtime-ում։ Դրա համար պետք է մեր reachability metadata-ն սահմանենք JSON ֆայլերով։ Այո… դա հնարավոր է, բայց ի՞նչ պետք է գրենք այդ ֆայլերում։ Պե՞տք է վերլուծենք յուրաքանչյուր գրադարան՝ պարզելու համար, թե ինչ է այն անում։
Առաջին սխալը ստանալու համար պահանջվեց 5 րոպե կառուցում։ Կարող ենք փորձել այս reachability metadata-ն ինքներս գրել, ինչը անշուշտ 5 րոպեից շատ կտևի, իսկ հետո պետք է վերակոմպիլյացնել հավելվածը, գործարկել, սխալները ուղղել, վերակոմպիլյացնել, գործարկել, սխալները ուղղել… Ո՞ւմ է ժամանակ դրա համար։ Այժմ տեսնում եք, թե ինչու սա ճիշտ ճանապարհը չէ։ Այսքան բարդ հավելվածների համար ամբողջ reachability metadata-ն ձեռքով սահմանելը գրեթե անհնար է։ Կա ավելի լավ մոտեցում։
Գործարկեք tracing agent՝ reachability metadata հավաքելու համար
Reachability metadata-ն ձեռքով գրելու փոխարեն կարող ենք գործարկել հավելվածը կցված tracing agent-ով, որը ամբողջը հավաքում է մեր փոխարեն։ Սակայն քանի որ metadata-ն հավաքվում է runtime-ում, պետք է համոզվենք, որ հավելվածի կոդի յուրաքանչյուր ուղի կատարվել է, որպեսզի agent-ը հավաքի ամեն անհրաժեշտ բան, և native image-ը մեզ անակնկալներ չպատրաստի գործարկելիս։
Եվս մեկ անգամ հավելվածը կառուցում ենք որպես jar ֆայլ։
$ ./gradlew build
Ապա գործարկում ենք հավելվածը native-image-agent-ը կցած։
$ java -agentlib:native-image-agent=config-output-dir=./src/main/resources/META-INF/native-image/ -Dspring.aot.enabled=true -jar ./build/libs/realworld.jar
Նկատեք, որ agent-ին փոխանցեցինք config-output-dir=./src/main/resources/META-INF/native-image/ կոնֆիգուրացիոն տարբերակը. երբ reachability metadata-ն հայտնվի այս թղթապանակում, native image կոմպիլյատորը ավտոմատ կերպով կվերցնի այն, երբ գործարկենք ./gradlew nativeCompile։
Հաջորդը պետք է աշխատեցնել հավելվածը, որպեսզի agent-ը կարողանա հավաքել ողջ reachability metadata-ն։ Դրա համար կարող ենք օգտագործել ./api թղթապանակում գտնվող api թեստերը։
$ ./api/run-api-tests.sh
Հավելվածը անջատելուց հետո src/main/resources/META-INF/native-image թղթապանակի JSON ֆայլերում կարող ենք տեսնել մեծ քանակությամբ կոնֆիգուրացիա։ Պարզապես պատկերացրեք, որ այս ամենը գրում եք ձեռքով…
Կառուցեք native image
Այժմ պատրաստ ենք կառուցել native image-ը։ Գնացինք։
./gradlew nativeCompile
source
BUILD SUCCESSFUL in 4m 46s
Հիմա գործարկենք այն։
$ ./build/native/nativeCompile/realworld
Այն կենդանի է!!! Վերջապես աշխատում է։ Տեսեք, թե որքան արագ գործարկվեց։ Կես վայրկյան spring boot հավելվածի համար։ Զարմանալի է։
Started RealworldApplication in 0.453 seconds (process running for 0.463)
Սակայն սպասեք. գործարկենք API թեստերը՝ համոզվելու համար, որ ամեն ինչ կարգին է։
$ ./api/run-api-tests.sh
Ցավոք, որոշ սխալներ կան…
| | executed | failed |
|--------------------|----------|--------|
| iterations | 1 | 0 |
| requests | 32 | 0 |
| test-scripts | 48 | 2 |
| prerequest-scripts | 18 | 0 |
| assertions | 194 | 69 |
Թվում է՝ hibernate-ը խնդիրներ է առաջացնում։
Caused by: org.hibernate.HibernateException: Generation of HibernateProxy instances at runtime is not allowed when the configured BytecodeProvider is 'none'; your model requires a more advanced BytecodeProvider to be enabled.
Լավ, ուրեմն hibernate-ը փորձել է գեներացնել proxy-ներ՝ օրինակ կեղտոտ վիճակի ստուգման (dirty checking) կամ ծույլ սկզբնավորման (lazy initialization) համար, բայց դա հնարավոր չէ native image-ում, քանի որ hibernate-ի ամբողջ bytecode provider-ը պետք է անջատված լինի։ Runtime-ում bytecode-ի մանիպուլյացիան բացառված է։
Կոդի հատված org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider-ից
static {
if (NativeDetector.inNativeImage()) {
System.setProperty(Environment.BYTECODE_PROVIDER, Environment.BYTECODE_PROVIDER_NAME_NONE);
}
}
Մեզ մնում է միայն մեկ տարբերակ՝ runtime-ում նույնպես անջատել hibernate-ի proxy-ների գեներացումը և բոլոր proxy-ները գեներացնել կառուցման ժամանակ։ Դրա համար կա հատուկ gradle պլագին՝ Hibernate Enhance Plugin։ Նրա տարբերակները բացատրված են Vlad Mihalcea-ի հիանալի հոդվածում։ Այս կոդը կառուցման ժամանակ գեներացնելու համար build.gradle.kts-ում պետք է երկու փոփոխություն անել։ Նախ plugins-ում ավելացրեք սա.
id("org.hibernate.orm") version ("6.2.2.Final")
ապա կարգավորեք կոդի բարելավումները.
hibernate {
enhancement {
enableDirtyTracking.set(true)
enableLazyInitialization.set(true)
enableExtendedEnhancement.set(false)
}
}
Այժմ կարող ենք նորից անցնել ամբողջ ցիկլով՝ ստուգելու համար, որ ամեն ինչ աշխատում է. կառուցել սովորական հավելված, գործարկել այն native-image-agent-ով, աշխատեցնել թեստերը reachability metadata հավաքելու համար, և վերջում կառուցել native image-ը։
Սակայն դրանից առաջ անհրաժեշտ է ևս մեկ քայլ՝ hibernate-ի բոլոր խնդիրները կարգավորելու համար։ Bytecode provider-ը (որն օգտագործում է hibernate-ը) պետք է անջատել նաև սովորական հավելվածը գործարկելիս։ Դրա երկու պատճառ կա. մենք ուզում ենք, որ agent-ով աշխատող հավելվածը ճիշտ նույնպես վարվի, ինչպես native միջավայրում, և ուզում ենք, որ սովորական հավելվածը աշխատի նույն կերպ, ինչ native-ը, որպեսզի native միջավայրում հնարավոր սխալները երևան գան շատ ավելի շուտ՝ սովորական հավելվածը թեստավորելիս։
Դրա համար կարող ենք src/main/resources-ում տեղադրել hibernate.properties ստորև նշված կոնֆիգուրացիայով։
hibernate.bytecode.provider=none
hibernate.bytecode.use_reflection_optimizer=false
Երկրորդ տողը անջատում է ReflectionOptimizer-ը, քանի որ առանց դրա անջատման մեր թեստերը ձախողվում են այս բացառությամբ.
org.hibernate.HibernateException: Using the ReflectionOptimizer is not possible when the configured BytecodeProvider is 'none'. Disable hibernate.bytecode.use_reflection_optimizer or use a different BytecodeProvider
Լավ, ժամանակն է մեկ անգամ ևս անցնել ամբողջ ցիկլով (կառուցել սովորական հավելված, գործարկել այն native-image-agent-ով, աշխատեցնել թեստերը reachability metadata հավաքելու համար և կառուցել native image)…
source
Գործարկում ենք հավելվածը և… ևս մեկ սխալ… Սա հոգնեցուցիչ է…
Caused by: com.oracle.svm.core.jdk.UnsupportedFeatureError: No classes have been predefined during the image build to load from bytecodes at runtime.
at org.graalvm.nativeimage.builder/com.oracle.svm.core.util.VMError.unsupportedFeature(VMError.java:89) ~[na:na]
at org.graalvm.nativeimage.builder/com.oracle.svm.core.hub.PredefinedClassesSupport.throwNoBytecodeClasses(PredefinedClassesSupport.java:76) ~[na:na]
at org.graalvm.nativeimage.builder/com.oracle.svm.core.hub.PredefinedClassesSupport.loadClass(PredefinedClassesSupport.java:130) ~[na:na]
at java.base@17.0.7/java.lang.ClassLoader.defineClass(ClassLoader.java:294) ~[realworld:na]
at net.bytebuddy.utility.dispatcher.JavaDispatcher$DynamicClassLoader.invoker(JavaDispatcher.java:1383) ~[na:na]
Այս սխալն ասում է, որ enhancer պլագինը runtime-ում մանիպուլյացիա է անում bytecode-ի հետ։ Բայց runtime-ում bytecode-ի մանիպուլյացիան թույլատրելի չէ. bytebuddy-ն անջատված է։ Ուրեմն ինչպե՞ս վարվենք։
Լուծումը GraalVM-ի փորձարարական հնարավորություններից մեկն է՝ Support for Predefined Classes։ Ուստի կճշգրտենք հավելվածը native-image-agent-ով գործարկող հրամանը։
Ահա թարմացված տարբերակը.
$ java -agentlib:native-image-agent=config-output-dir=./src/main/resources/META-INF/native-image/,**experimental-class-define-support** -Dspring.aot.enabled=true -jar ./build/libs/realworld.jar
Սրա շնորհիվ native-image-agent-ը որոշ bytecode պահում է որպես reachability metadata src/main/resources/META-INF/native-image թղթապանակում, և մենք կարող ենք փորձել կառուցել հավելվածը։
Սակայն եթե փորձենք, այս անգամ JaCoCo-ն խնդիր է առաջացնում։ JaCoCo-ն թեստերի ծածկույթի վերլուծիչ է, որն աշխատում է bytecode-ը գործիքավորելով (instrumenting)։ Քանի որ մենք այժմ bytecode ենք գեներացնում ./src/main/resources-ի ներսում, այն սկսում է վերլուծել նաև այդ կոդը և սխալ է տալիս՝ ասելով, որ նույն անունով դասերն արդեն վերլուծվել են (մեկ դասը եկել է սովորական սկզբնական կոդից, մյուսը՝ reachability metadata-ից)։ Ամենապարզ լուծումը գեներացված կոդը մեկ այլ տեղ դնելն է, սակայն այդ դեպքում native-image-ը պետք է վերակարգավորել՝ reachability metadata-ն այլ թղթապանակից կարդալու համար։
Ստեղծենք aot թղթապանակ նախագծի արմատում և սահմանենք այն որպես native-image-agent-ի ելքային թղթապանակ
$ java -agentlib:native-image-agent=config-output-dir=**./aot/META-INF/native-image/**,experimental-class-define-support -Dspring.aot.enabled=true -jar ./build/libs/realworld.jar
Հաջորդը aot թղթապանակը պետք է ավելացնել native-image գործիքի classpath-ին։ Դա անում ենք build.gradle.kts-ում
graalvmNative {
binaries {
names.forEach { binaryName ->
named(binaryName){
classpath("./aot/")
}
}
}
}
Սա aot թղթապանակը ավելացնում է յուրաքանչյուր երկուականի (binary) classpath-ին՝ մեր դեպքում main-ին և test-ին։
Այժմ պատրաստ ենք կառուցել հավելվածը։ Հիշեք, որ ամբողջ ցիկլը պետք է կրկնել։ Երկրո՞րդ սուրճ կուզեք։
Եվս մեկ կառուցման ցիկլից հետո (կորցրել եմ հաշիվը, թե քանի անգամ եմ անցել դրանով), կարող ենք գործարկել հավելվածը api թեստերով, և թվում է՝ ամեն ինչ աշխատում է։ Հավելվածը գործարկվում է կես վայրկյանում, ինչը մեծ հաջողություն է։
Started RealworldApplication in 0.448 seconds (process running for 0.456)
Բայց դեռ չենք ավարտել։ Իսկապես հաստատելու համար, որ հավելվածը ճիշտ է աշխատում որպես native image, unit թեստերը պետք է աշխատեն native միջավայրում։ Բավական է այս պարզ հրամանը։
./gradlew nativeTest
Թվում է՝ թեստերը ձախողվում են, քանի որ մենք օգտագործում ենք mockito. հիշո՞ւմ եք հայտնի սահմանափակումները։
Երբ mockito-ն և մի քանի hamcrest matcher-ներ հեռացվեցին, կարող ենք նորից գործարկել native թեստերը, և այս անգամ ամեն ինչ անցնում է։ Խոստանում եմ։
Ինչ երկար ճանապարհ էր…
Վերջնական մտքեր
Ինչպես տեսաք, իրական spring boot հավելվածները կարող են աշխատել որպես native image-եր, բայց դա հեշտ չէ, և աշխատող բան ստանալը շատ ժամանակ է խլում։ Այս ամբողջ հոսքը պետք է ինտեգրվի նաև CI pipeline-ին, ինչը նույնպես կարող է բարդ լինել։
Ահա մեր հավելվածը որպես native image և որպես սովորական Java հավելված աշխատելու արագ համեմատությունը։
| | startup time | occupied memory (rss) |
|---------------------|--------------|-----------------------|
| regular application | ~3 seconds | 500 Mb |
| native application | ~0.5 second | 200 Mb |
Ավելի մեծ հավելվածների համար գործարկման ժամանակի և հիշողության սպառման տարբերությունը ավելի մեծ կլինի։
Թվերը հիանալի են, ուրեմն որն է խնդիրը։ Native image-ին անցնելը ունի այս հիմնական թերությունները.
- Native image կառուցելը շատ ավելի դանդաղ է, քան սովորական կառուցումը. սովորական հավելվածը Java 17-ի temurin դիստրիբուտիվով կառուցվում է ընդամենը ~20 վայրկյանում, ուստի 5 րոպեն 20 վայրկյանի դեմ հսկայական տարբերություն է,
- ոչ բոլոր գրադարաններն են դեռ աշխատում native միջավայրում (հայտնի սահմանափակումներ),
- չկա աջակցություն JVMTI-ի, Java Agent-ների, JMX-ի կամ JFR-ի համար։ Հավելվածի ներսում կատարվողը ստուգելու համար մնում են միայն միջուկի հնարավորությունները։ Սա նաև նշանակում է, որ MXBean-ների միջոցով հավաքվող jvm heap մետրիկները (օրինակ՝ micrometer-ի կողմից) հասանելի չեն։ Ընդհանուր առմամբ, MXBean-ներից հավաքվող ոչ մի մետրիկա հասանելի չէ,
- GraalVM-ի community տարբերակում միակ առաջարկվող աղբահավաքիչը serialGC-ն է։ G1 GC-ն կարելի է օգտագործել, բայց միայն GraalVM-ի enterprise տարբերակում, որը գալիս է Oracle Java SE Subscription-ի հետ,
- JIT չկա, ուստի ձեր հավելվածի թողունակությունը ավելի ցածր կլինի։
Սա ամենը, ընկերնե՛ր։ Հուսով եմ, որ այս հոդվածը կօգնի ձեզ տեղափոխվել native image-ի. պարզապես հիշեք «ընտրել ձեր մարտիկին խելամտորեն»
Ժամանակն է փակել իմ բոլոր բաց ներդիրները… Հիանալի զգացողություն է, չէ՞։