Saga pattern for distributed transactions in RabbitMQ - Step-by-Step Execution

Process Flow - Saga pattern for distributed transactions

Start Transaction

↓

Execute Step 1

↓

Publish Event 1

↓

Execute Step 2

↓

Publish Event 2

↓

Check Success?

No→Execute Compensating Step 1

↓

Publish Compensate 1

↓

Execute Step 3

↓

Publish Event 3

↓

End Transaction

The saga pattern breaks a big transaction into steps. Each step publishes an event. If a step fails, compensating steps undo previous work.

Execution Sample

RabbitMQ

Step 1: Reserve inventory
Publish: inventory_reserved
Step 2: Charge payment
Publish: payment_charged
Step 3: Confirm order
Publish: order_confirmed

This sequence shows a saga with three steps, each publishing an event to RabbitMQ to trigger the next step.

Process Table

Step	Action	Event Published	Next Step Triggered	Compensation Triggered
1	Reserve inventory	inventory_reserved	Step 2: Charge payment	No
2	Charge payment	payment_charged	Step 3: Confirm order	No
3	Confirm order	order_confirmed	Transaction complete	No
Error at Step 2	Charge payment fails	payment_failed	No	Step 1: Release inventory

💡 Transaction ends after Step 3 success or after compensation if failure occurs

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Compensation
Inventory Reserved	False	True	True	True	False
Payment Charged	False	False	False	True	False
Order Confirmed	False	False	False	True	False

Key Moments - 2 Insights

Why do we need compensating steps in the saga pattern?

Because each step is independent, if a later step fails, compensating steps undo previous successful steps to keep data consistent, as shown in the error row of the execution table.

How does RabbitMQ help in the saga pattern?

RabbitMQ passes events between steps, triggering the next step or compensation, as seen in the 'Event Published' and 'Next Step Triggered' columns.

Visual Quiz - 3 Questions

Look at the execution table, what event is published after successfully reserving inventory?

A payment_charged

B inventory_reserved

C order_confirmed

D payment_failed

💡 Hint

Check the 'Event Published' column at Step 1 in the execution table.

At which step does the saga pattern trigger compensation if a failure occurs?

A After Step 1

B After Step 3

C At Step 2 failure

D No compensation is triggered

💡 Hint

Look at the 'Compensation Triggered' column in the error row of the execution table.

If the payment step succeeds, what is the state of 'Payment Charged' after Step 3?

A False

B True

C Unknown

D Reverted

💡 Hint

Refer to the variable_tracker row for 'Payment Charged' after Step 3.

Concept Snapshot

Saga pattern breaks a big transaction into steps.
Each step publishes an event to RabbitMQ.
Next step triggers on event reception.
If a step fails, compensating steps undo prior steps.
This keeps distributed data consistent without locking.

Full Transcript

The saga pattern manages distributed transactions by splitting them into smaller steps. Each step performs an action and publishes an event to RabbitMQ. The next step listens for this event and runs. If any step fails, compensating steps run to undo previous successful steps, ensuring data consistency. This pattern avoids locking resources across services. The execution table shows the flow: Step 1 reserves inventory and publishes 'inventory_reserved'. Step 2 charges payment and publishes 'payment_charged'. Step 3 confirms the order and publishes 'order_confirmed'. If Step 2 fails, a compensation step releases the reserved inventory. Variables track the state of each step's success. RabbitMQ acts as the message broker passing events between steps.