RabbitMQ में आप messages कैसे produce और consume करते हैं (basic usage)?

Question

Accepted Answer

Basic RabbitMQ usage में messages को एक exchange/queue पर **publish** करना और उन्हें **consume** करना शामिल है — आमतौर पर एक client library के माध्यम से (AMQP protocol का उपयोग करते हुए)। basic produce/consume flow को समझना व्यावहारिक प्रवेश बिंदु है।

## messages produce (publish) करना

```js
// connect, create a channel, declare a queue, publish
const channel = await connection.createChannel();
await channel.assertQueue('tasks', { durable: true });   // ensure the queue exists
channel.sendToQueue('tasks',
  Buffer.from(JSON.stringify({ task: 'send-email' })),
  { persistent: true }                                    // persistent message (survives restart)
);
// → publishes a message (here directly to a queue via the default exchange)
```

## messages consume करना

```js
await channel.assertQueue('tasks', { durable: true });
channel.prefetch(1);   // process one at a time (fair dispatch)
channel.consume('tasks', (msg) => {
  const data = JSON.parse(msg.content.toString());
  // process the task...
  channel.ack(msg);     // ACKNOWLEDGE after processing (reliable)
}, { noAck: false });   // manual acks (reliable)
```

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

```text
✓ Use a CLIENT LIBRARY (amqplib for Node, pika for Python, Java client, etc.)
✓ CHANNELS → lightweight connections for operations (reuse the connection, use channels)
✓ DURABLE queues + PERSISTENT messages → survive broker restart (durability)
✓ MANUAL acks → reliable processing; PREFETCH → fair work distribution
✓ Handle errors, reconnection; use exchanges/bindings for routing (beyond the default exchange)
```

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

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

messages को publish और consume करना जानना applications में RabbitMQ का उपयोग करने के लिए बुनियादी कौशल है।

**messages produce करना** को समझना — connect करना, एक channel बनाना, एक queue declare करना, और messages publish करना (durability के लिए persistence के साथ) — basic write operation है।

**messages consume करना** को समझना — queue declare करना, prefetch सेट करना, messages consume करना, उन्हें process करना, और processing के बाद **acknowledge करना** (reliability के लिए manual acks के साथ) — basic read operation है जिसमें महत्वपूर्ण reliability प्रथाएँ शामिल हैं।

**प्रमुख व्यावहारिक बिंदुओं** को समझना — एक client library (amqplib, pika, आदि) का उपयोग करना, **channels** का उपयोग करना (operations के लिए lightweight connections, connection को reuse करना), restart से बचने के लिए **durable queues plus persistent messages**, reliable processing के लिए **manual acks** और fair work distribution के लिए **prefetch**, और errors/reconnection को संभालना और routing के लिए exchanges/bindings का उपयोग करना — वास्तविक RabbitMQ usage के लिए व्यावहारिक विचारों को दर्शाता है।

ये व्यावहारिक बिंदु (channels, durability, manual acks, prefetch) conceptual ज्ञान (queues, acknowledgments, durability) को वास्तविक code से जोड़ते हैं और reliable RabbitMQ applications बनाने को दर्शाते हैं।

चूँकि messages को produce और consume करना applications में RabbitMQ का उपयोग करने के लिए बुनियादी व्यावहारिक कौशल है, और चूँकि basic flow और व्यावहारिक बिंदुओं (channels, durability, manual acks, prefetch) को समझना आवश्यक hands-on ज्ञान है, basic RabbitMQ produce/consume usage को समझना मूल्यवान और व्यावहारिक रूप से प्रासंगिक ज्ञान है — RabbitMQ का उपयोग करने का व्यावहारिक प्रवेश बिंदु, concepts को code से जोड़ते हुए (durable queues, persistent messages, और manual acks की reliability प्रथाओं के साथ), और RabbitMQ के साथ वास्तव में applications बनाने वाले किसी भी व्यक्ति के लिए आवश्यक।