RabbitMQ-ல் செய்திகளை எவ்வாறு உற்பத்தி செய்து நுகர்கிறீர்கள் (அடிப்படை பயன்பாடு)?

Question

Accepted Answer

RabbitMQ-ன் அடிப்படை பயன்பாடு **exchange/queue-க்கு செய்திகளை வெளியிடுதல்** மற்றும் அவற்றை **நுகர்தல்** ஆகியவை அடங்கும் — பொதுவாக ক்লায়েண்ட் லைब்ரரி மூலம் (AMQP நெறிமுறையைப் பயன்படுத்தி). அடிப்படை produce/consume பாய்வைப் புரிந்துகொள்வது நடைமுறை நுழைவுப் புள்ளியாகும்.

## செய்திகளை உற்பத்தி செய்தல் (வெளியிடுதல்)

```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)
```

## செய்திகளை நுகர்தல்

```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)
```

## ஏன் இது முக்கியமாக உள்ளது

अடிப்படை produce/consume பயன்பாட்டைப் புரிந்துகொள்வது மূல்யமானது ஏனெனில் இது **RabbitMQ-ஐ பயன்படுத்துவதற்கான நடைமுறை நுழைவுப் புள்ளி**, எனவே இது தேவையான hands-on அறிவு.

செய்திகளை வெளியிடுவது மற்றும் நுகர்வது RabbitMQ-ஐ பயன்படுத்துவதற்கான அடிப்படை திறமை.

**செய்திகளை உற்பத்தி செய்வதைப் புரிந்துகொள்வது** — இணைப்பு, channel உருவாக்குதல், queue அறிவிப்பு, மற்றும் செய்திகளை வெளியிடுதல் (நிலைத்தன்மைக்கான persistence உடன்) — அடிப்படை write operation ஆகும்.

**செய்திகளை நுகர்வதைப் புரிந்துகொள்வது** — queue அறிவிப்பு, prefetch அமைப்பு, செய்திகளை நுகர்தல், அவற்றை செயலாக்குதல், மற்றும் செயலாக்கத்திற்குப் பின் **acknowledgement** செய்தல் (நம்பகத்தன்மைக்கான manual acks) — reliability practices சம்மிலிত அடிப்படை read operation ஆகும்.

**முக்கிய நடைமுறை புள்ளிகளைப் புரிந்துகொள்வது** — ক்লையண்ட் லைब்ரரி பயன்படுத்துதல் (amqplib, pika, முதலியன), **channels** பயன்படுத்துதல் (operations க்கான lightweight connections, connection ஐ reuse செய்தல்), **durable queues மற்றும் persistent messages** restarts-ஐ உயிர்வாழ்வதற்கு, reliable processing க்கான **manual acks** மற்றும் fair work distribution க்கான **prefetch**, மற்றும் errors/reconnection ஐ கையாளுதல் மற்றும் routing க்காக exchanges/bindings பயன்படுத்துதல் — RabbitMQ-ன் நடைமுறை பயன்பாட்டிற்கான நடைமுறை கருதுகோள்களை பிரதிபலிக்கிறது.

இந்த நடைமுறை புள்ளிகள் (channels, durability, manual acks, prefetch) conceptual அறிவு (queues, acknowledgments, durability) ஐ actual code க்குடன் இணைக்கிறது மற்றும் நம்பகமான RabbitMQ applications கட்டுவதை பிரதிபலிக்கிறது.

செய்திகளை வெளியிடுவது மற்றும் நுகர்வது RabbitMQ ஐ applications-ல் பயன்படுத்துவதற்கான அடிப்படை நடைமுறை திறமை என்பதால், மற்றும் அடிப்படை பாய்வு மற்றும் நடைமுறை புள்ளிகள் (channels, durability, manual acks, prefetch) ஐப் புரிந்துகொள்வது தேவையான hands-on அறிவு என்பதால், RabbitMQ produce/consume பயன்பாட்டைப் புரிந்துகொள்வது மூல்யமான, practically-relevant அறிவு — RabbitMQ பயன்படுத்துவதற்கான நடைமுறை நுழைவுப் புள்ளி, concepts ஐ code-ஆக இணைப்பது (durable queues, persistent messages, மற்றும் manual acks-ன் reliability practices உடன்), மற்றும் RabbitMQ உடன் applications கட்டுபவர்களுக்கு தேவையான.