როგორ მუშაობენ რიგები RabbitMQ-ში?

Question

Accepted Answer

**რიგები** RabbitMQ-ში ინახავენ შეტყობინებებს სანამ მომხმარებლები მათ დაამუშავებენ — მოქმედებენ როგორც ბუფერი მწარმოებელსა და მომხმარებელს შორის. მნიშვნელოვანია რიგის თვისებების გაგება (მდგრადობა, დადასტურებები და ა.შ.) საიმედო მესიჯინგისთვის.

## რა აკეთებენ რიგები

```text
A QUEUE holds messages until a consumer takes them:
  → messages wait in the queue (a buffer) → decouples producer speed from consumer speed
  → consumers receive messages (push or pull), process them, and ACKNOWLEDGE
  → roughly FIFO (first-in, first-out) order
→ the buffer between producers and consumers (absorbs load, enables async)
```

## რიგის მთავარი თვისებები

```text
DURABLE → the queue survives a broker RESTART (the queue definition persists)
  (+ PERSISTENT messages → messages also survive restart → durability)
EXCLUSIVE → used by only one connection; deleted when that connection closes
AUTO-DELETE → deleted when the last consumer disconnects
TTL → messages (or the queue) can expire after a time
MAX LENGTH → limit queue size (drop/overflow when full)
→ configure based on durability and lifecycle needs
```

## მოხმარება და დადასტურებები

```text
✓ Consumers ACKNOWLEDGE messages → tells RabbitMQ the message was processed (then it's
  removed); if not acked (consumer dies) → REQUEUED/redelivered (no loss)
✓ Multiple consumers on a queue → messages DISTRIBUTED among them (competing consumers →
  load balancing/parallel processing)
✓ PREFETCH → limit unacknowledged messages per consumer (fair distribution)
```

## რატომ არის მნიშვნელოვანი

ქვესმის, როგორ მუშაობენ რიგები, ფუნდამენტური है, რადგან **რიგები RabbitMQ-ის ცენტრალური ნაწილია** (შეტყობინებების დაკავება და მიწოდება), ამიტომ მათი და მათი თვისებების გაგება აუცილებელია საიმედო მესიჯინგისთვის.

რიგები არის მთავარი მექანიზმი, სადაც შეტყობინებები ელოდება.

ქვესმის **რა აკეთებენ რიგები** — ინახავენ შეტყობინებებს სანამ მომხმარებლები მათ აიღებენ (ბუფერი, რომელიც განაცალკევებს მწარმოებელსა და მომხმარებელს სიჩქარის თვალსაზრისით, ითავსებს დატვირთვას და ხელმისაწვდომს აკეთებს ასინქრონულ დამუშავებას, დაახლოებით FIFO) — აღკვეთს მათი ფუნდამენტური როლის გაგებას.

ქვესმის **რიგის მთავარი თვისებები** — **მდგრადი** (რიგი, რომელიც გადარჩება ბროკერის გადატვირთვის შემდეგ, **მდგრადი შეტყობინებებთან** ერთად ისე რომ შეტყობინებებიც გადარჩებიან, უზრუნველყოფენ მდგრადობას), ექსკლუზიური, ავტო-დელეტი, TTL (შეტყობინების/რიგის ვადის გასვლა) და მაქსიმალური სიგრძე — მნიშვნელოვანია რიგების კონფიგურირებისთვის სწორი მდგრადობის და ცხოვრების ციკლის აღმოსავლელი, მდგრადობა (მდგრადი რიგები + მდგრადი შეტყობინებები) განსაკუთრებით მნიშვნელოვანია შეტყობინებების დაკარგვის თავიდან აცილებისთვის გადატვირთვის შემდეგ.

ქვესმის **მოხმარება და დადასტურებები** გადამწყვეტია: მომხმარებლები **აღიარებენ შეტყობინებებს** (ეუბნებიან RabbitMQ-ს, რომ შეტყობინება დამუშავდა ისე რომ ის მოიხსნა, უაღიარი შეტყობინებები კვლავ რიგში დამყარდება/აღმოცენდება თუ მომხმარებელი ჩავარდება — შეტყობინებების დაკარგვის თავიდან აცილება), რამდენიმე მომხმარებელი რიგში **ნაწილდება შეტყობინებებს** (კონკურირებული მომხმარებლები რიგისთვის დატვირთვის დაბალანსირებისა და პარალელური დამუშავებისთვის), და **prefetch** (უაღიარი შეტყობინებების შეზღუდვა მომხმარებელზე სამართლიანი განაწილებისთვის).

დადასტურების მექანიზმი ღია საიმედო მიწოდებისთვის (უზრუნველყოფს, რომ შეტყობინებები არ დაიკარგოს თუ დამუშავება ვერ ხერხდება), და კონკურირებული მომხმარებლები არის როგორ RabbitMQ ნაწილდება ნამუშევრებს.

ეს კონცეფციები (რიგის თვისებები მდგრადობისთვის, დადასტურებები საიმედოობისთვის, კონკურირებული მომხმარებლები სკალირებისთვის) აუცილებელია საიმედო მესიჯინგის აგებისთვის RabbitMQ-ით.

მას შემდეგ რაც რიგები RabbitMQ-ის ცენტრალური ნაწილია (შეტყობინებების დაკავება და მიწოდება) და მათი გაგება, მათი თვისებები (განსაკუთრებით მდგრადობა), და მოხმარება/დადასტურებები (საიმედო მიწოდებისა და დატვირთვის განაწილებისთვის) აუცილებელია, როგორ მუშაობენ რიგები აუცილებელია, ფუნდამენტური RabbitMQ ცოდნა — RabbitMQ-ის ცენტრალური ნაწილი თუ როგორ ინახავს და ამოწოდებს შეტყობინებებს, რიგის მდგრადობა და შეტყობინების დადასტურებები იყო გასაღები საიმედო მესიჯინგისთვის, და კონკურირებული მომხმარებლები ხელმისაწვდომს აკეთებენ დატვირთვის განაწილებას, აუცილებელია საიმედო RabbitMQ სისტემების აგებისთვის.