Kafka ਵਿੱਚ exactly-once processing ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

**Exactly-once semantics (EOS)** ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਹਰੇਕ ਸੁਨੇਹਾ ਬਿਲਕੁਲ ਇਕ ਵਾਰ ਪ੍ਰਾਸੈੱਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ — ਕੋਈ ਨੁਕਸਾਨ ਨਹੀਂ, ਕੋਈ ਡੁਪਲੀਕੇਟ ਨਹੀਂ — ਭਾਵੇਂ ਅਸਫਲਤਾਵਾਂ ਅਤੇ ਮੁੜ-ਕੋਸ਼ਿਸ਼ਾਂ ਹੋਣ। Kafka ਇਹ **idempotent producers** ਅਤੇ **transactions** ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਗੁੰਝਲਦਾਰ ਹੈ ਅਤੇ ਓਵਰਹੈੱਡ ਰੱਖਦਾ ਹੈ।

## ਚਿਨੌਤੀ

```text
Exactly-once is HARD in distributed systems (failures, retries, duplicates are inevitable):
  → producer retries → duplicate messages; consumer reprocessing → duplicate effects
  → naive at-least-once → duplicates; at-most-once → loss
→ exactly-once requires careful mechanisms to avoid BOTH loss AND duplicates.
```

## Kafka ਕਿਵੇਂ exactly-once ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ

```text
1. IDEMPOTENT PRODUCER (enable.idempotence=true):
  → the producer dedupes retries (sequence numbers per partition) → producing the same
    message twice (due to a retry) results in ONE write (no duplicates from retries)
2. TRANSACTIONS:
  → group writes (and consumer offset commits) into an ATOMIC transaction → all succeed
    or all roll back
  → enables "consume-process-produce" atomically: read, process, write results + commit
    offsets together → exactly-once across the pipeline (within Kafka)
→ Kafka Streams uses these for end-to-end exactly-once processing
```

## ਸਕੋਪ ਅਤੇ ਵਪਾਰ-ਆਫ

```text
⚠️ Exactly-once is WITHIN KAFKA (consume-process-produce to Kafka):
  → EXTERNAL side effects (e.g. writing to an external DB, calling an API) aren't covered →
    still need idempotency for those
⚠️ Has OVERHEAD (transactions, coordination) → performance cost
→ often AT-LEAST-ONCE + idempotent processing is simpler and sufficient → use exactly-once
  when truly needed (duplicates unacceptable and idempotency hard)
```

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Kafka ਵਿੱਚ exactly-once processing ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ ਇਹ ਸਮਝਣਾ ਸੀਨੀਅਰ-ਲੈਵਲ ਦਾ ਮੁੱਲਵਾਨ ਗਿਆਨ ਹੈ ਕਿਉਂਕਿ **exactly-once ਇਕ ਮਹੱਤਵਪੂਰਨ ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਗਲਤ ਸਮਝਿਆ ਜਾਣ ਵਾਲਾ ਗ੍ਰੈਂਟੀ** ਹੈ, ਇਸ ਲਈ ਇਸ ਦੀ ਕਾਰਕੁਸ਼ਲਤਾ ਅਤੇ ਸੀਮਾਵਾਂ ਨੂੰ ਸਮਝਣਾ ਡੂੰਘੇ Kafka ਗਿਆਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

Exactly-once semantics (ਅਸਫਲਤਾਵਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਕੋਈ ਨੁਕਸਾਨ ਨਹੀਂ, ਕੋਈ ਡੁਪਲੀਕੇਟ ਨਹੀਂ) ਲੋੜੀਂਦਾ ਹੈ ਪਰ ਸੱਚਮੁੱਚ ਵਿਤਰਿਤ ਸਿਸਟਮਾਂ ਵਿੱਚ ਔਖਾ ਹੈ ਜਿੱਥੇ ਮੁੜ-ਕੋਸ਼ਿਸ਼ਾਂ ਅਤੇ ਡੁਪਲੀਕੇਟ ਅਟੱਲ ਹਨ, ਅਤੇ ਇਹ ਸਮਝਣਾ ਕਿ Kafka ਇਸਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ (ਅਤੇ ਇਸ ਦੀ ਸੀਮਾਵਾਂ) ਨਿਖੁੱਤ ਗਿਆਨ ਹੈ।

**ਚਿਨੌਤੀ** ਨੂੰ ਸਮਝਣਾ — ਕਿ exactly-once ਲਾਜ਼ਮੀ ਅਸਫਲਤਾਵਾਂ ਅਤੇ ਮੁੜ-ਕੋਸ਼ਿਸ਼ਾਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਨੁਕਸਾਨ ਅਤੇ ਡੁਪਲੀਕੇਟ ਦੋਵਾਂ ਤੋਂ ਬਚਣ ਦੀ ਲੋੜ ਹੈ — ਇਸ ਗੱਲ ਨੂੰ ਫ਼ੇਮ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਕਿਉਂ ਔਖਾ ਹੈ।

**Kafka ਇਸਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ** ਨੂੰ ਸਮਝਣਾ — **idempotent producers** (sequence numbers ਦੁਆਰਾ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਦੇ ਕਾਰਨ ਡੁਪਲੀਕੇਟ ਨਿਕਾਸ ਕਰਨਾ ਤਾਂ ਕਿ ਇਕ ਲਿਖਣ ਦਾ ਨਤੀਜਾ ਹੋਵੇ) ਅਤੇ **transactions** (ਲਿਖਣ ਅਤੇ offset commits ਨੂੰ ਪਰਮਾਣੂ ਰੂਪ ਵਿੱਚ ਗ੍ਰਪ ਕਰਨਾ,