This document discusses how the Lagom framework can help build microservice systems. It provides an overview of challenges in building microservice systems, such as complex deployment, large teams, and breaking up monoliths. It then discusses how Lagom addresses these challenges through its developer experience, architecture principles like domain-driven design, and tools for persistence, communication, and deployment. The document also provides examples of how to use Lagom and recommends resources for learning more.

1. HOW LAGOM HELPS
TO BUILD REAL WORLD
MICROSERVICE SYSTEMS

2. MARKUS EISELE
@MYFEAR
M@LIGHTBEND.COM
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.

7. COMPLEX DEPLOYMENT

8. LARGE TEAMS

9. BREAKING UP MONOLITHS
ADDS COMPLEXITY

10. WHICH TECHNOLOGY TO CHOOSE?

11. DATA IN MOTION
Rather than acting on data at rest, modern software
increasingly operates on data in near real-time.

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.
> Service Discovery
> Service Lookup
> API Management
> Security
> Protocols and Interfaces
> Data Access
> Developer Experience

15. PROTOCOLS AND INTERFACES
REST tends to be our go-to but…
> Don’t just do a 1:1 service/interface replacement
> Instead… Design for an asynchronous architecture
Pro-tip: Watch Ben Christensen’s “Don’t build a distributed
Monolith” talk from Microservices Practitioner Summit
2016

16. Architecture
and software design principles
matter even more today.
— Eisele

17. HOW TO DESIGN MICROSERVICES SYSTEMS
> Single Responsible Principle
> Service Oriented Architecture
> Encapsulation
> Separation of Concern
> Loose Coupling
> Hexagonal Architecture

18. SOFTWARE DESIGN PATTERNS
> Domain-driven Design
> Bounded Contexts
> Event Sourcing
> CQRS
> Eventual Consistency
> Context Maps

19. WE NEED TO BUILD
SYSTEMS FOR FLEXIBILITY
AND RESILIENCY, NOT
JUST EFFICIENCY AND
ROBUSTNESS.

20. CORE TENANTS
> Responsive
> Resilient
> Elastic
> Message driven

21. HOW LAGOM CAN HELP
> Developer experience first!
> No ad-hoc scripts to run your
services
> Takes you through to production
deployment

22. HIGHLY OPINIONATED
> Use context bounds as boundaries for services!
(Domain Driven Design)
> The event log is the book of record!
(Event Sourcing)
> Separate the read and write sides!
(CQRS)
> Microservices, too, need to be elastic and resilient!

23. LAGOM SERVICE API
> IO and communication
> Streaming between services as a first-class concept
> Higher level of resilience and scalability with no
blocking
> Service is a Bounded Context in DDD
> Service Clients & Endpoints

24. LAGOM PERSISTENCE API
> 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

27. DEVELOPMENT ENVIRONMENT
$ cd my-first-system
$ activator
... (booting up)
> 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, use Ctrl+D to stop and go back to the console...)

28. WHAT IS TECHNICALLY IN LAGOM?
> sbt build tool
> Scala 2.11 and JDK8
> Play 2.5
> Akka 2.4
> Cassandra
> Jackson
> Google Guice

29. INTEGRATION WITH LAGOM

30. NEXT STEPS FOR LAGOM
> Scala API
> Swagger integration
> Maven support
> Support for more DBs
> Integration with other cluster orchestration tools
> … What is missing?

31. CARGO TRACKER EXAMPLE
https://github.com/lagom/activator-lagom-cargotracker

33. LEARN ABOUT LAGOM
Lagom on GitHub
Lagom Mailinglist
@Lagom
Chat Room

34. REACTIVE MICROSERVICES ARCHITECTURE
BIT.LY/REACTIVEMICROSERVICE
> explore a microservice architecture
> based on Reactive principles
> for building an isolated service
that’s
> scalable, resilient to failure,
> and combines with other services
> to form a cohesive whole

35. DEVELOPING REACTIVE MICROSERVICES
HTTP://BIT.LY/DEVELOPREACTIVEMICROSERVICE
> create base services, expose
endpoints, and then connect them
with a simple, web-based user
interface
> deal with persistence, state, and
clients
> Use integration technologies to
start a successful migration away
from legacy systems

36. NEXT STEPS
Project Site:
http://www.lightbend.com/lagom
GitHub Repo:
https://github.com/lagom
Documentation:
http://www.lagomframework.com/documentation/1.0.x/
Home.html