Microservices with Micronaut
1 like906 views
The document discusses the advantages of using Micronaut over Spring Boot for microservices, highlighting improvements in startup time and memory usage by utilizing compile-time processing instead of runtime reflection. It outlines Micronaut's features, including dependency injection, AOP, and reactive programming, and provides benchmarks demonstrating its efficiency compared to Spring. The conclusion recommends Micronaut for small services, noting good documentation and active development, while also mentioning the potential limitations of GraalVM.
![Why does it take so long?
● Start time of Spring (Boot)
○ Depends on the number of beans in the context
○ Reading of bytecode [3]
○ Creating proxies at runtime
○ Runtime AOP
○ Reflection
○ Annotation Synthesizing [1] [2]
● Memory usage
○ Reflective Metadata Cache
● Debugging
○ Very very long stacktraces
○ … with code in dynamically generated proxy classes
[1] https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/AnnotationUtils.html
[2] https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/AliasFor.html
[3] https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/core/type/classreading/AbstractRecursiveAnnotationVisitor.java](https://image.slidesharecdn.com/cloudnativenight-moritz-kammerer-2019-06-13-microservices-with-micronaut-190614073110/85/Microservices-with-Micronaut-3-320.jpg)
![The price you pay: Compile time (16k Beans)
Spring:
[INFO] Total time: 7.958 s
Micronaut:
BUILD SUCCESSFUL in 5m 3s](https://image.slidesharecdn.com/cloudnativenight-moritz-kammerer-2019-06-13-microservices-with-micronaut-190614073110/85/Microservices-with-Micronaut-11-320.jpg)
Microservices with Micronaut
- 1. Microservices with Micronaut 2019-06-13 - Moritz Kammerer
- 3. Why does it take so long? ● Start time of Spring (Boot) ○ Depends on the number of beans in the context ○ Reading of bytecode [3] ○ Creating proxies at runtime ○ Runtime AOP ○ Reflection ○ Annotation Synthesizing [1] [2] ● Memory usage ○ Reflective Metadata Cache ● Debugging ○ Very very long stacktraces ○ … with code in dynamically generated proxy classes [1] https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/AnnotationUtils.html [2] https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/annotation/AliasFor.html [3] https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/core/type/classreading/AbstractRecursiveAnnotationVisitor.java
- 4. What’s the (promised) solution? ● Create stuff at compile time ○ Proxies ○ Dependency Injection ○ AOP ● Why? ○ Compiled once, run often ○ Tradeoff: Compile time vs. Runtime ● Goal: ○ No reflection - or as little as possible ○ No proxies ○ Minimize startup time ○ Minimize memory usage ○ Readable stacktraces
- 5. And how does that work? ● Annotation Processor ○ Reads bytecode & annotations of the classes ○ Creates new classes ○ Doesn’t touch your code, just extends it ● Gradle ○ annotationProcessor "io.micronaut:micronaut-inject-java" ○ annotationProcessor "io.micronaut:micronaut-validation" ● Also runs with Maven ○ < Insert 500 KB of XML here >
- 7. And this is really working? ● Spring Boot 2.1.2 (starter-web), Java 11, @Component on empty class ○ 0 Beans: 1.236 seconds ○ 1000 Beans: 1.808 seconds ○ 2000 Beans: 2.356 seconds ○ 4000 Beans: 3.259 seconds ○ 8000 Beans: 6.498 seconds ○ 16000 Beans: 9.231 seconds ● Micronaut 1.0.4, Java 11, @Singleton on empty class ○ 0 Beans: 1085ms ○ 1000 Beans: 1870ms ○ 2000 Beans: 2757ms ○ 4000 Beans: 4529ms ○ 8000 Beans: 8038ms ○ 16000 Beans: 15861ms
- 8. Hmmmm...
- 9. Debunked: It’s not the classpath scanning ● Not so expensive: ○ Classpath scanning (Spring) ○ Injection with reflection (Spring) ● Expensive ○ Load classes (Micronaut + Spring) ○ Runtime AOP Proxies (Spring) ○ Annotation Synthesizing (Spring) ○ Read bytecode on big classes (Spring) ○ Auto-Configuration Magic (Spring)
- 10. Looks great, so not disadvantages?
- 11. The price you pay: Compile time (16k Beans) Spring: [INFO] Total time: 7.958 s Micronaut: BUILD SUCCESSFUL in 5m 3s
- 12. Benchmarking is hard! ● This was NOT a real benchmark ● Most time spent in the applications shown on the first slides: Spring autoconfiguration magic ● It really depends on the needed feature of your application ○ Actuator ○ JPA / Hibernate ○ Tracing ○ Metriken ○ @FeignClient ○ @Transactional ○ @Cacheable ○ … ● More in the live demo!
- 13. Okay... what else brings Micronaut to the table? ● Dependency Injection ○ @Inject, @Named, @Singleton, @Prototype, ... ● REST Controller ○ @Controller, @GET, @POST, … ● Events ○ @PostConstruct ○ @EventListener ● AOP ○ Around Advice, Introduction Advice, … ● Validation ○ @Validated, @NotNull, ...
- 14. ... ● Caching ○ @Cachable, @CacheInvalidate, … ● Retry ○ @Retryable ● Circuit Breaking ○ @CircuitBreaker ● Fallback / Recovery ○ @Recoverable / @Fallback ● Scheduling ○ @Scheduled
- 15. ... ● Reactive & Blocking HTTP with Netty ○ Compile Time Route Validation ○ @Error Exception Handling ala Spring ● Websocket Server & Clients ● Server side views ○ Thymeleaf, Handlebars, Velocity ● OpenAPI / Swagger (experimental) ○ Is created on compile time! ● HTTP Clients ○ @Client ○ Client-side load balancing ○ Service discovery (Consul, Eureka, K8S, Route 53, DNS based) ○ OpenTracing (Zipkin, Jaeger)
- 16. ... ● Application Configuration ○ application.yml / .json / .groovy ○ Different Environments ○ Property Sources (ENV, System Properties, …) ○ @ConfigurationProperties, @Value ○ Distributed config with Consul, AWS Parameter Store ● Database support ○ JPA, Mongo, Neo4J, Postgres-Reactive, Redis, Cassandra ● Monitoring ○ @Endpoint (/beans, /info, /health, …) ○ Metriken with Micrometer ○ Change log level at runtime
- 17. ... ● Security ○ Like Spring Security with users and roles (RBAC) ○ Basic Auth / Session based ○ JWT (JWS and JWE) incl. automatic token propagation ○ Auth with LDAP ● Function-as-a-Service (AWS Lambda, OpenFaaS) ● Message driven services (RabbitMQ / Kafka) ● CLI Applikationen ● Good documentation! ○ e.g. with tutorials for Let’s Encrypt, starting Consul, etc.
- 18. Enough bla bla, show code!
- 19. Spring vs. Micronaut - GitHub Scraper Micronaut BUILD SUCCESSFUL in 9s Startup completed in 1168ms Spring BUILD SUCCESSFUL in 5s Started DemoApplication in 3.066 seconds (JVM running for 3.505)
- 20. Micronaut (JAR: 12 MB) java -Xms16M -Xmx512M -jar github-scraper-0.1-all.jar / openjdk version "1.8.0_201"
- 21. Micronaut wrk -t 8 -c 80 -d 30s --latency http://localhost:8080/github/stars Running 30s test @ http://localhost:8080/github/stars 8 threads and 80 connections Thread Stats Avg Stdev Max +/- Stdev Latency 12.75ms 74.53ms 1.50s 97.96% Req/Sec 6.24k 2.70k 15.36k 69.12% Latency Distribution 50% 1.28ms 75% 4.19ms 90% 11.87ms 99% 411.86ms 1460134 requests in 30.03s, 714.10MB read Requests/sec: 48618.64 Transfer/sec: 23.78MB
- 22. Spring Boot (JAR: 33 MB) java -Xms16M -Xmx512M -jar github-scraper-spring-0.0.1-SNAPSHOT.jar / openjdk version "1.8.0_201"
- 23. Spring Boot wrk -t 8 -c 80 -d 30s --latency http://localhost:8080/github/stars Running 30s test @ http://localhost:8080/github/stars 8 threads and 80 connections Thread Stats Avg Stdev Max +/- Stdev Latency 19.98ms 62.12ms 1.26s 94.35% Req/Sec 3.72k 1.93k 8.64k 58.43% Latency Distribution 50% 1.99ms 75% 11.54ms 90% 50.91ms 99% 329.01ms 865022 requests in 30.06s, 425.81MB read Non-2xx or 3xx responses: 164 Requests/sec: 28779.20 Transfer/sec: 14.17MB
- 24. Graal VM “High-performance polyglot VM” (and AOT compiler)
- 25. Graal KB
- 26. Graal Running 30s test @ http://localhost:8080/test 8 threads and 80 connections Thread Stats Avg Stdev Max +/- Stdev Latency 9.12ms 10.93ms 149.69ms 86.75% Req/Sec 1.66k 301.15 2.80k 68.92% Latency Distribution 50% 4.28ms 75% 11.83ms 90% 23.74ms 99% 50.63ms 396402 requests in 30.02s, 51.79MB read Requests/sec: 13204.09 Transfer/sec: 1.73MB
- 27. Experience from the trenches: TASTE-OS Pro: ● Services start faster than Spring Boot ● Smaller JARs ● Tests are faster, as the embedded server starts fast Contra: ● No separation of management and API port ● MDC / ThreadLocal in reactive applications (not Micronaut specific)
- 28. Conclusion ● Good documentation ● Recommendation for writing small services ○ I have no experience with bigger services in Micronaut. If you have, please contact me :) ● Development is fun ● If the features are sufficient: Try it! ● GraalVM is incomplete / buggy / not ready for prime-time
- 29. Literature ● GitLab Repo: https://github.com/qaware/microservices-with-micronaut ● Micronaut documentation: https://docs.micronaut.io/latest/guide/index.html ● GraalVM: https://www.graalvm.org/
- 31. We are hiring. In Munich. And in Mainz. https://www.qaware.de/karriere/#jobs