როგორ მუშაობს შეტყობინებების დადასტურება RabbitMQ-ში?

Question

Accepted Answer

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

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

```text
When a consumer receives and processes a message, it ACKNOWLEDGES it:
  → ACK → "I've processed this message" → RabbitMQ removes it from the queue
  → if a consumer DIES before acking (crash, disconnect) → RabbitMQ REQUEUES the message
    → redelivered to another consumer (NOT lost)
→ acks ensure messages are processed reliably (not lost if a consumer fails)
```

## ხელით vs ავტომატური acks

```text
MANUAL ack → the consumer explicitly acks AFTER processing → reliable (message redelivered
  if processing fails) — the safe choice for important messages
AUTOMATIC ack → the message is considered acked as soon as it's DELIVERED (before processing)
  → faster but UNSAFE → if the consumer crashes during processing, the message is LOST
→ use MANUAL acks for reliability (ack only after successful processing)
```

## უარყოფითი acks და უარყოფა

```text
✓ NACK / REJECT → the consumer can negatively acknowledge a message it can't process:
  → REQUEUE it (try again / another consumer) OR send it to a DEAD LETTER queue
  → handle messages that fail processing (don't lose them, don't block forever)
→ acks (positive and negative) give control over message handling and reliability
```

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

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

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

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

**ხელით vs ავტომატური acks** -ის გაგება გადამწყვეტია: **ხელით acks** (მომხმარებელი ხელმისაწვდომლად აკეთებს ack-ს დამუშავების შემდეგ, ამიტომ შეტყობინებები ხელახლა მიწოდდება, თუ დამუშავება ვერ მოახერხა — უსაფრთხო, საიმედო არჩევანი) კი **ავტომატური acks** (შეტყობინება ითვლება ack-დ როგორც კი მიწოდდება, დამუშავებამდე, რაც უფრო სწრაფია, მაგრამ **უსაფრთხო** არ არის, რადგან დამუშავების დროს ჩავარდნა დაკარგავს შეტყობინებას).

მთავარი პრაქტიკული რჩევაა **ხელით acks გამოიყენო საიმედოობისთვის** (ack შედეგი უშედეგ დამუშავების შემდეგ), ვინაიდან ავტომატური acks ირტყმევს შეტყობინებას დაკარგვის რისკს — ხშირი, მნიშვნელოვანი საკითხი.

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

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

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