RabbitMQ இல் செய்தி acknowledgments எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Acknowledgments (acks)** RabbitMQ க்கு ஒரு செய்தி வெற்றிகரமாக செயல்படுத்தப்பட்டது என்று கூறுகிறது, இதனால் அது queue இலிருந்து நீக்கப்படலாம். அவை **நம்பகமான delivery** க்கு அத்தியாவசியமாக உள்ளன — ஒரு consumer தோல்வியுற்றால் செய்திகள் இழக்கப்படாமல் உறுதிப்படுத்துகிறது.

## Acknowledgments எவ்வாறு செயல்படுகிறது

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

## Manual vs automatic 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)
```

## Negative acks மற்றும் rejection

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

## இது ஏன் முக்கியமாக இருக்கிறது

செய்தி acknowledgments எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது அடிப்படையாக உள்ளது — ஒரு consumer processing க்குப் பிறகு ஒரு செய்தியை ack செய்கிறது (அது முடிந்துவிட்டது என்று RabbitMQ க்கு கூறி செய்தி நீக்கப்படுகிறது), consumer மரணத்திற்கு முன் ack செய்யாவிட்டால் செய்திகள் **மீண்டும் queue இல் வைக்கப்பட்டு மீண்டும் delivery செய்யப்படுகிறது** (consumer தோல்வியில் செய்திகள் இழக்கப்படாமல்) — என்பதை புரிந்துகொள்வது செய்தி இழப்பைத் தடுக்கும் நம்பகத்தன்மை பொறிமுறையைத் தெளிவுபடுத்துகிறது.

**Manual vs automatic acks** ஐ புரிந்துகொள்வது மிக முக்கியமாக உள்ளது: **manual acks** (processing க்குப் பிறகு consumer தெளிவாக ack செய்கிறது, processing தோல்வியுற்றால் செய்திகள் மீண்டும் delivery செய்யப்படுகிறது — பாதுகாப்பான, நம்பகமான தெரிவு) எதிராக **automatic acks** (deliver செய்யப்பட்ட உடனே செய்தி acked எனக் கருதப்படுகிறது, processing க்கு முன், இது வேகமாக உள்ளது ஆனால் **unsafe** processing நேரத்தில் crash விளைவுறினால் செய்தி இழக்கப்படுகிறது).

முக்கிய செயல்பாட்டு வழிகாட்டுதல் **நம்பகத்தன்மைக்கு manual acks ஐ பயன்படுத்துவது** (வெற்றிகரமான processing க்குப் பிறகு மட்டுமே ack செய்கிறது), automatic acks செய்திகளை இழக்க ஆபத்தாக இருப்பதால் — ஒரு பொதுவான, முக்கியமான கருத்து.

**Negative acks மற்றும் rejection** ஐ புரிந்துகொள்வது — ஒரு consumer அதைச் செயல்படுத்த முடியாத ஒரு செய்தியை negatively acknowledge (nack/reject) செய்கிறது, அதை மீண்டும் queue இல் வைக்கிறது அல்லது **dead letter queue** க்கு அனுப்புகிறது —실패한செய்திகளைக் கையாளுவதில் கட்டுப்பாட்டை வழங்குகிறது (அவற்றைத் தொலைக்கவோ அல்லது நிரந்தரமாக தடைசெய்யவோ இல்லாமல்).

இந்த acknowledgment பொறிமுறைகள் (நம்பகமான delivery க்கு positive acks, பாதுகாப்புக்கு manual acks, தோல்வி கையாளுதலுக்கு negative acks) நம்பகமான RabbitMQ messaging ஐ கட்டமைக்க அவசியமாக உள்ளன, இது செய்திகளை இழக்காது.

Acknowledgments RabbitMQ இல் நம்பகமான delivery க்கு அவசியமாக உள்ளன (consumer தோல்வியில் செய்தி இழப்பைத் தடுக்கிறது, manual acks பாதுகாப்பான தெரிவாக உள்ளது மற்றும் negative acks தோல்விகளைக் கையாளுகிறது), மேலும் அவற்றைப் புரிந்துகொள்வது நம்பகமான messaging கட்டமைக்க முக்கியமாக உள்ளது என்பதால், message acknowledgments ஐ புரிந்துகொள்வது அவசியமான, அடிப்படை RabbitMQ அறிவு — நம்பகமான delivery க்கு (consumers தோல்வியுற்றால் செய்திகள் இழக்கப்படாமல் உறுதிப்படுத்தும்), manual-vs-automatic ack வேறுபாடு ஒரு முக்கியமான நம்பகத்தன்மை கருத்தாக உள்ளது, மேலும் நம்பகமான RabbitMQ அமைப்புகளை கட்டமைக்க அவசியம்.