High Performance Microservices with Ratpack and Spring Boot
8 likes2,431 views
This document provides an overview of using Ratpack and Spring Boot to build high performance microservices. It discusses Ratpack's asynchronous and non-blocking execution model which uses promises to deterministically process asynchronous calls. It describes how Ratpack uses registries for dependency injection which can integrate with Spring Boot. It presents an example microservice application and includes performance numbers from testing on cloud infrastructure showing how much burst traffic can be sustained.
![package app;
import ratpack.server.RatpackServer
public class Main {
public static void main(String args[]) throws Exception {
RatpackServer.start(spec -> spec
.handlers(chain -> chain
.get(ctx -> ctx.render("Hello World!"))
)
);
}
}](https://image.slidesharecdn.com/ratpack-spring-microservices-160803232107/85/High-Performance-Microservices-with-Ratpack-and-Spring-Boot-11-320.jpg)
![Can quickly prototype without any DI system
public static void main(String[] args) throws Exception {
RatpackServer.start(spec -> spec
.registryOf(r -> r.add(new MyAsyncDbService())) // bind my service in the registry
.handlers(chain -> chain
.get(ctx -> {
MyAsyncDbService db = ctx.get(MyAsyncDbService.class); // retrieve it later
// ...
})
)
);
}](https://image.slidesharecdn.com/ratpack-spring-microservices-160803232107/85/High-Performance-Microservices-with-Ratpack-and-Spring-Boot-37-320.jpg)
![Integrate with Spring Boot when you're ready!
@SpringBootApplication // Spring Boot!!
public class Main {
@Bean
public MyAsyncDbService myAsyncDbService() { // bind it as a bean!
return new MyAsyncDbService();
}
public static void main(String[] args) {
// turn Spring Boot into a Ratpack registry!
Registry registry = ratpack.spring.Spring.spring(Main.class);
RatpackServer.start(spec -> spec
.registry(registry)
.handlers(chain -> chain
.get(ctx -> {
MyAsyncDbService db = ctx.get(MyAsyncDbService.class); // retrieve your service!
// ...
})
)
)
}
}](https://image.slidesharecdn.com/ratpack-spring-microservices-160803232107/85/High-Performance-Microservices-with-Ratpack-and-Spring-Boot-38-320.jpg)
High Performance Microservices with Ratpack and Spring Boot
- 1. HIGH PERFORMANCE MICROSERVICES WITH RATPACK AND SPRING BOOT DAN WOODS @DANVELOPER
- 2. SENIOR SOFTWARE ENGINEER WORKING ON CLOUD & DEVOPS TOOLING
- 4. SUPPORT YOUR COMMUNITY.ALL ROYALTIES FOR LEARNING RATPACK GO DIRECTLY TO GR8LADIES HTTP://GR8LADIES.ORG
- 5. ROUGH AGENDA > Brief overview > Execution model > Registries > Registries + Spring > Microservice example > Performance numbers
- 6. OVERVIEW
- 7. Ratpack is a high throughput, non-blocking, asynchronous, reactive web framework for the JVM
- 8. Built on Java 8, has first class support Groovy
- 9. Realistically, works great with every JVM language
- 10. @Grab('io.ratpack:ratpack-groovy:1.4.0-rc-2') import static ratpack.groovy.Groovy.ratpack ratpack { handlers { get { render "Hello World!" } } }
- 11. package app; import ratpack.server.RatpackServer public class Main { public static void main(String args[]) throws Exception { RatpackServer.start(spec -> spec .handlers(chain -> chain .get(ctx -> ctx.render("Hello World!")) ) ); } }
- 12. No opinions about how you build your application
- 13. Make common things as easy as possible
- 15. First class concerns: performance, developer experience, packaging
- 16. EXECUTION MODEL
- 17. Asynchronous programming is hard!
- 18. Traditionally there is a temporal disconnect between calling an async function and getting its response. public void asyncDbCall(Long productId, Consumer callback) { Product product = ... async db call + future + wait for future callback.apply(product); }
- 19. Bad things happen! final List products = new ArrayList(); Long productId = request.pathTokens.productId; db.asyncDbCall(productId, product -> products.add(product)); Long nextProductId = productId+1; db.asyncDbCall(nextProductId, product -> products.add(product)); response.send(products);
- 20. There is no guarantee as to what order async calls will be executed! final List products = new ArrayList(); String productId = request.pathTokens.productId; db.asyncDbCall(productId, product -> products.add(product)); // call may return first, maybe not! String nextProductId = productId+1; db.asyncDbCall(nextProductId, product -> products.add(product)); // call may return second, may not! response.send(products); // what even is the value of `products` here!
- 21. Luckily, Ratpack's execution model provides deterministic processing of asynchronous calls
- 22. An Execution in Ratpack is the equivalent construct to a continuation
- 23. Ratpack Promise type denotes a frame in the continuation (a.k.a "execution segments")
- 26. Execution segments are guaranteed to execute in their given order.
- 27. RATPACK MAINTAINS A SMALL THREAD POOL FOR ALL ITS PROCESSING (TYPICALLY 2 * NUM CPU CORES)
- 28. While an execution segment is processing, its thread is able to handle other processing and requests
- 29. Ratpack ensures the resources given to your application are being efficiently utilized
- 30. Ratpack's RxJava integration provides a scheduler that fits Observable into the execution model
- 31. Provides an implementation of Reactive Streams, which also fits into the execution model
- 32. REGISTRIES
- 33. Abstraction over dependency injection
- 34. Provides a basic component binding infrastructure
- 36. CAN BE BACKED BY ANY COMPONENT- PROVIDING SYSTEM SPRING BOOT AND GUICE NATIVELY SUPPORTED
- 37. Can quickly prototype without any DI system public static void main(String[] args) throws Exception { RatpackServer.start(spec -> spec .registryOf(r -> r.add(new MyAsyncDbService())) // bind my service in the registry .handlers(chain -> chain .get(ctx -> { MyAsyncDbService db = ctx.get(MyAsyncDbService.class); // retrieve it later // ... }) ) ); }
- 38. Integrate with Spring Boot when you're ready! @SpringBootApplication // Spring Boot!! public class Main { @Bean public MyAsyncDbService myAsyncDbService() { // bind it as a bean! return new MyAsyncDbService(); } public static void main(String[] args) { // turn Spring Boot into a Ratpack registry! Registry registry = ratpack.spring.Spring.spring(Main.class); RatpackServer.start(spec -> spec .registry(registry) .handlers(chain -> chain .get(ctx -> { MyAsyncDbService db = ctx.get(MyAsyncDbService.class); // retrieve your service! // ... }) ) ) } }
- 39. Architect your application using all the helpful aspects of Spring Boot, while using Ratpack under the hood for high throughput, reactive, async, non-blocking processing
- 42. A quick tirade about performance testing...
- 43. Generalizing performance numbers for all use cases is impossible
- 44. The numbers provided should be used as a guide, not the word of law
- 45. "YOU SHOULDN'T TEST ON THE CLOUD!!"
- 46. Unrealistic. Modern performance testing needs to be about how much burst traffic can be sustained, without your service falling over, before you can horizontally scale it.
- 47. PERFORMANCE NUMBERS HTTPS://GITHUB.COM/DANVELOPER/S1P-HIGH-PERF-MICROSERVICES/BLOB/MASTER/README.MD
- 49. Spring 5 will be all reactive; will be possible to integrate Spring controllers into Ratpack
- 50. Provide a scheduler to Project Reactor so that Flex and Mono types can utilize the execution model
- 51. Questions?