HOW LAGOM HELPSTO BUILD REAL WORLDMICROSERVICE SYSTEMS

MARKUS EISELE@MYFEAR

M@LIGHTBEND.COMBLOG.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}/") @Produces({"application/xml","application/json"}) 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}/") @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; }}

BUILDING ONE MICROSERVICE IS GENERALLY EASY.

WHAT IS HARD IS BUILDING A SYSTEM OF MICROSERVICES.

COMPLEX DEPLOYMENT

LARGE TEAMS

BREAKING UP MONOLITHS ADDS COMPLEXITY

WHICH TECHNOLOGY TO CHOOSE?

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

Architectureand 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

INTEGRATION WITH LAGOM

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 GitHubLagom Mailinglist

@LagomChat 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/

java/Home.html