One Microservice Is No Microservice: They Come in Systems [CON6471]

My JavaOne 2016 presentation:

"Building a complete system out of individual microservices is hard. Microservices-based architecture is gaining attention, but there are trade-offs and drawbacks. Individual microservices are fairly easy to understand and implement, but they make sense only as systems; it’s between services that the most-challenging problems arise—in distributed systems. Slicing a system into REST services and wiring them back together with synchronous protocols and traditional enterprise tools means failure. This session distills the essence of microservices-based systems and covers a new development approach to microservices that gets you started quickly with a guided, minimalistic approach on your machine and takes you to a productive scaled-out microservices-based on the Oracle Cloud system with hundreds of services."

Transcript

1. One Microservice Is No Microservice: They Come in Systems [CON6471] Markus Eisele (@myfear, blog.eisele.net)
3. @Path("/orders/") @Interceptors(CallAudit.class) @Stateless public class OrderService { @EJB BillingService billing; @EJB DeliveryService delivery; @EJB Warehouse warehouse; @PUT @Produces({"application/xml", "application/json"}) @Consumes({"application/xml", "application/json"}) public Order order(Order newOrder) { Order order = warehouse.checkout(newOrder); billing.payForOrder(order); delivery.deliver(order); return order; } @GET @Path("{orderid}/") @Produces({"application/xml", "application/json"}) public Order status(@PathParam("orderid") long orderId) { return delivery.status(orderId); } }
5. @Path("/orders/") @Interceptors(CallAudit.class) @Stateless public class OrderService { private Client client; private WebTarget tut; // ... @GET @Path("{orderid}/") @Produces({"application/xml","application/json"}) public Order status(@PathParam("orderid") long orderId){ // return delivery.status(orderId); this.client = ClientBuilder.newClient(); this.tut = this.client.target("http://..."); Order order = this.client.target(location).request(MediaType.APPLICATION_XML) .get(Order.class); return order; } }
6. Building one microservice is generally easy. What is hard is building a *system* of microservices.
10. Which technology to choose http://www.internetlivestats.com/internet-users/ J2EE Spring RoR Akka Reactive Manifesto Microservices
11. Data in Motion • Rather than acting on data at rest, modern software increasingly operates on data in near real-time. • Shortened time-frames for putting changes into production • New business models evolve from existing ones • New questions need to be answered by existing applications • Datacenter costs need to go down constantly
12. > Traditional application architectures and platforms are obsolete. -- Gartner
13. We used the _right_ tools to build the _wrong_ things.
14. And we still are missing tools and specifications. • Service Discovery • Service Lookup • API Management • Security • Protocols and Interfaces • Data Access • Developer Experience
15. > Architecture and software design principles matter even more today. -- Eisele
16. Software Design Architecture Principles • Single Responsible Principle • Service Oriented Architecture – Encapsulation – Separation of Concern – Loose Coupling • Hexagonal Architecture Design Patterns • Domain-driven Design • Bounded Contexts • Event Sourcing • CQRS • Eventual Consistency • Context Maps
17. Design Best Practices • Design for Automation • Designed for failure • Service load balancing and automatic scaling • Design for Data Separation • Design for Integrity • Design for Performance
18. We need to build systems for flexibility and resiliency, not just efficiency and robustness.
20. • Reactive Microservices Framework for the JVM • Focused on right sized services • Asynchronous I/O and communication as first class priorities • Highly productive development environment • Takes you all the way to production What is Lagom?
21. • Service API • Persistence API • Development environment • Production environment Highly opinionated
22. • Event sourced (deltas) with Cassandra backend by default • No object/relational impedance mismatch • Can always replay to determine current state • Allows you to learn more from your data later • Persistent entity is an Aggregate Root in DDD • Can be overridden for CRUD if you want Lagom Persistence API
25. Getting started.
26. mvn archetype:generate -DarchetypeGroupId=com.lightbend.lagom \ -DarchetypeArtifactId=maven-archetype-lagom-java \ -DarchetypeVersion=1.1.0 Creating a new Lagom project
27. $ cd my-first-system $ mvn lagom:runAll ... [info] Starting embedded Cassandra server .......... [info] Cassandra server running at 127.0.0.1:4000 [info] Service locator is running at http://localhost:8000 [info] Service gateway is running at http://localhost:9000 .......... [info] Service helloworld-impl listening for HTTP on 0:0:0:0:0:0:0:0:24266 [info] Service hellostream-impl listening for HTTP on 0:0:0:0:0:0:0:0:26230 (Services started, press enter to stop and go back to the console...)
28. http://localhost:9000/api/hello/World
30. The somewhat bigger example!
31. Cargo Tracker https://github.com/lagom/activator-lagom-cargotracker
32. Registration Shipping Frontend Cassandra
34. Now that we have our bundles, how do we get into production?
35. • Lagom doesn’t prescribe any particular production environment, however out of the box support is provided for Lightbend ConductR. • Zookeper based version: https://github.com/jboner/lagom-service-locator- zookeeper • Consul based version: https://github.com/jboner/lagom-service-locator-consul Out of the box support for ConductR but..
36. >sbt bundle:dist ... [info] Your package is ready in /Users/myfear/lagom-cargotracker/front- end/target/universal/front-end-1.0- SNAPSHOT.zip Create Service bundles via sbt
37. • Creating a bundle configuration file, bundle.conf • Creating a start script • Creating a Maven assembly plugin descriptor to create the bundle zip • Binding the Maven assembly plugin and Lagom renameConductRBundle goals to your projects lifecycle Create Service Bundles with Maven http://www.lagomframework.com/documentation/1.1.x/java/ConductRMaven.html
39. Next Steps! Download and try Lagom! Project Site: http://www.lightbend.com/lagom GitHub Repo: https://github.com/lagom Documentation: http://www.lagomframework.com/documentation/1.1.x/Home.html Example: https://github.com/typesafehub/activator-lagom-java
40. Written for architects and developers that must quickly gain a fundamental understanding of microservice-based architectures, this free O’Reilly report explores the journey from SOA to microservices, discusses approaches to dismantling your monolith, and reviews the key tenets of a Reactive microservice: • Isolate all the Things • Act Autonomously • Do One Thing, and Do It Well • Own Your State, Exclusively • Embrace Asynchronous Message-Passing • Stay Mobile, but Addressable • Collaborate as Systems to Solve Problems http://bit.ly/ReactiveMicroservice
41. The detailed example in this report is based on Lagom, a new framework that helps you follow the requirements for building distributed, reactive systems. • Get an overview of the Reactive Programming model and basic requirements for developing reactive microservices • Learn how to create base services, expose endpoints, and then connect them with a simple, web-based user interface • Understand how to deal with persistence, state, and clients • Use integration technologies to start a successful migration away from legacy systems http://bit.ly/DevelopReactiveMicroservice
42. https://www.reactivesummit.org/