How lagom helps to build real world microservice systems

HOW LAGOM HELPS
TO BUILD REAL WORLD
MICROSERVICE SYSTEMS

MARKUS EISELE
@MYFEAR
M@LIGHTBEND.COM
BLOG.EISELE.NET
! "

@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}/")
public Order status(@PathParam("orderid") long orderId){
return delivery.status(orderId);
}
}

@Path("/orders/")
@Interceptors(CallAudit.class)
@Stateless public class OrderService {
private Client client;
private WebTarget tut;
// ...
@GET
@Path("{orderid}/")
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;
}
}

BUILDING ONE MICROSERVICE IS
GENERALLY EASY.
WHAT IS HARD IS BUILDING A SYSTEM OF
MICROSERVICES.

BREAKING UP MONOLITHS
ADDS COMPLEXITY

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

Traditional application
architectures
and platforms are obsolete.
— Gartner

WE USED THE RIGHT TOOLS
TO BUILD THE WRONG
THINGS.

AND WE STILL ARE MISSING TOOLS.
> Service Discovery
> Service Lookup
> API Management
> Security
> Protocols and Interfaces
> Data Access
> Developer Experience

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

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

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

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

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

CORE TENANTS
> Responsive
> Resilient
> Elastic
> Message driven

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

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!

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

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

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

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

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

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

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

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

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

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

How lagom helps to build real world microservice systems

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to How lagom helps to build real world microservice systems (20)

More from Markus Eisele (19)

Recently uploaded (20)

How lagom helps to build real world microservice systems