C# / .NET Kompendium PLEN
.NET / C# / Architektura rozproszona

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".

Postaw mi kawę