Gestione delle compensazioni con gli eventi
Implementi i passaggi di compensazione in una choreography saga pubblicando specifici eventi di rollback per annullare le azioni precedenti.
Gestione delle compensazioni con gli eventi è una lezione Microservices Communication Patterns (Saga, Circuit Breaker) gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Microservices Communication Patterns (Saga, Circuit Breaker), e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Microservices Communication Patterns (Saga, Circuit Breaker) include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
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.
Domande Frequenti
La lezione «Gestione delle compensazioni con gli eventi» è gratuita?
Sì — il testo completo di «Gestione delle compensazioni con gli eventi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Microservices Communication Patterns (Saga, Circuit Breaker), passa a CoddyKit PRO. Il corso Microservices Communication Patterns (Saga, Circuit Breaker) include 4 lezioni in totale.
Cosa imparerò in «Gestione delle compensazioni con gli eventi»?
Implementi i passaggi di compensazione in una choreography saga pubblicando specifici eventi di rollback per annullare le azioni precedenti. Eserciti Microservices Communication Patterns (Saga, Circuit Breaker) con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Microservices Communication Patterns (Saga, Circuit Breaker)?
Non è richiesta alcuna esperienza precedente. Microservices Communication Patterns (Saga, Circuit Breaker) su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Gestione delle compensazioni con gli eventi»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Microservices Communication Patterns (Saga, Circuit Breaker)?
Sì. Ogni lezione Microservices Communication Patterns (Saga, Circuit Breaker) include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Progettazione di Saga basate sugli eventi
- Event bus e broker di messaggi
- Gestione delle compensazioni con gli eventi
- Creare consumer di eventi idempotenti