Garantie de l’idempotence dans les sagas

In distributed systems, idempotency is a crucial concept. An operation is idempotent if executing it multiple times produces the same result as executing it once.

• Think of it like pressing a light switch: pressing it once turns it on (or off). Pressing it again doesn't change the state further if it's already on (or off).
• This is vital because messages can be duplicated or retried.

When services communicate, especially asynchronously via message brokers, messages can sometimes be delivered more than once. This is known as "at-least-once" delivery.

• Network issues: A service might send a response, but the sender doesn't receive it, leading to a retry.
• Service failures: A service crashes after processing a message but before acknowledging it, so the message is redelivered.
• Without idempotency, these duplicates can cause unintended side effects, like double-charging a customer or creating duplicate orders.

The Saga pattern orchestrates complex business transactions across multiple services. Each step in a saga is an operation performed by a service.

• If a saga step receives the same command or event twice, it could lead to inconsistent data.
• For example, if a "deduct payment" command is processed twice, a customer's account could be overcharged.
• Idempotency ensures that even if a saga participant receives a message multiple times, the overall business transaction remains correct.

To achieve idempotency, we often use an idempotency key. This is a unique identifier associated with a specific operation or request.

• The key is typically generated by the client or the initiating service and passed along with the request.
• It allows the receiving service to detect if it has already processed this exact operation.
• Commonly, this could be a UUID (Universally Unique Identifier) or a unique transaction ID.

A common approach to implementing idempotency is the "check-then-act" pattern. Before performing an action, the service checks if the operation associated with the idempotency key has already been completed.

Here's the basic logic:

1. Receive a request with an idempotency key.
2. Check if this key is already marked as processed.
3. If processed, return the original result (or success) without re-executing.
4. If not processed, execute the operation and then mark the key as processed.

Let's look at a conceptual Java example for an idempotent payment processing method. We'll use a simple in-memory set to track processed keys, though a real system would use a persistent store.

Try running this example:

For operations that involve database writes, you can often use database features to help enforce idempotency:

• Unique Constraints: Add a unique constraint on the idempotency key column (e.g., request_id) in your table. If a duplicate key is inserted, the database will throw an error.
• Conditional Updates (UPSERT): Use commands like INSERT ... ON CONFLICT DO NOTHING (PostgreSQL) or INSERT ... ON DUPLICATE KEY UPDATE (MySQL) to prevent inserting duplicates or to update only if a record exists.

Consider creating an order. We want to ensure that if the same "create order" request is sent twice, only one order is created.

Using a unique request_id:

-- SQL example (conceptual)
INSERT INTO orders (order_id, customer_id, amount, request_id, status)
VALUES ('ORD001', 'CUST123', 100.00, 'req-uuid-123', 'PENDING')
ON CONFLICT (request_id) DO NOTHING;

This statement will insert the order if req-uuid-123 is new. If it already exists, the database ignores the insert, ensuring idempotency.

Idempotency isn't just for forward-moving saga steps; it's equally important for compensation actions.

• If a compensation request (e.g., "refund payment") is sent multiple times due to retries, you wouldn't want to issue multiple refunds.
• Apply the same idempotency principles: use a unique key for the compensation request and check if it has already been processed before executing.
• This ensures that the system correctly reverses the original action only once.

To effectively implement idempotency in your sagas:

• Use Robust Unique Keys: Generate truly unique, non-guessable IDs (like UUIDs) for each operation.
• Store Processed Keys Persistently: Don't rely on in-memory storage. Use a database or a dedicated cache for tracking processed keys.
• Handle Concurrency: Ensure your check-then-act logic is atomic to prevent race conditions where two identical requests are processed simultaneously. Database unique constraints are excellent for this.
• Define Scope: Clearly define what constitutes an "idempotent operation" and at what level the key applies (e.g., per message, per business transaction).

A microservice receives a "charge customer" message with an idempotency key. Due to network issues, the message is delivered twice. If the service correctly implements idempotency, what will happen?

We've learned that idempotency is critical for building robust distributed systems, especially when implementing the Saga pattern.

• It ensures that an operation, when executed multiple times, yields the same result as executing it once.
• This prevents unintended side effects from duplicate messages or retries, which are common in distributed environments.
• By using idempotency keys and patterns like "check-then-act" or database unique constraints, saga participants can safely process messages, maintaining data consistency.