Saga pattern for distributed transactions in Kafka - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the Saga pattern in distributed transactions?

The Saga pattern breaks a large transaction into smaller steps, each with a compensating action to undo it if needed. It helps keep data consistent across services without locking resources.

intermediate

How does Kafka help implement the Saga pattern?

Kafka acts as a message broker to send events between services. Each service listens for events, performs its step, and publishes the next event or a compensation event if something fails.

beginner

What is a compensating transaction in the Saga pattern?

A compensating transaction is an action that reverses a previous step if the saga fails later. It helps undo partial changes to keep the system consistent.

intermediate

What are the two main types of Saga implementations?

1. Choreography: Services communicate by producing and consuming events without a central coordinator. 2. Orchestration: A central coordinator tells each service what to do next.

intermediate

Why is the Saga pattern preferred over distributed two-phase commit in microservices?

Saga avoids locking resources and long waits by using asynchronous steps and compensations. It scales better and fits microservices' independent nature.

What role does Kafka play in the Saga pattern?

A Message broker to pass events between services

B Database to store all transactions

C Load balancer for microservices

D Authentication service

Kafka is used as a message broker to send and receive events that coordinate saga steps.

What is a compensating transaction?

A A step that confirms the transaction

B An action that reverses a previous step if needed

C A database commit operation

D A service that starts the saga

Compensating transactions undo previous steps to maintain consistency if the saga fails.

Which Saga implementation uses a central coordinator?

A Two-phase commit

B Choreography

C Orchestration

D Event sourcing

Orchestration uses a central coordinator to direct saga steps.

Why is Saga pattern better than two-phase commit in microservices?

A It avoids resource locking and scales better

B It locks resources longer

C It uses synchronous calls only

D It requires a single database

Saga uses asynchronous steps and compensations, avoiding locks and fitting microservices.

In Saga, what triggers the next step in the transaction?

A A database trigger

B A manual user action

C A timer

D An event published to Kafka

Each service publishes an event to Kafka to trigger the next step.

Explain how the Saga pattern manages distributed transactions using Kafka.

Think about how services talk and undo work if needed.

Describe the advantages of using the Saga pattern over traditional two-phase commit in microservices.

Focus on why Saga suits distributed systems better.

Practice

1. What is the main purpose of the Saga pattern in distributed systems?

easy

A. To encrypt messages between microservices

B. To speed up database queries by caching results

C. To break a large transaction into smaller steps with compensations

D. To create backups of all data in real-time

Solution

1. Step 1: Understand the Saga pattern concept

   The Saga pattern divides a big transaction into smaller, manageable steps that can be undone if needed.

2. Step 2: Identify the main goal

   Its goal is to maintain data consistency across services without locking resources for a long time.

3. Final Answer:

   To break a large transaction into smaller steps with compensations -> Option C

4. Quick Check:

   Saga pattern = smaller steps with undo [OK]

Hint: Saga splits big tasks into small reversible steps [OK]

Common Mistakes:

• Confusing Saga with caching or encryption
• Thinking Saga creates backups
• Assuming Saga speeds up queries

2. Which Kafka feature is most important for implementing the Saga pattern?

easy

A. Kafka Streams for data encryption

B. Kafka Consumer groups for load balancing

C. Kafka Connect for database backups

D. Kafka topics for event communication

Solution

1. Step 1: Identify Kafka components used in Saga

   Saga relies on events to coordinate steps, so Kafka topics are used to send these events.

2. Step 2: Exclude unrelated Kafka features

   Encryption, backups, and load balancing are not the main focus for Saga coordination.

3. Final Answer:

   Kafka topics for event communication -> Option D

4. Quick Check:

   Kafka topics = event communication [OK]

Hint: Saga uses Kafka topics to send events between services [OK]

Common Mistakes:

• Confusing Kafka Streams with event messaging
• Thinking Kafka Connect handles Saga coordination
• Mixing consumer groups with transaction steps

3. Given a Saga with three steps: A, B, and C, where each step publishes an event to Kafka, what happens if step B fails after step A succeeds?

medium

A. Step A is compensated by sending a rollback event

B. Step C executes anyway to complete the transaction

C. The entire Saga is aborted without compensation

D. Step B retries indefinitely without affecting others

Solution

1. Step 1: Understand failure handling in Saga

   If a step fails, previous successful steps must be undone using compensating actions.

2. Step 2: Apply to the scenario

   Since step B failed after A succeeded, step A must be compensated by sending a rollback event.

3. Final Answer:

   Step A is compensated by sending a rollback event -> Option A

4. Quick Check:

   Failure in step B triggers compensation for step A [OK]

Hint: Failed step triggers compensation for prior steps [OK]

Common Mistakes:

• Assuming next steps run despite failure
• Thinking Saga aborts without compensation
• Believing retries never stop

4. A developer implemented a Saga using Kafka but notices that compensating events are not triggered on failure. What is the most likely cause?

medium

A. The service does not listen to failure events to trigger compensation

B. Kafka topics are not partitioned correctly

C. Kafka consumer group ID is missing

D. Kafka brokers are overloaded

Solution

1. Step 1: Identify compensation trigger mechanism

   Compensation happens when a service listens for failure events and reacts by sending rollback events.

2. Step 2: Analyze the problem

   If compensations are missing, likely the service is not listening or handling failure events properly.

3. Final Answer:

   The service does not listen to failure events to trigger compensation -> Option A

4. Quick Check:

   Missing compensation = no failure event listener [OK]

Hint: Compensation needs failure event listeners active [OK]

Common Mistakes:

• Blaming Kafka partitions for compensation logic
• Confusing consumer group ID with compensation triggers
• Assuming broker overload causes missing compensations

5. You design a Saga with multiple microservices communicating via Kafka. To ensure scalability and fault tolerance, which approach is best?

hard

A. Store Saga state only in a centralized database without event logs

B. Use separate Kafka topics per Saga step and implement idempotent consumers

C. Use a single Kafka topic for all Saga events without consumer groups

D. Send synchronous HTTP calls between services instead of Kafka events

Solution

1. Step 1: Consider scalability and fault tolerance needs

   Separate topics per step allow independent scaling and isolation of events.

2. Step 2: Ensure idempotency in consumers

   Idempotent consumers prevent duplicate processing on retries, improving fault tolerance.

3. Step 3: Evaluate other options

   Single topic without consumer groups limits scalability; centralized DB without events loses Saga benefits; synchronous calls reduce fault tolerance.

4. Final Answer:

   Use separate Kafka topics per Saga step and implement idempotent consumers -> Option B

5. Quick Check:

   Separate topics + idempotent consumers = scalable Saga [OK]

Hint: Separate topics and idempotent consumers scale Saga well [OK]

Common Mistakes:

• Using one topic for all events limits scaling
• Ignoring idempotency causes duplicate side effects
• Relying on synchronous calls reduces fault tolerance