Gestion de la compensation par les événements
Mettez en œuvre les étapes de compensation d’une saga par chorégraphie en publiant des événements d’annulation spécifiques pour inverser les actions précédentes.
Gestion de la compensation par les événements est une leçon Microservices Communication Patterns (Saga, Circuit Breaker) gratuite sur CoddyKit. Ceci est la leçon 3 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.
Why Compensation is Crucial
In choreography sagas, services react to events. But what happens when one of those services fails to complete its part of a distributed transaction?
We need a way to undo any actions that were successfully performed by previous services. This is where compensation comes in.
What is Compensation?
Compensation is the process of reversing previously completed operations within a distributed transaction. Think of it as a 'rollback' mechanism tailored for microservices.
It ensures that if any step in a multi-service business process fails, the system can return to a consistent state.
Compensation in Choreography
In a choreography saga, there's no central orchestrator. Services communicate directly via events. So, how do we trigger compensation?
- When a service fails to complete its task, it publishes a specific compensation event.
- Other services that have successfully completed their part listen for these compensation events.
- Upon receiving a compensation event, they execute their own rollback logic.
Designing Compensation Events
Compensation events must contain enough information for services to perform their rollback. Key details often include:
- The original saga ID or transaction ID.
- Details about the original action that needs to be reversed.
- Any data required to perform the reversal (e.g., amount to refund, item to unreserve).
Example: Order Processing Saga
Consider an online order process:
- Order Service: Creates order (publishes
OrderCreated) - Payment Service: Processes payment (publishes
PaymentProcessed) - Inventory Service: Reserves stock (publishes
InventoryReserved)
What if the Inventory Service fails to reserve stock?
Initiating the Rollback
If the Inventory Service fails to reserve stock, it should:
- Not publish
InventoryReserved. - Instead, publish a compensation event, like
InventoryReservationFailed.
This event signals to other services that the saga could not complete successfully and they need to undo their actions.
Payment Service's Compensation
The Payment Service is subscribed to events that indicate failures. When it receives InventoryReservationFailed, it knows it needs to act:
- It will initiate a refund for the payment it previously processed.
- After refunding, it might publish a new event, like
PaymentRefunded, to inform other interested services.
Order Service's Compensation
The Order Service, having created the initial order, also needs to react. It might listen for InventoryReservationFailed or PaymentRefunded.
- Upon receiving such an event, the Order Service updates the order's status to 'Cancelled' or 'Failed'.
- This ensures the user sees an accurate status for their order.
Implementing Compensation Logic
Each service must contain logic to handle both successful forward-progress events and specific compensation events. This often means having separate event handlers for each.
Here's a simplified example of how a Payment Service might listen for a compensation event and trigger a refund:
public class PaymentService {
public static void main(String[] args) {
System.out.println("Payment Service Started.");
// Simulate receiving an event from a message broker
String receivedEvent = "InventoryReservationFailed: Order123";
if (receivedEvent.startsWith("InventoryReservationFailed")) {
String orderId = receivedEvent.split(":")[1];
System.out.println("Received compensation event: " + receivedEvent);
System.out.println("Initiating refund for Order ID: " + orderId + "...");
// In a real system, call a payment gateway API to refund
boolean refundSuccess = processRefund(orderId);
if (refundSuccess) {
System.out.println("Refund processed successfully for " + orderId + ".");
// Publish 'PaymentRefunded' event for other services
System.out.println("Publishing PaymentRefunded event.");
} else {
System.out.println("Refund failed for " + orderId + ".");
// Handle refund failure (e.g., alert, manual intervention)
}
} else {
System.out.println("No compensation event received yet.");
}
System.out.println("Payment Service Shutting Down.");
}
private static boolean processRefund(String orderId) {
// Simulate external refund API call
return true; // Assume success for this example
}
}Quick Check: Compensation Purpose
In a choreography saga, if the 'Inventory Service' fails to reserve items after 'Payment Service' has processed a payment, what is the primary purpose of the 'Inventory Service' publishing an InventoryReservationFailed event?
Recap: Handling Compensation
You've learned how critical compensation is in choreography sagas to maintain data consistency in distributed systems. Key takeaways:
- Compensation reverses successful actions when a saga step fails.
- In choreography, services publish specific compensation events to initiate rollbacks.
- Each service must implement logic to listen for and react to these events, performing its own undo operations.
- Clear event design and robust handling are essential for resilient sagas.
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
Questions Fréquemment Posées
La leçon « Gestion de la compensation par les événements » est-elle gratuite ?
Oui — le texte complet de « Gestion de la compensation par les événements » 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 « Gestion de la compensation par les événements » ?
Mettez en œuvre les étapes de compensation d’une saga par chorégraphie en publiant des événements d’annulation spécifiques pour inverser les actions précédentes. 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 3 sur 4.
Combien de temps prend la leçon « Gestion de la compensation par les événements » ?
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 de sagas pilotées par les événements
- Bus d’événements et courtiers de messages
- Gestion de la compensation par les événements
- Créer des consommateurs d’événements idempotents