Saga Pattern - zarządzanie rozproszonymi transakcjami
Problem, który Saga rozwiązuje - brak transakcji ACID między mikroserwisami
W monolicie, transakcja obejmująca wiele operacji (np. utworzenie zamówienia + odjęcie stanu magazynowego + obciążenie płatności) jest prosta - jedna transakcja bazodanowa, BeginTransaction/Commit/Rollback, jak omawialiśmy przy EF Core.
W architekturze mikroserwisów te operacje żyją w różnych serwisach, z różnymi bazami danych:
OrderService (własna baza) → InventoryService (własna baza) → PaymentService (własna baza)
Nie możesz po prostu owinąć tego w jedną transakcję SQL - nie ma jednej bazy danych, którą mógłbyś objąć transakcją BeginTransactionAsync(). Klasyczne dwufazowe zatwierdzanie (2PC - Two-Phase Commit) na poziomie rozproszonym jest w praktyce rzadko używane w mikroserwisach - jest wolne, blokujące i słabo się skaluje.
Saga Pattern to odpowiedź na ten problem: rozbija dużą operację biznesową na sekwencję mniejszych, lokalnych transakcji, każda w obrębie jednego serwisu, z mechanizmem kompensacji (compensating actions) w przypadku niepowodzenia jednego z kroków.
Skąd nazwa "Saga"
Nazwa pochodzi z oryginalnej pracy naukowej z 1987 roku (Hector Garcia-Molina, Kenneth Salem) opisującej długotrwałe transakcje, które - jak epicka saga - składają się z wielu następujących po sobie "rozdziałów" (kroków), zamiast jednego, atomowego zdarzenia.
Dwa modele implementacji Sagi
1. Choreography (Choreografia) - brak centralnego koordynatora
Każdy serwis nasłuchuje zdarzeń i reaguje, publikując własne zdarzenia - nikt "nie dyryguje" całością, to zdecentralizowany, zdarzeniowy przepływ.
// OrderService
public class OrderCreatedHandler
{
public async Task Handle(OrderCreatedEvent orderCreated)
{
// Utworzono zamówienie, publikuj zdarzenie
await _eventBus.PublishAsync(new OrderPlacedEvent(orderCreated.OrderId, orderCreated.Items));
}
}
// InventoryService - nasłuchuje OrderPlacedEvent
public class OrderPlacedHandler
{
public async Task Handle(OrderPlacedEvent orderPlaced)
{
var reserved = await _inventoryRepository.TryReserveStockAsync(orderPlaced.Items);
if (reserved)
await _eventBus.PublishAsync(new StockReservedEvent(orderPlaced.OrderId));
else
await _eventBus.PublishAsync(new StockReservationFailedEvent(orderPlaced.OrderId)); // KOMPENSACJA
}
}
// PaymentService - nasłuchuje StockReservedEvent
public class StockReservedHandler
{
public async Task Handle(StockReservedEvent stockReserved)
{
var charged = await _paymentGateway.ChargeAsync(stockReserved.OrderId);
if (charged)
await _eventBus.PublishAsync(new PaymentCompletedEvent(stockReserved.OrderId));
else
await _eventBus.PublishAsync(new PaymentFailedEvent(stockReserved.OrderId)); // KOMPENSACJA
}
}
// OrderService - nasłuchuje StockReservationFailedEvent / PaymentFailedEvent - KOMPENSACJA
public class SagaCompensationHandler
{
public async Task Handle(PaymentFailedEvent paymentFailed)
{
await _orderRepository.CancelOrderAsync(paymentFailed.OrderId);
await _eventBus.PublishAsync(new ReleaseStockEvent(paymentFailed.OrderId)); // każ InventoryService zwolnić rezerwację
}
}
Zalety Choreography: - Prostota dla małej liczby kroków - brak dodatkowego, scentralizowanego komponentu do zbudowania - Naturalna słaba spójność (loose coupling) - serwisy nie znają się nawzajem, tylko zdarzenia
Wady: - Trudność w śledzeniu całego przepływu - żeby zrozumieć "co się dzieje przy tworzeniu zamówienia", musisz przejrzeć handlery w kilku różnych serwisach, bez jednego, czytelnego miejsca opisującego cały proces - Ryzyko cyklicznych zależności zdarzeń przy złożonych sagach z wieloma krokami - Trudniejsze testowanie end-to-end całego przepływu
2. Orchestration (Orkiestracja) - centralny koordynator
Dedykowany komponent (Saga Orchestrator) jawnie koordynuje wszystkie kroki, wysyłając komendy do poszczególnych serwisów i decydując, co robić w przypadku błędu.
public class OrderSagaOrchestrator
{
private readonly IInventoryServiceClient _inventoryClient;
private readonly IPaymentServiceClient _paymentClient;
private readonly IOrderRepository _orderRepository;
public async Task ExecuteAsync(int orderId, List<OrderItemDto> items, decimal amount)
{
try
{
// Krok 1
await _inventoryClient.ReserveStockAsync(orderId, items);
try
{
// Krok 2
await _paymentClient.ChargeAsync(orderId, amount);
}
catch (PaymentFailedException)
{
// KOMPENSACJA dla Kroku 1 - musimy wycofać rezerwację magazynową
await _inventoryClient.ReleaseStockAsync(orderId, items);
throw;
}
// Krok 3
await _orderRepository.MarkAsConfirmedAsync(orderId);
}
catch (Exception)
{
await _orderRepository.MarkAsFailedAsync(orderId);
throw;
}
}
}
Wersja z jawną maszyną stanów (State Machine) - częsta w praktyce, np. z biblioteką MassTransit (obsługującą Sagi natywnie):
public class OrderSaga : MassTransitStateMachine<OrderSagaState>
{
public State AwaitingStockReservation { get; private set; }
public State AwaitingPayment { get; private set; }
public State Completed { get; private set; }
public State Failed { get; private set; }
public Event<OrderPlacedEvent> OrderPlaced { get; private set; }
public Event<StockReservedEvent> StockReserved { get; private set; }
public Event<PaymentCompletedEvent> PaymentCompleted { get; private set; }
public Event<PaymentFailedEvent> PaymentFailed { get; private set; }
public OrderSaga()
{
InstanceState(x => x.CurrentState);
Initially(
When(OrderPlaced)
.Then(context => context.Saga.OrderId = context.Message.OrderId)
.TransitionTo(AwaitingStockReservation)
.Publish(context => new ReserveStockCommand(context.Message.OrderId)));
During(AwaitingStockReservation,
When(StockReserved)
.TransitionTo(AwaitingPayment)
.Publish(context => new ChargePaymentCommand(context.Saga.OrderId)));
During(AwaitingPayment,
When(PaymentCompleted)
.TransitionTo(Completed),
When(PaymentFailed)
.Publish(context => new ReleaseStockCommand(context.Saga.OrderId)) // KOMPENSACJA
.TransitionTo(Failed));
}
}
Zalety Orchestration: - Jasny, scentralizowany przepływ - cały proces biznesowy widoczny w JEDNYM miejscu (klasa Orchestratora/State Machine) - Łatwiejsze testowanie i debugowanie całej sekwencji - Łatwiej dodać timeouty i bardziej złożoną logikę warunkową
Wady: - Orchestrator staje się punktem centralnym - większa odpowiedzialność w jednym miejscu (choć nie jest to "single point of failure" w sensie dostępności, jeśli jest odpowiednio zaprojektowany) - Serwisy uczestniczące muszą "znać" Orchestratora (przynajmniej format komend, które odbierają)
Kompensacja (Compensating Transactions) - fundament Sagi
To jest najważniejsza koncepcja w całym wzorcu - skoro nie ma rozproszonego rollbacku (jak w klasycznej transakcji SQL), każdy krok Sagi musi mieć zdefiniowaną akcję kompensującą, która "odwraca" jego efekt:
| Krok | Akcja | Kompensacja |
|---|---|---|
| 1. Rezerwacja stanu magazynowego | ReserveStock() |
ReleaseStock() |
| 2. Obciążenie płatności | ChargePayment() |
RefundPayment() |
| 3. Potwierdzenie zamówienia | ConfirmOrder() |
CancelOrder() |
Ważna właściwość kompensacji: nie musi być "dosłownym cofnięciem" - to jest semantyczne odwrócenie efektu biznesowego. Np. jeśli płatność już przeszła i towar został wysłany, "kompensacja" może oznaczać zwrot pieniędzy i proces reklamacyjny, nie magiczne "usunięcie" faktu, że transakcja się wydarzyła.
Idempotencja - wymóg praktyczny dla wszystkich kroków Sagi
Skoro komunikacja między serwisami odbywa się przez sieć (message queue, HTTP), wiadomości mogą być dostarczone wielokrotnie (retry po timeout, brak potwierdzenia ACK) - każdy krok Sagi (i jego kompensacja) musi być idempotentny, czyli bezpieczny do wielokrotnego wykonania z tym samym skutkiem:
public async Task ReserveStockAsync(int orderId, List<OrderItemDto> items)
{
// ✅ Idempotentne - sprawdza, czy JUŻ zarezerwowano dla tego orderId, zanim zrobi to ponownie
var existingReservation = await _context.StockReservations
.FirstOrDefaultAsync(r => r.OrderId == orderId);
if (existingReservation != null) return; // już wykonane, nic nie robimy
// faktyczna logika rezerwacji
}
Kiedy stosować Sagę - praktyczna reguła
Saga ma sens, gdy masz operację biznesową obejmującą wiele niezależnych serwisów/baz danych, którą trzeba przeprowadzić w skoordynowany sposób, bez klasycznej rozproszonej transakcji ACID. Dla prostych przepływów (2-3 kroki, mało warunków błędu) Choreography jest szybsza do zaimplementowania. Dla złożonych przepływów (wiele kroków, warunki, timeouty, potrzeba śledzenia stanu) Orchestration (zwłaszcza z gotową biblioteką jak MassTransit) daje dużo lepszą czytelność i testowalność.
Podsumowanie
Saga Pattern rozwiązuje problem transakcji rozproszonych między mikroserwisami przez rozbicie dużej operacji na sekwencję lokalnych transakcji, każda z zdefiniowaną akcją kompensującą na wypadek niepowodzenia kolejnego kroku. Dwa modele implementacji - Choreography (zdecentralizowana, przez zdarzenia, prostsza dla małych sag) i Orchestration (scentralizowany koordynator/maszyna stanów, lepsza czytelność i testowalność dla złożonych przepływów) - różnią się głównie tym, kto podejmuje decyzje o kolejnym kroku: w Choreography każdy serwis reaguje samodzielnie na zdarzenia, w Orchestration jeden komponent jawnie steruje całym procesem. Kluczowe wymogi praktyczne to kompensacja dla każdego kroku i idempotencja wszystkich operacji, bo komunikacja sieciowa nie gwarantuje dostarczenia "exactly once".