Saga Pattern Implementation with Axon and Spring Boot – Part 1

Saga Pattern is a direct result of Database-per-service pattern. In Database-per-service pattern, each service has its own database. In other words, each service is responsible only for its own data.

This leads to a tricky situation.

Some business transactions require data from multiple services. Such transactions may also need to update or process data across services. Therefore, a mechanism to handle data consistency across multiple services is required.

This situation or use-case forms the basis of the Saga Pattern.

In this series of posts, we will implement Saga Pattern using Axon Framework and Spring Boot.

Axon Framework is a microservices framework that makes it easy to build distributed systems. It provides great support for Spring Boot and we will be using the same to build a sample application.

In Part 1 (this post), we will understand what Saga Pattern really is. We will also look at different types of Saga Implementation. At the end we will also look at the plan for the sample application we are going to build.

In Part 2, we will start building the sample application using Saga Pattern.

Continuing in Part 3, we will continue with our implementation.

Lastly, in Part 4, we will test our application and see the Saga in action.

Defining the Saga Pattern

Saga Pattern proposes implementing distributed transactions in the form of Sagas.

A Saga is nothing but a sequence of local transactions. These local transactions are occurring at the service level. Whenever a local transaction occurs, it publishes a message or an event. Such an event is responsible for triggering the next transaction in the Saga.

But then, you might ask what happens when a single transaction in the Saga sequence fails?

In that case, the Saga executes a series of compensating transactions. These transactions basically undo the changes made by the preceding transactions.

Types of Saga

There are basically two types of Saga. In other words, there are two ways in which you can implement the Saga Pattern.

Choreography-Based Saga

In this type of Saga Implementation, each service publishes one or more domain events. These domain events trigger local transactions in other microservices.

Let’s understand what is happening in the above example.

• Order Service is responsible for creating an Order. It also publishes an event for the same.
• The Payment Service listens to that event and creates an Invoice.
• When the Invoice is created, the Shipping Service creates the shipment.
• When the Order is shipped, the Order Service updates the status of the Order.

Now, this is a very simple example. In real life situations, there would be many business rules and steps involved to carry out such a distributed transaction. However, this example is only meant to demonstrate how Saga Pattern works.

The important thing to note here is that each service plays its part in the choreography. Each service is basically dependent on the events coming out from other services.

Orchestration-Based Saga

In Orchestration-Based Saga, there is an orchestrator. An orchestrator can also be thought of as a manager that directs the participant services to execute local transactions.

Below is how it can look like for the previous example.

Let’s understand what’s happening in this approach:

• Order Service creates an Order. Then, it also creates the Order Management Saga.
• The Order Management Saga sends a Create Invoice Command to the Payment Service.
• The Payment Service creates the Invoice and responds back to the Order Management Saga. Note that these responses can be totally asynchronous and message-driven as well.
• In the next step, the Order Management Saga issues the Create Shipping Command to the Shipping Service.
• The Shipping Service does the needful and creates the Shipping. It also replies back to the Order Management Saga.
• The Order Management Saga changes the status of the Order and ends the Saga’s life-cycle.

Saga Pattern – Benefits and Drawbacks

The biggest benefit of Saga Pattern is that it allows an application to maintain data consistency across multiple services. This is very important from a Microservices Architecture point-of-view because it allows us to write our individual services without tight coupling. In case we run into a case for distributed transactions, we can utilize the Saga Pattern.

However, there are also drawbacks in this approach. The main point going against Saga Pattern is the fact that this pattern makes the programming model more complex. A simple example is developing compensating transactions in case anything goes wrong. Also, developers are usually not completely comfortable with this programming model. At least, not yet.

Other challenges include the topic of atomically updating the Aggregate state as well as publishing domain events.

Usually, Saga Pattern is applied in conjunction with some other patterns such as Event Sourcing and CQRS. These patterns specifically try to handle the scenarios around atomically updating the Aggregate’s state and publish events.

Implementing Saga Pattern

Now that we have understood what is Saga Pattern, we will look at implementing it.

We will be look at Orchestration-Based Implementation. And we will be using the same case as the Order Service described above.

Some of the tools and frameworks we would be using are as follows:

• Axon Framework – This is a Java-based Microservices Framework that helps build applications using Domain Driven Design techniques. Building Scalable Microservices using Axon Framework describes the framework in more detail.
• Axon Server – From version 4 onward, Axon has becomes more of a platform. The Axon Platform comprises of the core Axon Framework and also the Axon Server. The Axon Server facilitates communication between microservices.
• Spring Boot – Spring Boot is probably the most popular Java-based framework for building enterprise application. It’s ease of use and wide integration with other frameworks makes it an ideal choice for building microservices. Building Fastest Production-Ready Microservices using Spring Boot talks in detail about Spring Boot Microservices.

Conclusion

To conclude for this post, we will be using the above frameworks plus a lot of other smaller components to implement Saga Pattern for Order Management.

Till this point, we have explored what Saga Pattern really is. And how it can solve one of the most difficult challenges in moving to a Microservices Architecture.

We also looked at two ways of implementing Saga Pattern – the Choreography Way and the Orchestration Way. We also understood the benefits and drawbacks of Saga implementation.

In the next post, we will start with implementation of the Order Management Saga in the Orchestration-based approach. So stay tuned and let me know your overall thoughts about Saga Pattern in the comments section below.