Successfully reported this slideshow.
Your SlideShare is downloading. ×

The Path Towards Spring Boot Native Applications

Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Upcoming SlideShare
Not Just Initializing
Not Just Initializing
Loading in …3
×

Check these out next

1 of 71 Ad

The Path Towards Spring Boot Native Applications

Download to read offline

SpringOne 2020
The Path Towards Spring Boot Native Applications

Sébastien Deleuze, Spring Framework Committer at VMware
Andy Clement, Director at VMware

SpringOne 2020
The Path Towards Spring Boot Native Applications

Sébastien Deleuze, Spring Framework Committer at VMware
Andy Clement, Director at VMware

Advertisement
Advertisement

More Related Content

Slideshows for you (20)

Similar to The Path Towards Spring Boot Native Applications (20)

Advertisement

More from VMware Tanzu (20)

Recently uploaded (20)

Advertisement

The Path Towards Spring Boot Native Applications

  1. 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. 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. 3. Agenda ● Native applications ● Spring Boot native applications ● Where are we? ● Getting started ● Demo ● spring-graalvm-native ● The road ahead 3
  4. 4. Native applications
  5. 5. 5 Native ahead-of-time compilation Java or Kotlin application GraalVM native compiler Native executable Lightweight container image EXE0110 5
  6. 6. Two main benefits 6 Instant startup Reduced memory consumption
  7. 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. 8. JVM and native executables trade-offs 8
  9. 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. 10. GraalVM native is a source of inspiration for the JVM ecosystem 10
  11. 11. An upcoming Java platform standard with Project Leyden 11
  12. 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. 13. Still in “early adopter” mode (supported with breaking changes) but matures quickly 13
  14. 14. Spring Boot native applications
  15. 15. Good fit with Spring Boot stand-alone deployment model 15
  16. 16. Compiling your application to a native executable requires reflection/proxy/resources configuration 16
  17. 17. The Spring team is doing most of the hard work 17
  18. 18. Our goal is to support compilation of existing or new Spring Boot applications to native executables. Unchanged. 18
  19. 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. 20. Leverage Spring Boot container image support 2 0 > mvn spring-boot:build-image or > gradle bootBuildImage
  21. 21. Using Paketo Buildpacks 21 https://paketo.io/
  22. 22. To create lightweight container images 2 2
  23. 23. Where are we?
  24. 24. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 24
  25. 25. https://github.com/oracle/graal/labels/spring 25
  26. 26. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 26
  27. 27. https://github.com/spring-projects-experimental/spring-graalvm-native 27
  28. 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. 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. 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. 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. 32. Timeline GraalVM fixes and improvements Incubating support in spring-graalvm-native Spring Boot support We are here 32
  33. 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. 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. 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. 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. 37. Getting started
  38. 38. start.spring.io or an existing project 38
  39. 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. 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); } }
  41. 41. Configure Maven plugin 41 <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <image> <env> <BP_BOOT_NATIVE_IMAGE>true</BP_BOOT_NATIVE_IMAGE> </env> </image> </configuration> </plugin>
  42. 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. 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. 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. 45. You can also build a native executable without using containers 45
  46. 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. 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. 48. Run the native application 48 > target/com.example.demo.demoapplication . ____ _ __ _ _ / / ___'_ __ _ _(_)_ __ __ _ ( ( )___ | '_ | '_| | '_ / _` | / ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |___, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: Started application in 0.05 seconds (JVM running for 0.009)
  49. 49. Petclinic Demo 49
  50. 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. 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. 52. You can specify additional native configuration 52
  53. 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. 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. 55. Our CI checks Java 8/11 x GraalVM 20.2/20.3 55
  56. 56. spring-graalvm-native
  57. 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. 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. 59. Opportunity for the community to contribute 59
  60. 60. The road ahead
  61. 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. 62. More starters supported in upcoming 0.9.x releases 62
  63. 63. Hidden gem in Spring Framework since 5.0: functional bean registration 63
  64. 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. 65. @Configuration to functional configuration 65 Automated transformation from @Configuration to functional configuration
  66. 66. 66 spring-init
  67. 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. 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. 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. 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. 71. https://github.com/spring-projects-experimental/spring-graalvm-native https://spring.io/blog @sdeleuze on for fresh news #springone@SpringOne Stay Connected.

×