The Path Towards Spring Boot Native Applications
5 likes818 views
The document discusses the development of Spring Boot native applications using GraalVM, focusing on their benefits such as instant startup and reduced memory consumption. It outlines the compilation process and configuration requirements for creating native executables and provides an overview of the timeline and updates for Spring-GraalVM-Native integration. Key goals include improving resource efficiency and enabling serverless capabilities for Spring Boot applications.
![Update configuration to avoid using proxies
40
@SpringBootApplication(proxyBeanMethods = false)
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}](https://image.slidesharecdn.com/nativeapplicationsspringone2020-200909224113/85/The-Path-Towards-Spring-Boot-Native-Applications-40-320.jpg)
![For additional native configuration (eg. resources)
● Create a META-INF/native-image/resource-config.json file
● Wildcard patterns can be used
● Similar config for reflection and proxies
● See GraalVM documentation for more details
{
"resources": [
{ "pattern": "myresource.*" }
],
"bundles": [
{ "name": "your.pkg.Bundle" }
]
}
53](https://image.slidesharecdn.com/nativeapplicationsspringone2020-200909224113/85/The-Path-Towards-Spring-Boot-Native-Applications-53-320.jpg)
The Path Towards Spring Boot Native Applications
- 1. The Path Towards Spring Boot Native Applications September 2–3, 2020 springone.io Join https://springone.slack.com #session-the-path-towards-spring-boot-native-applications 1 Andy Clement Sébastien Deleuze
- 2. Safe Harbor Statement The following is intended to outline the general direction of VMware's offerings. It is intended for information purposes only and may not be incorporated into any contract. Any information regarding pre-release of VMware offerings, future updates or other planned modifications is subject to ongoing evaluation by VMware and is subject to change. This information is provided without warranty or any kind, express or implied, and is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions regarding VMware's offerings. These purchasing decisions should only be based on features currently available. The development, release, and timing of any features or functionality described for VMware's offerings in this presentation remain at the sole discretion of Pivotal. Pivotal has no obligation to update forward looking information in this presentation. 2
- 3. Agenda ● Native applications ● Spring Boot native applications ● Where are we? ● Getting started ● Demo ● spring-graalvm-native ● The road ahead 3
- 5. 5 Native ahead-of-time compilation Java or Kotlin application GraalVM native compiler Native executable Lightweight container image EXE0110 5
- 6. Two main benefits 6 Instant startup Reduced memory consumption
- 7. 7 Scale to zero You only pay when your application is used Serverless for any kind of workload including regular web applications Good fit with platforms like Knative 3x to 5x memory reduction (RSS) Cheaper cloud instances Critical with systems splitted into multiple microservices Instant Startup Reduced memory consumption Our goal is cheaper hosting of your Spring Boot applicationsCheaper and more sustainable Spring Boot applications 7
- 8. JVM and native executables trade-offs 8
- 9. Key differences between JVM and native 9 ● Static analysis of your application from the main entry point ● Configuration required for: ○ Reflection ○ Proxies ○ Resources ● Classpath fixed at build time ● No class lazy loading ● Some code will run at build time
- 10. GraalVM native is a source of inspiration for the JVM ecosystem 10
- 11. An upcoming Java platform standard with Project Leyden 11
- 12. GraalVM 20.2 ● Better static container image support ● Faster native image generation ● java.* and javax.* classes are now mostly initialized at runtime ● Enterprise edition only ○ Low Latency Garbage Collector (G1 like) ○ Loop unrolling optimization 12
- 13. Still in “early adopter” mode (supported with breaking changes) but matures quickly 13
- 14. Spring Boot native applications
- 15. Good fit with Spring Boot stand-alone deployment model 15
- 16. Compiling your application to a native executable requires reflection/proxy/resources configuration 16
- 17. The Spring team is doing most of the hard work 17
- 18. Our goal is to support compilation of existing or new Spring Boot applications to native executables. Unchanged. 18
- 19. “We are excited about the great partnership between the Spring and GraalVM engineering teams to support native ahead-of-time compilation for millions of Spring Boot applications. This is a game changer enabling low memory footprint and instant startup for these workloads.” Thomas Wuerthinger, GraalVM founder & project lead 19 Collaboration between Spring and GraalVM teams
- 20. Leverage Spring Boot container image support 2 0 > mvn spring-boot:build-image or > gradle bootBuildImage
- 22. To create lightweight container images 2 2
- 23. Where are we?
- 24. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 24
- 26. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 26
- 28. spring-graalvm-native ● Incubating Spring Boot native application support ○ It includes a plugin for the GraalVM native image builder ● Analyses the Spring Boot application at build time ○ Computes the most optimal native image configuration ○ Challenge is doing that with static analysis ● Also perform some build time transformation for: ○ Optimized footprint ○ Compatibility 28
- 29. We have just released 0.8.0 ● GraalVM 20.2 baseline ● Use Spring Boot 2.4.0 latest milestone ● Significant footprint improvements ● Wider range of supported technology ● New experimental functional mode ● Spring Boot lightweight container integration ○ Maven ○ Gradle 29
- 30. Patch updates until Spring Boot 2.4.0 ● 0.8.1 (September 2020) ○ Upgrade to Spring Boot 2.4.0-M3 ● 0.8.2 (October 2020) ○ Upgrade to Spring Boot 2.4.0-RC1 ● 0.8.3 (November 2020) ○ Upgrade to Spring Boot 2.4.0 ○ GraalVM 20.3 baseline 30
- 31. Starters supported in 0.8.x ● Actuator ● Cache ● Data JPA, MongoDB, R2DBC, Redis ● JDBC ● Logging (Logback) ● Thymeleaf ● Validation ● Web (Spring MVC with Tomcat) ● Webflux (Netty) ● Wavefront ● Spring Cloud Function 31
- 32. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 32
- 33. Comparing Spring Boot 2.3 LoggingSystem ... 33 Map<String, String> systems = new LinkedHashMap<>(); systems.put("ch.qos.logback.core.Appender", "org.springframework.boot.logging.logback.LogbackLoggingSystem"); systems.put("org.apache.logging.log4j.core.impl.Log4jContextFactory", "org.springframework.boot.logging.log4j2.Log4J2LoggingSystem"); systems.put("java.util.logging.LogManager", "org.springframework.boot.logging.java.JavaLoggingSystem"); SYSTEMS = Collections.unmodifiableMap(systems);
- 34. … with Spring Boot 2.4 one 34 ClassLoader classLoader = LoggingSystem.class.getClassLoader(); if (ClassUtils.isPresent("ch.qos.logback.core.Appender", classLoader)) { return LogbackLoggingSystem::new; } if (ClassUtils.isPresent("org.apache.logging.log4j.core.impl.Log4jContextFactory", classLoader)) { return Log4J2LoggingSystem::new; } if (ClassUtils.isPresent("java.util.logging.LogManager", classLoader)) { return JavaLoggingSystem::new; } throw new IllegalStateException("No suitable logging system located");
- 35. New flags available in Spring Framework 5.3 # -3.6M RSS -Dspring.xml.ignore=true # -0.5M RSS -Dspring.spel.ignore=true 35
- 36. A new Tomcat artifact optimized for native apps <!-- -3.5M RSS --> <dependency> <groupId>org.apache.tomcat.experimental</groupId> <artifactId>tomcat-embed-programmatic</artifactId> <version>9.0.38</version> </dependency> 36
- 37. Getting started
- 38. start.spring.io or an existing project 38
- 39. Make sure to use Spring Boot 2.4 latest milestone 39 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.0-M2</version> <relativePath/> <!-- lookup parent from repository --> </parent>
- 40. Update configuration to avoid using proxies 40 @SpringBootApplication(proxyBeanMethods = false) public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }
- 42. Add the spring-graalvm-native dependency 42 <dependency> <groupId>org.springframework.experimental</groupId> <artifactId>spring-graalvm-native</artifactId> <version>0.8.0</version> </dependency>
- 43. Build the native application 43 > mvn spring-boot:build-image Successfully built image 'docker.io/library/demo:0.0.1-SNAPSHOT' Total time: 60 s ● No need for a GraalVM native local install ● Build happens in a container ● And produces a container
- 44. Run the native application 44 > docker run -p 8080:8080 docker.io/library/demo:0.0.1-SNAPSHOT . ____ _ __ _ _ / / ___'_ __ _ _(_)_ __ __ _ ( ( )___ | '_ | '_| | '_ / _` | / ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |___, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: Started application in 0.05 seconds (JVM running for 0.009)
- 45. You can also build a native executable without using containers 45
- 46. Configure Maven plugin in a native profile 46 <plugin> <groupId>org.graalvm.nativeimage</groupId> <artifactId>native-image-maven-plugin</artifactId> <version>20.2.0</version> <configuration> <mainClass>com.example.demo.DemoApplication</mainClass> </configuration> <executions> <execution> <goals> <goal>native-image</goal> </goals> <phase>package</phase> </execution> </executions> </plugin>
- 47. Build the native application 47 > mvn -Pnative clean package Total time: 60 s ● Need for a GraalVM native local install ● Build happens directly on your host (Linux, Mac and Windows are supported) ● Produces a native executable ● No cross compilation
- 48. Run the native application 48 > target/com.example.demo.demoapplication . ____ _ __ _ _ / / ___'_ __ _ _(_)_ __ __ _ ( ( )___ | '_ | '_| | '_ / _` | / ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |___, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: Started application in 0.05 seconds (JVM running for 0.009)
- 50. How fast is your PetClinic? 50 Sample On the JDK native-executable petclinic-jdbc Build: 9s Memory(RSS): 417M Startup time: 2.6s Build: 194s +2050% Memory(RSS): 101M -75% Startup time: 0.158s -94%
- 51. Ongoing work on footprint Key metrics: build time, size of resultant image, and runtime memory footprint 51 Sample SpringOne 2019 SpringOne 2020 commandlinerunner Build: 90s Exec. size: 48M Memory(RSS): 29M Build: 50s -45% Exec. size: 22M -55% Memory(RSS): 24M -17% webflux-netty Build: 193s Exec. size: 81M Memory(RSS): 95M Build: 79s -60% Exec. size: 43M -47% Memory(RSS): 47M -50% webmvc-tomcat Build: 203s Exec size: 105M Memory(RSS): 70M Build: 67s -67% Exec. size: 42M -60% Memory(RSS): 51M -27%
- 52. You can specify additional native configuration 52
- 53. For additional native configuration (eg. resources) ● Create a META-INF/native-image/resource-config.json file ● Wildcard patterns can be used ● Similar config for reflection and proxies ● See GraalVM documentation for more details { "resources": [ { "pattern": "myresource.*" } ], "bundles": [ { "name": "your.pkg.Bundle" } ] } 53
- 54. Tracing agent collected configuration ● An agent can assist in generating these files, available with GraalVM java -Dorg.graalvm.nativeimage.imagecode=agent -agentlib:native-image-agent=config-output-dir=META-INF/native-image Demo ● Agent has improved greatly during 2020, thanks to the GraalVM team ● Run application with agent attached to produce .json files ○ Exercise all code paths (manually or via tests) - producing (merging) many of these collected configurations ● Access filter file supported to avoid including unnecessary infrastructure 5 4
- 55. Our CI checks Java 8/11 x GraalVM 20.2/20.3 55
- 57. Project structure and extensibility ● Core static analysis engine for Spring Applications ○ static: behaviour driven by separate ‘hints’ ○ dynamic: extensible with Spring portfolio project awareness via plugins ● @NativeImageHint ○ Same information as JSON, but more modular, more type safe ○ hints attached to a trigger - an auto configuration active or a classpath presence check ○ application analysis determines if triggers are active => activates those hints 57
- 58. Hint with auto-configuration trigger @NativeImageHint(trigger = R2dbcAutoConfiguration.class, proxyInfos = { @ProxyInfo(types={Serializable.class, InterfaceFoo.class}) }, typeInfos= { @TypeInfo(types = EmbeddedDatabase.class, access = AccessBits.LOAD_AND_CONSTRUCT) } ) public class R2dbcHints implements NativeImageConfiguration { } 58
- 59. Opportunity for the community to contribute 59
- 60. The road ahead
- 61. spring-graalvm-native 0.9.0 (December 2020) ● First release with beta support ○ Spring Boot 2.4.0 and GraalVM 20.3 baseline ○ Subset of starters supported ○ Breaking change will happen (with upgrade paths) ● Wider support ○ Spring Security ○ Spring Batch ● Development-oriented container image 61
- 62. More starters supported in upcoming 0.9.x releases 62
- 63. Hidden gem in Spring Framework since 5.0: functional bean registration 63
- 64. Comparing annotation and functional bean definition @Configuration public class SampleConfiguration { @Bean public Foo foo() { return new Foo(); } @Bean public Bar bar(Foo foo) { return new Bar(foo); } } 64 public class SampleInitializer implements ApplicationContextInitializer<GenericApplicationContext> { @Override public void initialize(GenericApplicationContext ctx) { ctx.registerBean(Foo.class, () -> new Foo()); ctx.registerBean(Bar.class, () -> new Bar(ctx.getBean(Foo.class))); } }
- 65. @Configuration to functional configuration 65 Automated transformation from @Configuration to functional configuration
- 66. 66 spring-init
- 67. Native applications functional configuration 67 Sample webmvc-tomcat webmvc-functional With build time transformation to functional configuration Regular Spring Boot application with Spring MVC, Tomcat and Jackson Build: 67s Exec. size: 42M Memory(RSS): 51M Startup time: 0.06s Build: 60s -10% Exec. size: 37M -12% Memory(RSS): 26M -49% Startup time: 0.02s -66%
- 68. Experimentations on more build time transformations ● @Configuration to functional configuration transformation with spring-init ● Infer proxyBeanMethods = false when possible ● Automatically set optimization flags when relevant 68
- 69. Spring Boot 3, based on Spring Framework 6, is expected to provide first-class support for native application deployment, as well as an optimized footprint on the JVM. 69
- 70. Takeaways ● Spring Boot native applications are great to build lightweight containers ● Try it now with spring-graalvm-native 0.8 ● Contribute support for your favorite starter ● Beta support in December with spring-graalvm-native 0.9 ● Wider support and smaller footprint during 0.9.x releases ● Upcoming first-class native support in Spring Boot 3 / Framework 6 70
- 71. https://github.com/spring-projects-experimental/spring-graalvm-native https://spring.io/blog @sdeleuze on for fresh news #springone@SpringOne Stay Connected.