Microservices Communication Patterns (Saga, Circuit Breaker) · Leçon

Machines à états pour l’orchestration

Appliquez les concepts de machine à états pour créer des orchestrateurs de sagas robustes et prévisibles qui suivent la progression des transactions.

Leçon 2 sur 411 étapes

Machines à états pour l’orchestration est une leçon Microservices Communication Patterns (Saga, Circuit Breaker) gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Microservices Communication Patterns (Saga, Circuit Breaker), et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Microservices Communication Patterns (Saga, Circuit Breaker) comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

State Machines for Sagas

Welcome to this lesson on using state machines to build robust saga orchestrators!

Orchestration sagas manage complex distributed transactions by keeping track of the overall process. State machines are a powerful tool for this.

Why State Machines?

A saga orchestrator needs to know the exact status of a business process at any given moment. This allows it to:

Decide the next action to take.
Handle failures and trigger compensation.
Ensure consistency across multiple services.

State machines provide a clear, structured way to model this complex logic.

State Machine Basics

At its core, a state machine consists of three main concepts:

States: Represent different phases or conditions of the saga (e.g., OrderCreated, PaymentPending).
Events: Occurrences that trigger changes in the saga (e.g., PaymentSuccessful, ShipmentFailed).
Transitions: Rules that define how an event causes the saga to move from one state to another.

Example: Order Processing Saga

Let's consider a common scenario: an online order processing saga.

This saga might involve several services:

Order Service
Payment Service
Shipping Service

The orchestrator needs to coordinate these steps.

Defining Saga States

For our order processing saga, we can define states like:

ORDER_CREATED: Initial state.
PAYMENT_PENDING: Waiting for payment confirmation.
PAID: Payment successful.
SHIPPING_PENDING: Waiting for shipment to be initiated.
SHIPPED: Item has been shipped.
CANCELLED: Order cancelled (due to failure or user action).

Defining Saga Events

And the events that can occur:

ORDER_PLACED: Customer places an order.
PAYMENT_SUCCESS: Payment service confirms payment.
PAYMENT_FAILED: Payment service reports failure.
SHIPMENT_SUCCESS: Shipping service confirms shipment.
SHIPMENT_FAILED: Shipping service reports an issue.
ORDER_CANCELLED_REQUEST: User requests cancellation.

State Transition Logic

The core of a state machine is its transition logic: Current State + Event = New State (and possibly an action).

For example:

If in ORDER_CREATED state and ORDER_PLACED event occurs, transition to PAYMENT_PENDING.
If in PAYMENT_PENDING state and PAYMENT_SUCCESS event occurs, transition to PAID.

This defines the predictable flow of your saga.

Code: Simple State Transition

Here's a simplified Java example demonstrating how states and events can drive transitions in an orchestrator.

Try running it to see the state changes!

public class SimpleSagaState {

    public enum SagaStepState {
        STARTED,
        PROCESSING_PAYMENT,
        PAYMENT_COMPLETE,
        FAILED
    }

    private SagaStepState currentState;

    public SimpleSagaState() {
        this.currentState = SagaStepState.STARTED;
    }

    public SagaStepState getCurrentState() {
        return currentState;
    }

    public void processEvent(String event) {
        System.out.println("Event: " + event);
        switch (currentState) {
            case STARTED:
                if ("OrderCreated".equals(event)) {
                    currentState = SagaStepState.PROCESSING_PAYMENT;
                }
                break;
            case PROCESSING_PAYMENT:
                if ("PaymentSuccess".equals(event)) {
                    currentState = SagaStepState.PAYMENT_COMPLETE;
                } else if ("PaymentFailed".equals(event)) {
                    currentState = SagaStepState.FAILED;
                }
                break;
            case PAYMENT_COMPLETE:
                // After payment, might go to shipping, etc.
                break;
            case FAILED:
                System.out.println("Saga already failed.");
                break;
        }
        System.out.println("New State: " + currentState);
    }

    public static void main(String[] args) {
        SimpleSagaState saga = new SimpleSagaState();
        System.out.println("Initial State: " + saga.getCurrentState());

        saga.processEvent("OrderCreated");
        saga.processEvent("PaymentSuccess");
        saga.processEvent("ShipmentInitiated"); // This event won't change state in this simplified example

        System.out.println("Final State: " + saga.getCurrentState());
    }
}

Compensation with States

One of the biggest advantages of using state machines for sagas is how they simplify compensation logic.

If a service fails, the orchestrator receives a 'failed' event. Based on the current state, the state machine can determine which compensation actions need to be triggered to reverse previous successful steps.

For example, if in PAID state and SHIPMENT_FAILED occurs, the state machine can transition to CANCELLED and trigger a refund.

State Transition Question

Consider an order saga using a state machine. The order is currently in the PAYMENT_PENDING state.

If the orchestrator receives a PAYMENT_FAILED event, what is the most appropriate next state for the saga, typically indicating compensation?

Réponds-y dans la leçon interactive

Recap: States for Orchestration

In this lesson, we explored how state machines are crucial for building robust saga orchestrators.

They provide a clear model for tracking saga progress.
States, Events, and Transitions define the saga's flow.
They simplify handling complex logic, especially for compensation.

By explicitly defining states and transitions, you create predictable and resilient distributed transactions.

Gratuit pour commencer

Apprends Microservices Communication Patterns (Saga, Circuit Breaker) avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 12
Leçons: 48

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Machines à états pour l’orchestration » est-elle gratuite ?

Oui — le texte complet de « Machines à états pour l’orchestration » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Microservices Communication Patterns (Saga, Circuit Breaker), passe à CoddyKit PRO. Le cours Microservices Communication Patterns (Saga, Circuit Breaker) comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Machines à états pour l’orchestration » ?

Appliquez les concepts de machine à états pour créer des orchestrateurs de sagas robustes et prévisibles qui suivent la progression des transactions. Tu pratiques Microservices Communication Patterns (Saga, Circuit Breaker) avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Microservices Communication Patterns (Saga, Circuit Breaker) ?

Aucune expérience préalable n'est requise. Microservices Communication Patterns (Saga, Circuit Breaker) sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Machines à états pour l’orchestration » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Microservices Communication Patterns (Saga, Circuit Breaker) ?

Oui. Chaque leçon Microservices Communication Patterns (Saga, Circuit Breaker) inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Conception d’orchestrateurs de sagas
Machines à états pour l’orchestration
Mise en œuvre avec un moteur de flux de travail
Tester les sagas orchestrées

← Retour à Microservices Communication Patterns (Saga, Circuit Breaker)