Events-First Microservices with Lagom - DDDeXchange

Digital transformations are the new hype. By switching to a more IT-oriented organization, businesses hope to achieve a new level of flexibility to answer better to the fast changing demands of customers. Companies often start their new customer-driven strategy with a big-bang agile transformation in the hope of a quicker time-to-market. But can companies have a significant improvement from this transformation with their (still) rigid software architectures?

Domain Driven Design and Microservices are ways of designing systems in which Conway's law can be used to a business' advantage. With the goal of instant improvement of the business and its flexibility, a big-bang strategy for an (agile) architectural transformation isn't a good fit.

Kenny and Gideon will share with you a strategy for the disentanglement of monoliths during a hands-on session; using event-first DDD they'll start modelling a business and will use Lagom to incrementally transform the senders and receivers of those events. Not only does this technology and strategy ensure a less-entangled system which will improve the autonomy of software development teams. The level of disentanglement also ensures that old and new technology can co-exist with ease during the migration and full life-cycle of your architecture.

Transcript

1. Events-First Microservices With Lagom Gideon de Kok @gideondk Kenny Baas @kenny_baas
2. 2 IT’S YOUR BUSINESS. WE ACCELERATE IT. XEBIA GROUP CONSISTS OF SEVEN SPECIALIZED, INTERLINKED COMPANIES WITH OFFICES IN AMSTERDAM AND HILVERSUM (NETHERLANDS), PARIS, DELHI, BANGALORE AND BOSTON, WE EMPLOY OVER 700 PEOPLE WORLDWIDE
3. Microservices
5. ShipOrder Order Shipping REST
6. ShipOrder Order Shipping REST
7. “Any organization that designs a system will produce a design whose structure is a copy of the organization's communication structure.”
 
 — Melvin Conway, 1967
9. ShipOrder Order Shipping
11. Fucking Microservices
13. We’re often forcing our current problem into microservices instead of complimenting it
15. Boundaries aren’t only about form, they’re also about communication patterns and language
17. Structure-First Domain-Driven Design
18. Structure weights you down. Something that has been visualised is hard to be unvisualised.
19. Design is not just what it looks like and feels like. Design is how it works.
20. It is not the things that matter (in early stages of design). It is the things that happen — Russ Miles
21. “Event”
 1. A thing that happens or takes place, especially one of importance.
22. Events-First Domain-Driven Design™,
25. "Software development is a learning process; working code is a side effect." — Alberto Brandolini
33. Order Created
34. Order Confirmed Order Created Order Paid Order Shipped Order Delivered Order Picked
35. Order Shipping Order Confirmed Order Created Order Paid Order Shipped Order Delivered Order Picked
36. package com.xebia.webshop.order.api sealed trait OrderEvent object OrderEvent { case class OrderCreated(orderId: String, orderLines: Seq[OrderLine], shippingInfo: ShippingInfo) extends OrderEvent case class OrderConfirmed(orderId: String) extends OrderEvent case class OrderPaid(orderId: String, orderLines: Seq[OrderLine], shippingInfo: ShippingInfo) extends OrderEvent object OrderCreated { implicit val format: Format[OrderCreated] = Json.format } object OrderConfirmed { implicit val format: Format[OrderConfirmed] = Json.format } object OrderPaid { implicit val format: Format[OrderPaid] = Json.format } implicit val format: Format[OrderEvent] = derived.flat.oformat((__ \ "type").format[String]) }
37. package com.xebia.webshop.shipping.api sealed trait OrderEvent object OrderEvent { case class OrderPicked(orderId: String, pickedBy: Employee) extends OrderEvent case class OrderShipped(orderId: String, shippingReference: String) extends OrderEvent case class OrderDelivered(orderId: String, wasDeliveredAt: LocalDateTime) extends OrderEvent object OrderPicked { implicit val format: Format[OrderPicked] = Json.format } object OrderShipped { implicit val format: Format[OrderShipped] = Json.format } object OrderDelivered { implicit val format: Format[OrderDelivered] = Json.format } implicit val format: Format[OrderEvent] = derived.flat.oformat((__ \ "type").format[String]) }
38. “Lagom” /lah-gome/ 1. (just) right, fitting, neither too much nor too little
39. Lagom provides an opinionated way of building microservices that intentionally constrains what a developer can do and how they should do it.
40. package com.xebia.webshop.order.api import akka.NotUsed import com.lightbend.lagom.scaladsl.api.broker.Topic import com.lightbend.lagom.scaladsl.api.transport._ import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall} trait OrderService extends Service { import Method._ import Service._ def orderEvents: Topic[OrderEvent] final override def descriptor = { named("order").withTopics( topic("order-OrderEvent", orderEvents) ) } }
41. Order Paid Order Picked Order Shipping
42. Order Paid Order Picked Whenever an Order is Paid Order Shipping
43. class OrderServicePolicy(orderService: OrderService) { orderService.orderEvents.subscribe.atLeastOnce(Flow[api.OrderEvent].mapAsync(1) { case x: OrderPaid => ??? // Where we should trigger our side-effect case other => Future.successful(Done) }) }
44. package com.xebia.webshop.order.api import akka.NotUsed import com.lightbend.lagom.scaladsl.api.broker.Topic import com.lightbend.lagom.scaladsl.api.transport._ import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall} trait OrderService extends Service { import Method._ import Service._ def orderEvents: Topic[OrderEvent] final override def descriptor = { named("order").withTopics( topic("order-OrderEvent", orderEvents) ) } }
45. Order Paid Order Picked Whenever an Order is Paid Pick Order Pay Order Order Shipping
46. Order Order Picked Whenever an Order is Paid Pick Order Order Order Paid Pay Order Order Shipping
47. Create Order Order Pay Order Order Confirmed Order Created Order Paid
48. Order OrderLine OrderLine OrderLine CreateOrder Ack OrderCreated Akka Actor
49. Order 1 Order Domain Order 2 Order 3 Akka Singleton (Entity Framework)
50. Hash(Id(Order 1)) Hash(Id(Order 2)) Hash(Id(Order 3)) A B C Akka Cluster (Auto-Sharding)
51. Create Order Order Pay Order Order Confirmed Order Created Order Paid
52. trait POrderCommand object POrderCommand { case class CreateOrder(orderLines: Seq[POrderLine], info: PShippingInfo) extends POrderCommand with ReplyType[Done] case class PayOrder(reference: String) extends POrderCommand with ReplyType[Done] case object GetOrder extends POrderCommand with ReplyType[POrder] }
53. trait POrderEvent extends AggregateEvent[POrderEvent] { override def aggregateTag: AggregateEventTagger[POrderEvent] = POrderEvent.Tag } object POrderEvent { val Tag = AggregateEventTag[POrderEvent] case class OrderCreated( orderLines: Seq[POrderLine], shippingInformation: PShippingInfo) extends POrderEvent case object OrderConfirmed extends POrderEvent case class OrderPaid(reference: String) extends POrderEvent }
54. case class POrder(id: String, orderLines: Seq[POrderLine], shippingInfo: Option[PShippingInfo], paymentReference: Option[String], confirmed: Boolean) object POrder { case class PShippingInfo(address: String, zipcode: String, city: String, country: String) case class PSKU(id: String) case class POrderLine(sku: PSKU, amount: Int) }
55. class OrderEntity extends PersistentEntity { override type Command = POrderCommand override type Event = POrderEvent override type State = POrder override def initialState = POrder(this.entityId, Seq.empty, None, None, false) override def behavior: Behavior = Actions() .onCommand[POrderCommand.CreateOrder, Done] { case (POrderCommand.CreateOrder(orderLines, shippingInfo), ctx, state) => { ctx.thenPersist(POrderEvent.OrderCreated(orderLines, shippingInfo)) { evt => ctx.reply(Done) } } }.onCommand[POrderCommand.PayOrder, Done] { case (POrderCommand.PayOrder(reference), ctx, state) => { ctx.thenPersistAll(POrderEvent.OrderPaid(reference), POrderEvent.OrderConfirmed) { () => ctx.reply(Done) } } }.onReadOnlyCommand[GetOrder.type, POrder] { case (GetOrder, ctx, state) => ctx.reply(state) }.onEvent { case (POrderEvent.OrderCreated(lines, shippingInfo), state) => state.copy(orderLines = lines, shippingInfo = Some(shippingInfo)) case (POrderEvent.OrderPaid(reference), state) => state.copy(paymentReference = Some(reference)) case (POrderEvent.OrderConfirmed, state) => state.copy(confirmed = true) } } Order
56. Order Order Picked Whenever an Order is Paid Pick Order Order Order Paid Pay Order Order Shipping
57. class OrderEntity extends PersistentEntity { override type Command = POrderCommand override type Event = POrderEvent override type State = POrder override def initialState = POrder(this.entityId, Seq.empty, None, None, false) override def behavior: Behavior = Actions().onCommand[POrderCommand.PayOrder, Done] { case (POrderCommand.PayOrder(reference), ctx, state) => { ctx.thenPersistAll(POrderEvent.OrderPaid(reference), POrderEvent.OrderConfirmed) { () => ctx.reply(Done) } } }.onEvent { case (POrderEvent.OrderPaid(reference), state) => state.copy(paymentReference = Some(reference)) case (POrderEvent.OrderConfirmed, state) => state.copy(confirmed = true) } }
58. class OrderEntity extends PersistentEntity { override type Command = POrderCommand override type Event = POrderEvent override type State = POrder override def initialState = POrder(this.entityId, Seq.empty, None, None, false) override def behavior: Behavior = Actions().onCommand[POrderCommand.PayOrder, Done] { case (POrderCommand.PayOrder(reference), ctx, state) => { ctx.thenPersistAll(POrderEvent.OrderPaid(reference), POrderEvent.OrderConfirmed) { () => ctx.reply(Done) } } }.onEvent { case (POrderEvent.OrderPaid(reference), state) => state.copy(paymentReference = Some(reference)) case (POrderEvent.OrderConfirmed, state) => state.copy(confirmed = true) } }
59. class OrderEntity extends PersistentEntity { override type Command = POrderCommand override type Event = POrderEvent override type State = POrder override def initialState = POrder(this.entityId, Seq.empty, None, None, false) override def behavior: Behavior = Actions().onCommand[POrderCommand.PayOrder, Done] { case (POrderCommand.PayOrder(reference), ctx, state) => { ctx.thenPersistAll(POrderEvent.OrderPaid(reference), POrderEvent.OrderConfirmed) { () => ctx.reply(Done) } } }.onEvent { case (POrderEvent.OrderPaid(reference), state) => state.copy(paymentReference = Some(reference)) case (POrderEvent.OrderConfirmed, state) => state.copy(confirmed = true) } }
60. class OrderEntity extends PersistentEntity { override type Command = POrderCommand override type Event = POrderEvent override type State = POrder override def initialState = POrder(this.entityId, Seq.empty, None, None, false) override def behavior: Behavior = Actions().onCommand[POrderCommand.PayOrder, Done] { case (POrderCommand.PayOrder(reference), ctx, state) => { ctx.thenPersistAll(POrderEvent.OrderPaid(reference), POrderEvent.OrderConfirmed) { () => ctx.reply(Done) } } }.onEvent { case (POrderEvent.OrderPaid(reference), state) => state.copy(paymentReference = Some(reference)) case (POrderEvent.OrderConfirmed, state) => state.copy(confirmed = true) } }
61. State OrderPaid OrderConfirmed OrderUpdated Akka Persistence
62. Event Processor OrderConfirmed OrderPaid OrderChanged OrderCreated Repository (Payment => Order) ID: A ID: B ID: C OrderConfirmed OrderPaid OrderChanged OrderCreated OrderConfirmed OrderPaid OrderChanged OrderCreated
63. Event Processor SEQ: 12 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 SEQ: 0 ID: A ID: B ID: C OrderConfirmed OrderPaid OrderChanged OrderCreated OrderConfirmed OrderPaid OrderChanged OrderCreated OrderConfirmed OrderPaid OrderChanged OrderCreated Repository (Payment => Order)
64. Event Processor SEQ: 12 #1 #2 #3 #4 #5 #6 #7 #8 #9 #10 #11 #12 SEQ: 12 ID: A ID: B ID: C OrderConfirmed OrderPaid OrderChanged OrderCreated OrderConfirmed OrderPaid OrderChanged OrderCreated OrderConfirmed OrderPaid OrderChanged OrderCreated Repository (Payment => Order)
65. package com.xebia.webshop.order.api import akka.NotUsed import com.lightbend.lagom.scaladsl.api.broker.Topic import com.lightbend.lagom.scaladsl.api.transport._ import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall} trait OrderService extends Service { import Method._ import Service._ def orderEvents: Topic[OrderEvent] final override def descriptor = { named("order").withTopics( topic("order-OrderEvent", orderEvents) ) } }
66. class OrderServiceImpl(persistentEntityRegistry: PersistentEntityRegistry)(implicit ec: ExecutionContext) extends OrderService { override def orderEvents = TopicProducer.singleStreamWithOffset { offset => persistentEntityRegistry.eventStream(POrderEvent.Tag, offset).filter(e => /* Filter some of the internal events to isolate some of the entities internal logic */ e.event == POrderEvent.OrderPaid ).mapAsync(1) { event => event.event match { case x: POrderEvent.OrderPaid => persistentEntityRegistry.refFor[OrderEntity](event.entityId).ask(POrderCommand.GetOrder).map { x => val shippingInfo = x.shippingInfo.getOrElse(throw new NoShippingInfoSetException()) val message = api.OrderEvent.OrderPaid( orderId = event.entityId, orderLines = x.orderLines.map(x => api.Order.OrderLine(api.Order.SKU(x.sku.id), x.amount)), shippingInfo = api.Order.ShippingInfo(shippingInfo.address, shippingInfo.zipcode, shippingInfo.country) ) (message, event.offset) } } } } }
67. Order Shipping Message Broker OrderPaid PickOrder OrderPaid
68. Order Order Picked Whenever an Order is Paid Pick Order Order Order Paid Pay Order Order Shipping
69. Order Shipping Message Broker OrderPaid PickOrder OrderPaid Whenever an Order is Paid
70. class OrderServicePolicy(persistentEntityRegistry: PersistentEntityRegistry, orderService: OrderService) { orderService.orderEvents.subscribe.atLeastOnce(Flow[OrderEvent].mapAsync(1) { case x: OrderPaid => entityRef(x.orderId).ask( PickOrder(x.orderId, PAddress(x.shippingInfo.address, x.shippingInfo.city, x.shippingInfo.address, x.shippingInfo.zipcode) )) case other => Future.successful(Done) }) private def entityRef(orderId: UUID) = persistentEntityRegistry.refFor[POrder](orderId.toString) }
71. Purposes are deduced from behaviour, not from rhetoric or stated goals — Donella H. Meadows
72. Autonomy is reached by implementing policies for behaviour instead of commanding behaviour
73. As long as events are readable on a topic, the origin is of less importance
74. Message Broker Basket Shipping Order Product Stock Legacy Service Gateway Domain Events Product UpdateProduct ProductUpdated / StockChanged Anti Corruption Layer / Data Pumps
75. Message Broker Domain Events Anti Corruption Layer / Data Pumps API Gateway CORE SHOPPING Product Event Command Basket Command Event
76. Message Broker Domain Events Anti Corruption Layer / Data Pumps API Gateway CORE SHOPPING CHECK-OUT SELF-SERVICE Product Event Payment Command Event Shipping Command Event Order Command Event Command Basket Command Event
77. Event-first thinking decouples behaviour, communication from structure
78. REST as an anti-pattern for service to service communication
79. Events-first delivers on a better way of modelling businesses in technology, while getting the rest for “free”
80. Q&A