Kafka में producers और consumers कैसे काम करते हैं?

Question

Accepted Answer

**Producers** events को Kafka topics में publish (लिखते) करते हैं, और **consumers** उनसे events को subscribe (पढ़ते) करते हैं। वे कैसे काम करते हैं यह समझना — partitioning, offsets और consumer groups सहित — Kafka का उपयोग करने के लिए मूलभूत है।

## Producers — events लिखना

```text
PRODUCERS publish events to TOPICS:
  → send a record (key, value) to a topic
  → the key determines the PARTITION (same key → same partition → ordering for that key);
    no key → distributed (round-robin)
  → can configure ACKNOWLEDGMENTS (acks) for durability (wait for replicas to confirm)
  → batching, compression for throughput
```

## Consumers — events पढ़ना

```text
CONSUMERS subscribe to topics and read events:
  → read from partitions, tracking their OFFSET (position) → resume from where they left off
  → read at their OWN PACE (events are retained); can re-read (replay) from any offset
  → COMMIT offsets to record progress (so they don't reprocess on restart)
```

## Consumer groups (scaling के लिए मुख्य)

```text
CONSUMER GROUP → consumers working together to consume a topic:
  → each partition is consumed by ONE consumer in the group → parallel processing
    (distribute partitions across the group's consumers)
  → add consumers (up to the partition count) to scale consumption
  → if a consumer fails, its partitions are REBALANCED to others (fault tolerance)
DIFFERENT GROUPS → each group reads ALL the events independently (pub/sub: many groups
  each get the full stream)
```

## यह क्यों महत्वपूर्ण है

Producers और consumers कैसे काम करते हैं यह समझना मूलभूत है क्योंकि वे ही **Kafka में data के अंदर और बाहर बहने का तरीका** हैं, इसलिए Kafka का उपयोग करने के लिए यह आवश्यक है।

Producers events लिखते हैं और consumers उन्हें पढ़ते हैं — बुनियादी data flow।

**Producers** को समझना — events को topics में publish करना, जहाँ **key partition निर्धारित करती है** (same key ordering के लिए same partition में जाती है, no key round-robin से distribute होती है), durability के लिए acknowledgments configure करना, और throughput के लिए batching — यह कवर करता है कि data Kafka में कैसे प्रवेश करता है।

**Consumers** को समझना — events पढ़ते समय अपने **offset** (position) को track करना ताकि वहाँ से resume करें जहाँ छोड़ा था, अपनी गति से पढ़ना क्योंकि events retained हैं, किसी भी offset से **replay** करने में सक्षम होना, और progress रिकॉर्ड करने के लिए offsets commit करना — यह कवर करता है कि data कैसे पढ़ा जाता है, Kafka की विशिष्ट replay क्षमता सहित।

सबसे महत्वपूर्ण, **consumer groups** को समझना Kafka के scaling model के लिए आवश्यक है: consumers एक साथ काम करते हैं जहाँ **प्रत्येक partition को group में एक consumer द्वारा consume किया जाता है** (parallel processing सक्षम करते हुए, partition count तक consumers जोड़कर scaling), यदि कोई consumer विफल हो जाए तो स्वचालित **rebalancing** (fault tolerance) के साथ, जबकि **विभिन्न consumer groups प्रत्येक सभी events को स्वतंत्र रूप से पढ़ते हैं** (pub/sub सक्षम करते हुए जहाँ कई groups प्रत्येक पूरी stream प्राप्त करते हैं)।

यह consumer-group model इसके लिए मूलभूत है कि Kafka कैसे consumption को scale करता है और queue-जैसे (एक group के भीतर) तथा pub/sub (groups के पार) दोनों patterns का समर्थन करता है।

चूँकि producers और consumers ही Kafka में data के अंदर और बाहर बहने का तरीका हैं, और चूँकि उनके कार्य — partitioning, offsets, replay, और विशेष रूप से consumer groups (scaling और queue/pub-sub द्वैत की कुंजी) — को समझना Kafka का उपयोग करने के लिए आवश्यक है, इसलिए producers और consumers कैसे काम करते हैं यह समझना आवश्यक, बुनियादी Kafka ज्ञान है — Kafka में data flow के लिए मूलभूत, consumer groups के साथ Kafka के scaling और consumption model को समझने के लिए विशेष रूप से महत्वपूर्ण, और Kafka का उपयोग करने वाले किसी भी व्यक्ति के लिए आवश्यक।