Scala Days NYC 2016 presentation

1. ONE MICROSERVICE
IS NO MICROSERVICE
THEY COME IN 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. COMPLEX DEPLOYMENT

7. LARGE TEAMS

8. BREAKING UP MONOLITHS
ADDS COMPLEXITY

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

11. REST - MONOLITH TO MICROSERVICES
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

12. HOW SHOULD WE
BUILD
MICROSERVICE
SYSTEMS?

13. Traditional application
architectures
and platforms are obsolete.
— Gartner

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

15. ARCHITECTURE PRINCIPLES
> Single Responsible Principle
> Service Oriented Architecture
> Encapsulation
> Separation of Concern
> Loose Coupling
> Hexagonal Architecture

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

17. We need to build systems for flexibility and resiliency, not
just efficiency and robustness.

18. > Responsive
> Resilient
> Elastic
> Message driven

19. SCALA, AKKA AND PLAY ARE GREAT FITS HERE
Have a steep learning curve
Still a lot to build out yourself
Not explicitly build for microservices

20. BUT LAGOM IS HERE TO HELP
> Developer experience first!
> No ad-hoc scripts to run your
services
> Takes you through to production
deployment

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

22. HIGHLY OPPINIONATED
> Service API
> Persistence API
> Development environment
> Production environment

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

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

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

27. CONTRIBUTE TO LAGOM
Lagom on GitHub
Lagom Mailinglist
@Lagom
Chat Room

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

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

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

31. ❕ ❓