როგორ აწარმოებთ და მოიხმარებთ შეტყობინებებს 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-ის გამოყენების პრაქტიკული შესვლის წერტილი**, ამიტომ აუცილებელია პრაქტიკული ცოდნა.

იმის ცოდნა, თუ როგორ გამოქვეყნოთ და მოიხმაროთ შეტყობინებები, RabbitMQ-ის გამოყენების ფუნდამენტური უნარია აპლიკაციებში.

**შეტყობინებების აწარმოების** გაგება — დაკავშირება, channel-ის შექმნა, queue-ის დეკლარირება და შეტყობინებების გამოქვეყნება (მდგრადობისთვის persistence-ით) — არის ძირითადი write ოპერაცია.

**შეტყობინებების მოხმარების** გაგება — queue-ის დეკლარირება, prefetch-ის დაყენება, შეტყობინებების მოხმარება, მათი დამუშავება და დამუშავების შემდეგ **acknowledgment** — არის ძირითადი read ოპერაცია, რომელიც მოიცავს სანდოობის მნიშვნელოვან პრაქტიკებს.

**ძირითადი პრაქტიკული პუნქტების** გაგება — კლიენტის ბიბლიოთეკის გამოყენება (amqplib, pika და სხვა), **channel-ების** გამოყენება (ოპერაციებისთვის მელი კავშირები, კავშირის ხელახლა გამოყენება), **მდგრადი queue-ები პლუს მდგრადი შეტყობინებები** რეზიუმირებისათვის, **manual ack-ები** საიმედო დამუშავებისა და **prefetch** სამუშაოს თანაბარი განაწილებისთვის, და შეცდომების/რეკონექტის დამუშავება და exchange-ები/bindings-ების გამოყენება მარშრუტიზაციისთვის — ასახავს RabbitMQ-ის რეალური გამოყენების პრაქტიკული გათვალისწინებებს.

ეს პრაქტიკული პუნქტები (channel-ები, durability, manual ack-ები, prefetch) აკავშირებენ კონცეპტუალურ ცოდნას (queue-ები, acknowledgment-ები, durability) რეალურ კოდთან და ასახავენ საიმედო RabbitMQ აპლიკაციების აგებას.

მას შემდეგ, რაც შეტყობინებების აწარმოება და მოხმარება არის RabbitMQ-ის აპლიკაციებში გამოყენების ფუნდამენტური პრაქტიკული უნარი, და რადგან ძირითადი ნაკადის და პრაქტიკული პუნქტების გაგება (channel-ები, durability, manual ack-ები, prefetch) აუცილებელი ხელით შეძენილი ცოდნაა, RabbitMQ-ის ძირითადი produce/consume გამოყენების გაგება ღირებული, პრაქტიკულად შესაბამისი ცოდნაა — პრაქტიკული შესვლის წერტილი RabbitMQ-ის გამოყენებაში, კონცეპციების კოდთან დაკავშირება (სანდოობის პრაქტიკებით მდგრადი queue-ებისა და მდგრადი შეტყობინებებისა და manual ack-ების), და აუცილებელი ყველასთვის, ვინც რეალურად აშენებს აპლიკაციებს RabbitMQ-ით.