SAGA IMPLEMENTATION USING THE OUTBOX PATTERN

Abstract

Microservice architecture provides a number of advantages, which include flexibility, fault tolerance, and the ability to reuse functionality. But the distributed nature of such systems makes it difficult to manage interactions and data consistency between different services. Applications need to perform transactions spanning multiple services, each with its own database and isolated. To manage transactions in systems with a microservice architecture, the Saga design pattern is used, which represents a distributed transaction as a sequence of local transactions. Typically, a local transaction updates the service database and publishes a message to initiate the next local transaction in the saga. Updating the database and publishing a message must be done atomically, otherwise the system may end up in an inconsistent state. This can happen if, for example, after committing changes to the database, the message is not sent due to network failure. The Transitional Outbox or Event Sourcing pattern can be used to ensure data consistency. The article is devoted to research the features of using these patterns when implementing distributed transactions using Saga, identifying the advantages and disadvantages of each approach. Event Sourcing allows you to save the history of changes in the state of an object, play back events to restore its state at a certain point in time. The disadvantage of this pattern is that it is difficult to learn. When using complex database queries, in combination with Event Sourcing you should use the CQRS pattern. The paper presents a microservices-based application architecture built using the Saga and Outbox design patterns. Services interact with each other asynchronously using Apache Kafka and Debezium connectors, which monitor changes in the databases and transmit messages to the broker. Services receive messages from the broker immediately after publication.