Overview of the Eventuate Tram Customers and Orders application

This Spring Boot/JPA application illustrates how to use the Saga and CQRS patterns in a microservice architecture.

Software

@crichardson
About the Eventuate Tram
Customers and Orders example
Chris Richardson
Founder of Eventuate.io
Founder of the original CloudFoundry.com
Author of POJOs in Action
@crichardson
chris@chrisrichardson.net
http://microservices.io
http://eventuate.io
Copyright © 2020. Chris Richardson Consulting, Inc. All rights reserved

@crichardson
About the example
Demonstrates two key patterns:
Sagas - implement transactions that span services, https://
microservices.io/patterns/data/saga.html
CQRS - implement queries that retrieve data from multiple
services, https://microservices.io/patterns/data/cqrs.html
Built using Spring Boot, JPA and the Eventuate Tram
framework
https://github.com/eventuate-tram/eventuate-tram-examples-customers-and-orders/
Note: this presentation describes the development branch , which
reorganized/renamed the service modules.
These changes will soon be merged into master

@crichardson
System operations
CustomersAndOrdersApplication
≪commands≫
createCustomer(name, creditLimit)
createOrder(customerId, orderTotal)
cancelOrder(orderID)
≪queries≫
ﬁndOrder(orderId)
ﬁndOrderHistory(customerId)

@crichardson
Customer Service - domain
model

@crichardson
Order Service - domain model

@crichardson
Order History Service - canvas

@crichardson
Technical architecture
Service:
REST endpoint
Pub/sub events
Relational database - MySQL database
Message broker
Eventuate CDC - implements the Transaction Outbox pattern

@crichardson
Using the Saga pattern
Customer has a credit limit
createOrder()
Creates Order
Reserves credit
cancelOrder()
Updates Order
Releases credit
Event-driven
a.k.a
Choreography-based sagas
https://microservices.io/patterns/data/saga.html

Using the CQRS pattern
ﬁndOrderHistory()
Returns customers and
their orders
Order History Service
uses events to maintain a
replica in MongoDB
https://microservices.io/patterns/data/cqrs.html

@crichardson
Customer Service
Customer
Controller
Message
Producer
createCustomer()
Customer* Events
Order
Event
Consumer
Order* events
Customer
Database
≪entity≫
Customer
Customer
Repository
≪service≫
Customer
Service
Domain
Event
Publisher
POST /customers

Customer Service - code
customer-service-api-
messaging - events
published by the service
customer-service-api-web
- DTOs for REST
resources
customer-service - service
implementation

@crichardson
Order Service
Order Controller
Message
Producer
createOrder()
cancelOrder()
Order* Events
Customer
Event
Consumer
Customer* events
Order
Database
≪entity≫
Order
Order
Repository
≪service≫
Order
Service
Domain
Event
Publisher
POST /customers

Order Service - code
order-service-api-
messaging - events
published by the service
order-service-api-web -
DTOs for REST requests
and responses
order-service - service
implementation

@crichardson
Order History Service
CustomerOrder
HistoryController
ﬁndOrderHistory()
Order
History
Event
Consumer
Order* events
Order
History
Databas
CustomerView
Repository
≪service≫Ord
erHistory
ViewService
POST /customers
Customer* events

Order History Service - code
order-history-service-api-
web - DTOs for REST
requests and responses
order-service - service
implementation

@crichardson
Using the Saga pattern
https://microservices.io/patterns/data/saga.html

@crichardson
createOrder() sequence
diagram

@crichardson
cancelOrder() sequence
diagram

@crichardson
Using the CQRS pattern
https://microservices.io/patterns/data/cqrs.html

@crichardson
Implementing ﬁndOrderHistory()

@crichardson
@crichardson chris@chrisrichardson.net
http://eventuate.io
Questions?

The microservice architecture is becoming increasing important. But what is it exactly? Why should you care about microservices? And, what do you need to do to ensure that your organization uses the microservice architecture successfully? In this talk, I’ll answer these and other questions using shapes as visual metaphors. You will learn about the motivations for the microservice architecture and why simply adopting microservices is insufficient. I describe essential characteristics of microservices, You will learn how a successful microservice architecture consist of loosely coupled services with stable APIs that communicate asynchronous. I will cover strategies for effectively testing microservices.

Saturn 2018: Managing data consistency in a microservice architecture using S...

A revised and extended version that I gave at Saturn 2018. The services in a microservice architecture must be loosely coupled and so cannot share database tables. What’s more, two phase commit (a.k.a. a distributed transaction) is not a viable option for modern applications. Consequently, a microservices application must use the Saga pattern, which maintains data consistency using a series of local transactions. In this presentation, you will learn how sagas work and how they differ from traditional transactions. We describe how to use sagas to develop business logic in a microservices application. You will learn effective techniques for orchestrating sagas and how to use messaging for reliability. We will describe the design of a saga framework for Java and show a sample application.

DDD SoCal: Decompose your monolith: Ten principles for refactoring a monolith...

Kong Summit 2018 - Microservices: decomposing applications for testability an...

In this presentation, I describe the essential characteristics of the microservice architecture. You will learn about the benefits and drawbacks of the microservice architecture and when it makes sense to use it. I discuss how the microservice architecture is not a silver bullet. You will learn about the microservice pattern language, which is a collection of patterns that solve architecture and design issues that you will encounter when using microservices.

From Monolithic to Microservices

In this session, we’ll discuss the benefits of moving from monolithic to micro-services application architectures, and examine where micro-services can be used. We’ll share common transition strategies and relate them to the specifics of e-commerce and retail workloads, using customer examples. You’ll learn how to build micro-services using AWS services, and get a better understanding of the role of data storage, API endpoints and service discovery. Plus, you can learn from the real-life experience of Digital Goodie, an online retailing platform for connected commerce.

YOW2018 - Events and Commands: Developing Asynchronous Microservices

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. I describe how to implement transactions using sagas, which are sequences of local transactions, coordinated using messages. You will learn how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain replicas. I describe how to use event sourcing, which is an event-centric approach to business logic and persistence, in a microservice architecture.

What is a Microservices architecture and how does it differ from a Service-Oriented Architecture? Should you use traditional REST APIs to bind services together? Or is it better to use a richer, more loosely-coupled protocol? This talk will start with quick recap of how we created systems over the past 20 years and how different architectures evolved from it. The talk will show how we piece services together in event driven systems, how we use a distributed log (event hub) to create a central, persistent history of events and what benefits we achieve from doing so. Apache Kafka is a perfect match for building such an asynchronous, loosely-coupled event-driven backbone. Events trigger processing logic, which can be implemented in a more traditional as well as in a stream processing fashion. The talk will show the difference between a request-driven and event-driven communication and show when to use which. It highlights how the modern stream processing systems can be used to hold state both internally as well as in a database and how this state can be used to further increase independence of other services, the primary goal of a Microservices architecture.

Architecture: Microservices

Kevin Huang: AWS San Francisco Startup Day, 9/7/17 Architecture: When, how, and if to adopt microservices - Microservices are not for everyone! If you're a small shop, a monolith provides a great amount of value and reduces the complexities involved. However as your company grows, this monolith becomes more difficult to maintain. We’ll look at how microservices allow you to easily deploy and debug atomic pieces of infrastructure which allows for increased velocity in reliable, tested, and consistent deploys. We’ll look into key metrics you can use to identify the right time to begin the transition from monolith to microservices.

Designing loosely coupled services

Skillsmatter CloudNative eXchange 2020 The microservice architecture is a key part of cloud native. An essential principle of the microservice architecture is loose coupling. If you ignore this principle and develop tightly coupled services the result will mostly likely be yet another "microservices failure story”. Your application will be brittle and have all of disadvantages of both the monolithic and microservice architectures. In this talk you will learn about the different kinds of coupling and how to design loosely coupled microservices. I describe how to minimize design time and increase the productivity of your DevOps teams. You will learn how how to reduce runtime coupling and improve availability. I describe how to improve availability by minimizing the coupling caused by your infrastructure.

Microservice vs. Monolithic Architecture

Paul Mooney

Principles of microservices XP Days Ukraine

Sam Newman

Monoliths and Microservices

Bozhidar Bozhanov

QConPlus 2021: Minimizing Design Time Coupling in a Microservice Architecture

Delivering large, complex software rapidly, frequently and reliably requires a loosely coupled organization. DevOps teams should rarely need to communicate and coordinate in order to get work done. Conway's law states that an organization and the architecture that it develops mirror one another. Hence, a loosely coupled organization requires a loosely coupled architecture. In this presentation, you will learn about design-time coupling in a microservice architecture and why it's essential to minimize it. I describe how to design service APIs to reduce coupling. You will learn how to minimize design-time coupling by applying a version of the DRY principle. I describe how key microservices patterns potentially result in tight design time coupling and how to avoid it.

Using patterns and pattern languages to make better architectural decisions

This is a presentation that gave at the O'Reilly Software Architecture Superstream: Software Architecture Patterns. The talk's focus is the microservices pattern language. However, it also shows how thinking with the pattern mindset - context/problem/forces/solution/consequences - leads to better technically decisions. The microservices architecture offers tremendous benefits, but it’s not a silver bullet. It also has some significant drawbacks. The microservices pattern language—a collection of patterns that solve architecture, design, development, and operational problems—enables software developers to apply the microservices architecture effectively. I provide an overview of the microservices architecture and examines the motivations for the pattern language, then takes you through the key patterns in the pattern language.

Mucon: Not Just Events: Developing Asynchronous Microservices

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. Chris will share with you how to implement transactions using sagas, which are sequences of local transactions. You will learn how to coordinate sagas using either events or command messages. Chris will also explore how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain easily queried replicas.

Microservice Architecture

Nguyen Tung

Docker Kubernetes Istio

Tutorial - Modern Real Time Streaming Architectures

Karthik Ramasamy

Across diverse segments in industry, there has been a shift in focus from big data to fast data, stemming, in part, from the deluge of high-velocity data streams as well as the need for instant data-driven insights, and there has been a proliferation of messaging and streaming frameworks that enterprises utilize to satisfy the needs of various applications. Drawing on their experience operating streaming systems at Twitter scale, Karthik Ramasamy, Sanjeev Kulkarni, Arun Kejariwal, and Sijie Guo walk you through state-of-the-art streaming architectures, streaming frameworks, and streaming algorithms, covering the typical challenges in modern real-time big data platforms and offering insights on how to address them. They also discuss how advances in technology might impact the streaming architectures and applications of the future. Along the way, they explore the interplay between storage and stream processing and speculate about future developments. Topics include: Basic requirements of stream processing Streaming and one-pass algorithms Different types of streaming architectures An in-depth review of streaming frameworks Deploying and operating stream processing applications Lessons learned from building a real-time stack using Apache Pulsar and Apache Heron at Twitter Scale

Decompose your monolith: strategies for migrating to microservices (Tide)

This is a presentation that I gave at Tide.co, London - January 2020 A typical mission-critical enterprise application is a large, complex monolith developed by large team. Software delivery is usually slow, and the team struggles to keep up with the demands of the business. Consequently, many enterprise applications are good candidates to be migrated to the microservice architecture. But how do you know whether it makes sense to migrate to microservices? And, how to get there? In this presentation, I describe when you should consider migrating to microservices. You will learn strategies for migrating a monolith application to a microservice architecture. I explain how to implement new functionality as services. You will learn how to incrementally break apart a monolith one service at a time.

A pattern language for microservices - June 2021

The microservice architecture is growing in popularity. It is an architectural style that structures an application as a set of loosely coupled services that are organized around business capabilities. Its goal is to enable the continuous delivery of large, complex applications. However, the microservice architecture is not a silver bullet and it has some significant drawbacks. The goal of the microservices pattern language is to enable software developers to apply the microservice architecture effectively. It is a collection of patterns that solve architecture, design, development and operational problems. In this talk, I’ll provide an overview of the microservice architecture and describe the motivations for the pattern language. You will learn about the key patterns in the pattern language.

Agile, User Stories, Domain Driven Design

From Monolith to Microservices

Microservices architecture overview v2

Dmitry Skaredov

Temporal intro and event loop

TihomirSurdilovic

AWS App Mesh (Service Mesh Magic)- AWS Container Day 2019 Barcelona

Microservices: Decomposing Applications for Deployability and Scalability (ja...

Today, there are several trends that are forcing application architectures to evolve. Users expect a rich, interactive and dynamic user experience on a wide variety of clients including mobile devices. Applications must be highly scalable, highly available and run on cloud environments. Organizations often want to frequently roll out updates, even multiple times a day. Consequently, it's no longer adequate to develop simple, monolithic web applications that serve up HTML to desktop browsers.In this talk we describe the limitations of a monolithic architecture. You will learn how to use the scale cube to decompose your application into a set of narrowly focused, independently deployable services. We will also discuss how an event-based approach addresses the key challenges of developing applications with this architecture.

Microservices + Events + Docker = A Perfect Trio (dockercon)

Microservices are an essential enabler of agility but developing and deploying them is a challenge. In order for microservices to be loosely coupled,each service must have its own datastore. This makes it difficult to maintain data consistency across services. Deploying microservices is also a complex problem since an application typically consists of 10s or 100s of services, written in a variety of languages and frameworks. In this presentation, you will learn how to solve these problems by using an event-driven architecture to maintain data consistency and by using Docker to simplify deployment.

What's hot

Application modernization patterns with apache kafka, debezium, and kubernete...

Bilgin Ibryam

Building Event Driven (Micro)services with Apache Kafka

Guido Schmutz

Architecture: Microservices

Designing loosely coupled services

Microservice vs. Monolithic Architecture

Paul Mooney

Principles of microservices XP Days Ukraine

Sam Newman

Monoliths and Microservices

Bozhidar Bozhanov

QConPlus 2021: Minimizing Design Time Coupling in a Microservice Architecture

Using patterns and pattern languages to make better architectural decisions

Mucon: Not Just Events: Developing Asynchronous Microservices

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. Chris will share with you how to implement transactions using sagas, which are sequences of local transactions. You will learn how to coordinate sagas using either events or command messages. Chris will also explore how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain easily queried replicas.

Microservice Architecture

Nguyen Tung

Docker Kubernetes Istio

Tutorial - Modern Real Time Streaming Architectures

Karthik Ramasamy

Decompose your monolith: strategies for migrating to microservices (Tide)

A pattern language for microservices - June 2021

Agile, User Stories, Domain Driven Design

From Monolith to Microservices

Microservices architecture overview v2

Dmitry Skaredov

Temporal intro and event loop

TihomirSurdilovic

AWS App Mesh (Service Mesh Magic)- AWS Container Day 2019 Barcelona

What's hot (20)

Application modernization patterns with apache kafka, debezium, and kubernete...

Building Event Driven (Micro)services with Apache Kafka

Architecture: Microservices

Designing loosely coupled services

Microservice vs. Monolithic Architecture

Principles of microservices XP Days Ukraine

Monoliths and Microservices

QConPlus 2021: Minimizing Design Time Coupling in a Microservice Architecture

Using patterns and pattern languages to make better architectural decisions

Mucon: Not Just Events: Developing Asynchronous Microservices

Microservice Architecture

Docker Kubernetes Istio

Tutorial - Modern Real Time Streaming Architectures

Decompose your monolith: strategies for migrating to microservices (Tide)

A pattern language for microservices - June 2021

Agile, User Stories, Domain Driven Design

From Monolith to Microservices

Microservices architecture overview v2

Temporal intro and event loop

AWS App Mesh (Service Mesh Magic)- AWS Container Day 2019 Barcelona

Similar to Overview of the Eventuate Tram Customers and Orders application

Microservices: Decomposing Applications for Deployability and Scalability (ja...

Microservices + Events + Docker = A Perfect Trio (dockercon)

Microservices + Events + Docker = A Perfect Trio by Docker Captain Chris Rich...

Docker, Inc.

Events on the outside, on the inside and at the core (jaxlondon)

This presentation looks at the importance of events and the role that they play in software applications. We describe how events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You will learn how the microservices inside a system can use events to maintain data consistency. We discuss how easy it is to implement both these mechanisms by developing your core business logic using an event-centric approach.

Events on the outside, on the inside and at the core - Chris Richardson

JAXLondon_Conference

Introduction to MicroServices (Oakjug)

Futures and Rx Observables: powerful abstractions for consuming web services ...

A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone. In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.

Developing event-driven microservices with event sourcing and CQRS (Shanghai)

This is a talk I gave in Shanghai on July 4th 2016 In a microservices architecture, each service has its own database. While this ensures that services are loosely coupled it creates a problem: how do you maintain consistency across services without using 2PC? In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Separation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.

Building a SaaS using WSO2 StratosWSO2

SVCC Developing Asynchronous, Message-Driven Microservices

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. I describe how to implement transactions using sagas, which are sequences of local transactions, coordinated using messages. You will learn how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain replicas. I describe the key role that messaging plays a microservice architecture. Given at Silicon Valley Code Camp 2018

OReilly SACON2018 - Events on the outside, on the inside, and at the core

Events are very much on the edge of traditional applications, which use them as an application integration mechanism. The classic example is an ecommerce system. When a customer places an order, the order management application publishes an event, which triggers the fulfillment application to action. But today, microservices and DDD—which is a great foundation for microservices—are at the core of the application. Events play an essential role in modern applications. Chris Richardson explains why events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You’ll learn how the microservices inside an application use events to maintain data consistency and discover how to go one step further and make events an integral part of your domain logic.

Developing applications with a microservice architecture (SVforum, microservi...

Building and deploying microservices with event sourcing, CQRS and Docker (Ha...

In this talk we share our experiences developing and deploying a microservices-based application. You will learn about the distributed data management challenges that arise in a microservices architecture. We will describe how we solved them using event sourcing to reliably publish events that drive eventually consistent workflows and pdate CQRS-based views. You will also learn how we build and deploy the application using a Jenkins-based deployment pipeline that creates Docker images that run on Amazon EC2.

Decompose your monolith: Six principles for refactoring a monolith to microse...

Developing applications with a microservice architecture (svcc)

The micro-service architecture, which structures an application as a set of small, narrowly focused, independently deployable services, is becoming an increasingly popular way to build applications. This approach avoids many of the problems of a monolithic architecture. It simplifies deployment and let’s you create highly scalable and available applications. In this talk we describe the micro-service architecture and how to use it to build complex applications. You will learn how techniques such as Command Query Responsibility Segregation (CQRS) and Event Sourcing address the key challenges of developing applications with this architecture. We will also cover some of the various frameworks such as NodeJS and Spring Boot that you can use to implement micro-services.

Developing event-driven microservices with event sourcing and CQRS (london Ja...

This is a talk I gave to the London Java Community in June 2016 In a microservices architecture, each service has its own database. While this ensures that services are loosely coupled it creates a problem: how do you maintain consistency across services without using 2PC? In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Separation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.

#JaxLondon keynote: Developing applications with a microservice architecture