Kafka में messages को produce और consume कैसे करते हैं (बुनियादी उपयोग)?

Question

Accepted Answer

बुनियादी Kafka उपयोग में messages को एक topic में **produce करना** और उन्हें **consume करना** शामिल है — आमतौर पर एक client library (Java, Python आदि) के माध्यम से। बुनियादी produce/consume flow को समझना Kafka का उपयोग करने का व्यावहारिक प्रवेश बिंदु है।

## Messages produce करना

```js
// using a Kafka client (e.g. KafkaJS for Node)
const producer = kafka.producer();
await producer.connect();
await producer.send({
  topic: 'orders',
  messages: [
    { key: 'user-123', value: JSON.stringify({ orderId: 1, amount: 100 }) },
    // key determines the partition (same key → same partition → ordering)
  ],
});
// → publishes the message to the 'orders' topic
```

## Messages consume करना

```js
const consumer = kafka.consumer({ groupId: 'order-processors' });   // a consumer GROUP
await consumer.connect();
await consumer.subscribe({ topic: 'orders', fromBeginning: false });
await consumer.run({
  eachMessage: async ({ topic, partition, message }) => {
    const data = JSON.parse(message.value.toString());
    // process the message...
    // offset is auto-committed (or commit manually for control)
  },
});
```

## मुख्य व्यावहारिक बिंदु

```text
✓ Use a client LIBRARY for your language (Java, KafkaJS, confluent-kafka-python, etc.)
✓ Producers: set a KEY for ordering/partitioning; configure acks for durability
✓ Consumers: use a GROUP ID; the group distributes partitions; commit offsets
✓ Handle SERIALIZATION (JSON, Avro, Protobuf) — often a schema registry for structured data
✓ Handle errors, retries; process idempotently (at-least-once → possible duplicates)
```

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

बुनियादी produce/consume उपयोग को समझना मूल्यवान है क्योंकि यह **Kafka का उपयोग करने का व्यावहारिक प्रवेश बिंदु** है, इसलिए यह Kafka के साथ काम करने के लिए आवश्यक हाथों-हाथ ज्ञान है।

Messages को produce और consume करना जानना applications में Kafka का उपयोग करने के लिए मूलभूत कौशल है।

**Messages produce करना** को समझना — एक producer connect करना और records (key, value) को एक topic में भेजना, जहाँ **key partitioning और ordering निर्धारित करती है** — बुनियादी write operation है।

**Messages consume करना** को समझना — एक **group ID** के साथ एक consumer connect करना, एक topic को subscribe करना, और messages को process करना (offsets स्वचालित या manually committed होने के साथ) — बुनियादी read operation है, consumer group ही वह तरीका है जिससे consumption scale करती है।

**मुख्य व्यावहारिक बिंदुओं** को समझना — अपनी भाषा के लिए एक client library का उपयोग करना (Java, KafkaJS, Python आदि), producers पर ordering के लिए keys सेट करना और durability के लिए acks configure करना, consumers पर group IDs का उपयोग करना और offsets commit करना, **serialization** को संभालना (JSON, Avro, Protobuf, अक्सर structured data के लिए एक schema registry के साथ), और errors, retries तथा **idempotent processing** को संभालना (चूँकि at-least-once delivery का अर्थ संभावित duplicates है) — वास्तविक Kafka उपयोग के लिए व्यावहारिक विचारों को दर्शाता है।

ये व्यावहारिक बिंदु (keys, groups, serialization, idempotency) वैचारिक ज्ञान (partitions, consumer groups, delivery semantics) को वास्तविक code से जोड़ते हैं।

चूँकि messages को produce और consume करना applications में Kafka का उपयोग करने के लिए मूलभूत व्यावहारिक कौशल है, और चूँकि बुनियादी flow तथा व्यावहारिक बिंदुओं (keys, groups, serialization, idempotency) को समझना आवश्यक हाथों-हाथ ज्ञान है, इसलिए बुनियादी Kafka produce/consume उपयोग को समझना मूल्यवान, व्यावहारिक रूप से प्रासंगिक ज्ञान है — Kafka का उपयोग करने का व्यावहारिक प्रवेश बिंदु, अवधारणाओं को code से जोड़ना, और Kafka के साथ वास्तव में applications बनाने वाले किसी भी व्यक्ति के लिए आवश्यक।