SpringOne 2020 The Path Towards Spring Boot Native Applications Sébastien Deleuze, Spring Framework Committer at VMware Andy Clement, Director at VMware

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

4. Native applications

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

21. Using Paketo Buildpacks
21
https://paketo.io/

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

25. https://github.com/oracle/graal/labels/spring
25

26. Timeline
GraalVM fixes
and improvements
Incubating support in
spring-graalvm-native
Spring Boot support
We are here
26

27. https://github.com/spring-projects-experimental/spring-graalvm-native
27

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);
}
}

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. 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)

49. Petclinic Demo
49

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

56. spring-graalvm-native

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.