SSD Nodes Learn Hosting plans →
راهنماها Matt Connorتوسط Matt Connor

مقایسه NATS و RabbitMQ و Kafka برای اجرا روی یک VPS

برای انتخاب صف پیام روی یک سرور، این راهنما تفاوت تضمین تحویل، مصرف رم و رفتار در زمان ریستارت را بررسی می‌کند. بفهمید چه زمانی Postgres جایگزین بهتری برای این ابزارهاست.

پاسخ کوتاه برای یک سرور

استفاده از صف پیام (message queue) روی یک VPS، تصمیمی در مورد تضمین تحویل پیام است، نه سرعت. روی یک سرور واحد، broker به‌ندرت گلوگاه محسوب می‌شود، زیرا کد برنامه، پایگاه داده و دیسک شما زودتر از آن به محدودیت می‌رسند. ابزاری را انتخاب کنید که رفتار آن در زمان خرابی برایتان قابل‌قبول باشد، سپس سروری که در اختیار دارید را ارزیابی کنید.

چهار گزینه، به ترتیبی که اکثر کاربران باید در نظر بگیرند:

  • از پایگاه داده‌ای که هم‌اکنون اجرا می‌کنید استفاده کنید. Postgres با SELECT ... FOR UPDATE SKIP LOCKED یک صف کاری کارآمد است و هیچ پردازش جدیدی برای مانیتور کردن اضافه نمی‌کند.
  • زمانی از RabbitMQ استفاده کنید که هر پیام یک واحد کاری است که باید تایید (acknowledge) شود، تعداد دفعات محدودی بازنشانی (retry) شود و سپس در جایی قرار گیرد که انسان بتواند آن را بررسی کند.
  • زمانی از NATS استفاده کنید که پیام‌ها رویدادهایی هستند که چندین بخش از سیستم شما به آن‌ها واکنش نشان می‌دهند. برای رویدادهایی که باید پس از راه‌اندازی مجدد باقی بمانند، JetStream را فعال کنید.
  • زمانی از Kafka استفاده کنید که ابزار مقصد فقط از پروتکل Kafka پشتیبانی می‌کند. روی یک سرور، این تقریباً تنها دلیل باقی‌مانده برای انتخاب آن است.

باقی این راهنما به استدلال‌های این موضوع می‌پردازد: هر گزینه چه میزان حافظه و دیسک روی یک VPS کوچک اشغال می‌کند، هنگام reboot شدن سرور چه رفتاری دارد و دستور دقیقی که پیش از متوجه شدن کاربران، انباشت پیام‌ها (backlog) را به شما نشان می‌دهد چیست.

تضمین تحویل پیام واقعاً به چه معناست

حداکثر یک‌بار (At most once) یعنی کارگزار (broker) پیام را تحویل می‌دهد و آن را فراموش می‌کند. اگر هیچ مصرف‌کننده‌ای (consumer) متصل نباشد، یا مصرف‌کننده در میانهٔ کار از کار بیفتد، پیام از دست می‌رود و هیچ گزارشی مبنی بر عدم تحویل آن ثبت نمی‌شود.

حداقل یک‌بار (At least once) یعنی مصرف‌کننده پس از موفقیت در انجام کار، یک تأییدیه (ack) ارسال می‌کند. تا زمانی که این تأییدیه نرسد، کارگزار پیام را نزد خود نگه می‌دارد و دوباره آن را تحویل خواهد داد. به همین دلیل است که هندلرهای شما باید Idempotent باشند: پردازش دوبارهٔ یک پیام نباید منجر به دوبار کسر هزینه از کارت بانکی شود. تحویل «دقیقاً یک‌بار» (Exactly once) به صورت سرتاسری، چیزی نیست که کارگزار به تنهایی ارائه دهد. این ویژگی از طریق یک کلید یکتا در دیتابیس خودتان حاصل می‌شود.

بازپخش (Replay) یک ویژگی مجزا است. صف (queue) به محض دریافت تأییدیه، پیام را حذف می‌کند. اما لاگ (log)، پیام را برای یک بازهٔ زمانی مشخص نگه می‌دارد تا مصرف‌کنندهٔ جدید بتواند از ابتدای تاریخچه شروع به خواندن کند. Kafka و NATS JetStream از نوع لاگ هستند. RabbitMQ هم صف و هم استریم‌های قابل بازپخش ارائه می‌دهد؛ این راهنما از quorum queues استفاده می‌کند. این تفاوت، معماری‌های بیشتری را نسبت به نرخ توان عملیاتی (throughput) تحت تأثیر قرار می‌دهد.

صف پیام‌های مرده (Dead lettering) سرنوشت پیامی است که پیوسته در پردازش شکست می‌خورد. بدون این قابلیت، یک پیام سمی (poison message) تا ابد در حلقه تکرار می‌ماند و این وضعیت باعث می‌شود کارگر (worker) به جای آنکه «خراب» به نظر برسد، «مشغول» به نظر برسد.

با Postgres شروع کنید و اجازه دهید کارگزار (broker) خود را اثبات کند

بیشتر بارهای کاری تک‌برنامه‌ای، شامل چند هزار job پس‌زمینه در روز هستند. این حجم به‌راحتی در یک جدول جای می‌گیرد.

CREATE TABLE job (
  id        bigserial   PRIMARY KEY,
  payload   jsonb       NOT NULL,
  run_after timestamptz NOT NULL DEFAULT now(),
  attempts  int         NOT NULL DEFAULT 0
);
CREATE INDEX job_ready_idx ON job (run_after, id);

یک worker، یک job را درون یک تراکنش (transaction) تصاحب می‌کند.

BEGIN;
SELECT id, payload
  FROM job
 WHERE run_after <= now()
 ORDER BY id
   FOR UPDATE SKIP LOCKED
 LIMIT 1;
-- run the work, then remove the row
DELETE FROM job WHERE id = $1;
COMMIT;

FOR UPDATE SKIP LOCKED تمام ترفند کار است. این دستور ردیفی را که برمی‌گرداند قفل می‌کند و از هر ردیفی که تراکنش دیگری قبلاً قفل کرده است، عبور می‌کند؛ بنابراین دو worker هرگز یک job مشابه را تصاحب نمی‌کنند. اگر یک worker کرش کند، Postgres تراکنش آن را لغو (abort) می‌کند، قفل آزاد می‌شود و ردیف برای worker بعدی قابل مشاهده خواهد بود. شما تحویل حداقل-یک‌بار (at-least-once delivery)، تلاش مجدد با افزایش attempts و یک جدول dead letter را به دست می‌آورید؛ همه این‌ها با پایداری (durability) که از قبل بابت آن هزینه پرداخت کرده‌اید. صف عقب‌افتاده (backlog) تنها یک کوئری است: SELECT count(*) FROM job WHERE run_after <= now();

جایی که این روش دیگر کار نمی‌کند: هر تصاحب و حذف، یک عملیات نوشتن (write) است؛ بنابراین نرخ بالای job باعث باقی ماندن نسخه‌های مرده ردیف‌ها می‌شود و جدول صف، نمونه کلاسیک تورم (bloat) است که از autovacuum پیشی می‌گیرد. jobهای طولانی وضعیت را بدتر می‌کنند، زیرا تراکنشی که به اندازه طول مدت کار باز می‌ماند، افق vacuum را برای کل دیتابیس عقب نگه می‌دارد. Polling باعث ایجاد تأخیر می‌شود و LISTEN با NOTIFY عمل polling را حذف می‌کند اما عملیات نوشتن همچنان باقی است. زمانی که جدول job شلوغ‌ترین جدول شماست، یا سرویس دومی به همان رویدادها نیاز دارد، کار را به خارج از دیتابیس منتقل کنید. این انتخاب با نحوه استقرار خود دیتابیس در تعامل است، بنابراین پیش از افزودن یک کارگزار در کنار آن، در مورد اجرای دیتابیس در Docker یا روی host تصمیم بگیرید.

Redis گزینه دیگری است که ممکن است همین حالا از آن استفاده کنید. Redis Streams به شما consumer groupهایی با XADD و XREADGROUP، یک لیست معلق (pending list) برای هر گروه و XAUTOCLAIM برای بازپس‌گیری کار از یک consumer که از کار افتاده است، می‌دهد. این ابزار کوچک و سریع است. نکته صادقانه در مورد یک سرور واحد: با تنظیم معمول appendfsync everysec، قطع برق می‌تواند باعث از دست رفتن حدود یک ثانیه از عملیات نوشتن شود. این برای ابطال cache مناسب است اما برای پرداخت‌ها اشتباه است. اگر برنامه شما یک پردازش واحد است که حول SQLite در محیط production روی یک VPS ساخته شده، همان الگوی تصاحب-و-حذف کار می‌کند، هرچند SQLite معادل SKIP LOCKED را ندارد و هر worker روی همان یک قفل نوشتن (write lock) سریال‌سازی می‌شود.

NATS core: مسیریابی موضوع‌محور بدون حافظه

docker run -d --name nats \
  -p 4222:4222 -p 127.0.0.1:8222:8222 \
  nats:2.15 -m 8222

از اکتبر 2026، خط تولید فعلی سرور 2.15 است. فلگ -m 8222 پورت مانیتورینگ HTTP را فعال می‌کند که به‌صورت پیش‌فرض خاموش است و هیچ احراز هویتی ندارد؛ بنابراین آن را مطابق دستور بالا روی localhost محدود کنید.

NATS core از مدل حداکثر یک‌بار تحویل (at most once) استفاده می‌کند و هیچ‌چیزی را ذخیره نمی‌کند. ناشر (publisher) پیامی را به یک موضوع (subject) مانند orders.created ارسال می‌کند و هر مشترکی (subscriber) که فیلترش با آن مطابقت داشته باشد، یک نسخه دریافت می‌کند. اگر کسی مشترک نباشد، پیام حذف می‌شود و ناشر هیچ خطایی دریافت نمی‌کند، زیرا کار ناشر در لحظه‌ای که سرور بایت‌ها را پذیرفت، به پایان رسیده است. یک گروه صف (queue group) که شامل چندین مشترک با نام گروه یکسان است، باعث می‌شود سرور برای هر پیام یک عضو را انتخاب کند؛ این کار توزیع بار را بدون ذخیره‌سازی صف انجام می‌دهد.

میزان مصرف منابع (footprint) شامل وضعیت اشتراک به‌علاوه یک بافر نوشتن برای هر اتصال است، بنابراین سرور تعداد اتصالات را ردیابی می‌کند نه حجم پیام‌ها، و هیچ‌چیزی روی دیسک انباشته نمی‌شود. رفتار پس از راه‌اندازی مجدد (restart) نیز از همین قاعده پیروی می‌کند: پیام‌های در حال انتقال از بین می‌روند، کلاینت‌ها به‌طور خودکار دوباره متصل می‌شوند و هیچ مرحله بازیابی (recovery) برای انتظار وجود ندارد.

هیچ صف عقب‌افتاده‌ای (backlog) برای نظارت وجود ندارد، بنابراین باید مراقب از دست رفتن پیام‌ها باشید. زمانی که یک مشترک سوکت خود را کندتر از سرعتی که سرور به آن می‌نویسد می‌خواند، بافر سرور برای آن کلاینت پر می‌شود. اگر کلاینت تا زمان تعیین‌شده برای نوشتن (write deadline) عقب‌ماندگی خود را جبران نکند، سرور کل اتصال را می‌بندد و یک شمارنده را افزایش می‌دهد.

curl -s http://localhost:8222/varz | jq '.slow_consumers, .connections, .in_msgs, .out_msgs'

مقدار slow_consumers که دائماً در حال افزایش است به این معنی است که پیام‌ها در حال حذف شدن هستند، بنابراین به‌جای خواندن یک‌باره آن، روی آن هشدار (alert) تنظیم کنید. NATS core برای پیام‌هایی مناسب است که ارزش آن‌ها به‌سرعت از بین می‌رود: مانند یک معیار (metric)، به‌روزرسانی وضعیت حضور (presence update) یا ابطال کش (cache invalidation) که رویداد بعدی به‌هرحال جایگزین آن خواهد شد.

NATS JetStream: استریم‌های پایدار و بازپخش در همان پردازش

JetStream یک محصول جداگانه نیست. این یک زیرسیستم در همان فایل باینری است که با یک فلگ فعال می‌شود.

docker run -d --name nats \
  -p 4222:4222 -p 127.0.0.1:8222:8222 \
  -v nats-data:/data \
  nats:2.15 -js -sd /data -m 8222

-sd /data مسیر ذخیره‌سازی را تعیین می‌کند. اگر آن را حذف کنید، JetStream داده‌های خود را در /tmp ذخیره می‌کند که دقیقاً به همان اندازه‌ای که از نامش پیداست، پایدار است. یک استریم را با استفاده از CLI بسازید که در ایمیج nats-box عرضه می‌شود.

docker run --rm -it --network host natsio/nats-box:latest \
  nats stream add ORDERS \
    --subjects 'orders.>' \
    --storage file \
    --retention limits \
    --max-age 72h \
    --max-bytes=1073741824 \
    --discard old \
    --defaults

هر محدودیتی در اینجا، جایگاه خود را در یک سرور کوچک پیدا می‌کند. ذخیره‌سازی فایل در صورت کرش کردن پردازش بروکر باقی می‌ماند، اما بازه پیش‌فرض دو دقیقه‌ای برای fsync به این معناست که کرش سیستم‌عامل یا قطع برق می‌تواند منجر به از دست رفتن پیام‌های تاییدشده شود؛ استریم‌های حافظه‌محور نیز با خروج پردازش، داده‌های خود را از دست می‌دهند. --max-bytes=1073741824 سقف استریم را روی 1 GiB به صورت تعداد بایت محدود می‌کند و --discard old با رسیدن به این سقف، قدیمی‌ترین پیام‌ها را حذف می‌کند تا از رد کردن نوشتن‌های جدید جلوگیری شود. اگر سقف را تعیین نکنید، یک ناشر (publisher) خارج از کنترل، دیسک را پر می‌کند و در آن لحظه دیتابیس شما نیز متوقف می‌شود، زیرا آن‌ها در آن دیسک مشترک هستند.

یک مصرف‌کننده (consumer) پایدار، موقعیت خود را در استریم حفظ می‌کند و آن را پس از راه‌اندازی مجدد نیز نگه می‌دارد. مقدار --max-deliver را روی مصرف‌کننده تنظیم کنید تا پیامی که همیشه با خطا مواجه می‌شود، برای همیشه بازنشر نشود. هنگامی که تعداد دفعات ارسال یک پیام به پایان می‌رسد، JetStream یک هشدار روی $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.> منتشر می‌کند و اشتراک در آن موضوع، روشی است که شما با آن مسیر پیام‌های مرده (dead letter path) را می‌سازید؛ قابلیتی که RabbitMQ به‌صورت آماده ارائه می‌دهد. این کاری است که باید خودتان پیاده‌سازی کنید.

برای مشاهده صف پیام‌ها، nats stream report را برای تعداد پیام‌های ذخیره‌شده و nats consumer report ORDERS را برای تاییدهای معلق و پیام‌های پردازش‌نشده به ازای هر مصرف‌کننده اجرا کنید. عدد مربوط به پیام‌های پردازش‌نشده همان عددی است که باید برای آن هشدار (alarm) تنظیم کنید. هزینه دیسک با اجرای du -sh روی دایرکتوری ذخیره‌سازی قابل مشاهده است و تا زمانی که محدودیت نگهداری (retention limit) آن را کاهش ندهد، رشد می‌کند.

RabbitMQ: تایید دریافت هر پیام و انتقال موارد ناموفق به صف انتظار

docker run -d --name rabbitmq \
  -p 5672:5672 -p 127.0.0.1:15672:15672 \
  -v rabbitmq-data:/var/lib/rabbitmq \
  rabbitmq:4-management

از تاریخ 1 نوامبر 2026، سری فعلی 4.4 و آخرین نسخه منتشرشده 4.4.0 است. پورت 5672 برای پروتکل AMQP (پروتکل صف‌بندی پیشرفته پیام) و پورت 15672 برای رابط مدیریتی استفاده می‌شود. رابط مدیریتی را روی localhost نگه دارید و از طریق تونل SSH به آن دسترسی پیدا کنید.

صف‌ها را با تنظیم آرگومان x-queue-type روی quorum تعریف کنید؛ مقدار پیش‌فرض همچنان classic است. صف‌های Quorum همیشه پایدار (durable) هستند و پیش از هر عملیاتی، داده‌ها را روی دیسک می‌نویسند. بنابراین در یک نود، به‌جای مواجهه با ماتریسی از گزینه‌های پایدار و موقت، رفتاری واحد و شفاف خواهید داشت. مقصد پیام‌های ناموفق (dead letter) را با استفاده از یک policy تعیین کنید.

docker exec rabbitmq rabbitmqctl set_policy DLX ".*" \
  '{"dead-letter-exchange":"my-dlx", "dead-letter-routing-key":"my-routing-key"}' \
  --apply-to queues --priority 7

یک my-dlx تعریف کرده و یک صف پایدار برای پیام‌های ناموفق را با استفاده از my-routing-key به آن متصل کنید؛ توجه داشته باشید که policy به‌طور خودکار این موارد را ایجاد نمی‌کند.

یک پیام به چهار دلیل به صف dead letter منتقل می‌شود: مصرف‌کننده (consumer) آن را با basic.reject یا basic.nack و تنظیم requeue روی false رد می‌کند، TTL (زمان زنده بودن) پیام منقضی می‌شود، صف از حد مجاز طول خود عبور می‌کند، یا تعداد دفعات تحویل پیام در صف Quorum از حد مجاز فراتر می‌رود. این حد مجاز از نسخه 4.0 RabbitMQ به بعد، به‌طور پیش‌فرض 20 است. از نسخه 4.3 RabbitMQ، استفاده صریح از nack همراه با requeue باعث افزایش delivery-count نمی‌شود، بنابراین پیام می‌تواند در یک حلقه بی‌پایان گیر کند. برای خطاهایی که باید در شمارش حد مجاز لحاظ شوند، از basic.reject همراه با requeue استفاده کنید. در صورت عبور از حد مجاز، پیام تنها در صورتی به صف dead letter منتقل می‌شود که DLX پیکربندی شده باشد؛ در غیر این صورت، پیام حذف می‌شود.

حافظه (RAM) جایی است که RabbitMQ در VPSهای کوچک کاربران را غافلگیر می‌کند. حد آستانه بالای حافظه به‌طور پیش‌فرض 0.6 از RAM موجود است و هنگامی که نود از این حد عبور کند، RabbitMQ تمام اتصالات در حال انتشار (publishing) را مسدود می‌کند. برنامه شما خطایی دریافت نمی‌کند؛ بلکه عملیات انتشار هرگز به پایان نمی‌رسد که در کد شما به‌صورت یک وقفه (hang) دیده می‌شود. لاگ راه‌اندازی، عددی را که نود محاسبه کرده است چاپ می‌کند:

Memory high watermark set to 1024 MiB (1073741824 bytes) of 8192 MiB (8589934592 bytes) total

هشدار دیسک نیز زمانی که فضای آزاد به‌طور پیش‌فرض به زیر 50 MB برسد، ناشران را به همین شکل مسدود می‌کند. صف‌های Quorum محاسبات خاص خود را نیز اضافه می‌کنند: مستندات حداقل 32 بایت متادیتای درون‌حافظه‌ای برای هر پیام (حدود 1 MB برای هر 30,000 پیام) را در نظر می‌گیرند و توصیه می‌کنند حداقل سه برابر اندازه موثر write-ahead log در RAM فضا موجود باشد. حد پیش‌فرض WAL برابر 512 MiB است، بنابراین این توصیه به‌تنهایی نیازمند 1.5 GiB رم است. روی سروری با 2 GB رم، این مقدار را در rabbitmq.conf کاهش دهید و به اینکه تنظیمات پیش‌فرض مناسب باشد، تکیه نکنید.

raft.wal_max_size_bytes = 64000000
vm_memory_high_watermark.relative = 0.5

Backlog شامل دو عدد است و این جفت به شما می‌گوید با چه نوع خطایی مواجه هستید.

docker exec rabbitmq rabbitmqctl list_queues name messages messages_ready messages_unacknowledged

messages_ready نشان‌دهنده پیام‌های در انتظار مصرف‌کننده است. messages_unacknowledged پیام‌هایی هستند که تحویل داده شده اما هرگز تایید (ack) نشده‌اند. افزایش تعداد پیام‌های تاییدنشده در کنار ثابت ماندن تعداد پیام‌های آماده، به این معنی است که کارگرهای (workers) شما وظایف را دریافت کرده اما پردازش آن‌ها را به پایان نمی‌رسانند؛ این با وضعیتی که صف صرفاً عقب مانده است، تفاوت دارد.

اجرای Kafka روی یک سرور و محدودیت‌های آن

KAFKA_CLUSTER_ID="$(bin/kafka-storage.sh random-uuid)"
bin/kafka-storage.sh format --standalone -t $KAFKA_CLUSTER_ID -c config/server.properties
bin/kafka-server-start.sh config/server.properties

این راهنمای سریع برای Kafka 4.4.0 است که در تاریخ 1 نوامبر 2026 به‌روزرسانی شده و در حالت KRaft (یعنی Kafka Raft، کنترل‌کننده داخلی که در Kafka 4.0 جایگزین ZooKeeper شد) اجرا می‌شود. معادل کانتینری آن apache/kafka:4.4.0 است.

اسکریپت راه‌اندازی، در صورتی که خودتان مقداری تعیین نکرده باشید، export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" را تنظیم می‌کند. بنابراین broker پیش از ذخیره حتی یک پیام، 1 گیگابایت از حافظه Heap جاوا را رزرو می‌کند و علاوه بر آن، به رم آزاد برای کش صفحاتی که از آن‌ها می‌خواند نیاز دارد. در یک VPS با 2 گیگابایت رم، برنامه شما برای باقی‌مانده حافظه با JVM رقابت خواهد کرد.

موضوع بعدی که ممکن است غافلگیرکننده باشد، Retention است. مقدار پیش‌فرض log.retention.hours برابر با 168 است که معادل هفت روز بوده و log.retention.bytes به‌طور پیش‌فرض روی -1 تنظیم شده که به معنای عدم وجود محدودیت حجمی است. Kafka پیام‌ها را در تمام این بازه زمانی نگه می‌دارد، فارغ از اینکه همه مصرف‌کنندگان (consumers) آن‌ها را خوانده باشند یا خیر. این همان قابلیتی است که به خاطرش Kafka را انتخاب کرده‌اید، اما روی یک دیسک کوچک، همین ویژگی می‌تواند باعث بروز خطا شود؛ بنابراین پیش از آنکه با مشکل مواجه شوید، برای هر topic یک محدودیت حجمی تعیین کنید. این محدودیت حجمی برای هر partition اعمال می‌شود، پس هنگام بودجه‌بندی فضای دیسک، آن را در تعداد partitionها ضرب کنید.

و حالا بخش صادقانه ماجرا: یک broker تکی به معنای replication factor 1 است؛ بنابراین acks=all فقط منتظر همان broker می‌ماند، نه یک fsync. با تنظیمات پیش‌فرض flushing، داده‌های تاییدشده ممکن است همچنان در page cache سیستم‌عامل باقی بمانند. شما پایداری یک ماشین را با هزینه عملیاتی یک broker مبتنی بر JVM به اضافه یک کنترل‌کننده دریافت می‌کنید. Partitionها همچنین به چندین مصرف‌کننده در یک گروه اجازه می‌دهند تا کار را روی یک broker تقسیم کنند. قابلیت‌های Replication، آگاهی از رک (rack awareness) و سایر ویژگی‌های کلاستر در اینجا غیرفعال هستند. JetStream همان قابلیت بازپخش (replay) پایدار را روی همان سرور با کسری از حافظه مصرفی به شما می‌دهد. دو دلیل همچنان استفاده از Kafka را در اینجا توجیه می‌کند: یا یک ابزار پایین‌دستی (downstream) فقط از پروتکل Kafka پشتیبانی می‌کند (مانند تغییر داده‌ها با Debezium یا یک بارگذار تحلیلی)، یا در حال شبیه‌سازی توپولوژی محیط تولید در مقیاس کوچک هستید. برنامه‌ریزی برای رشد و تبدیل شدن به یک کلاستر، در واقع برنامه‌ریزی برای خرید ماشین‌های بیشتر است و تا آن زمان، این معامله همانند اجرای k3s روی یک نود تکی است که در آن پیچیدگی کلاستر را برای قابلیت اطمینان یک نود می‌پردازید.

Backlog در Kafka همان consumer lag است.

bin/kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group my-group

ستون LAG را بخوانید که حاصل تفریق CURRENT-OFFSET از LOG-END-OFFSET برای هر partition است. افزایش Lag در یک partition در حالی که بقیه ثابت مانده‌اند، نشان‌دهنده توزیع نامتوازن کلید (key) است؛ زیرا تمام پیام‌هایی که کلید یکسانی دارند در یک partition قرار می‌گیرند و یک مصرف‌کننده به‌تنهایی پردازش آن‌ها را بر عهده می‌گیرد.

پس از راه‌اندازی مجدد سرور چه اتفاقی می‌افتد

NATS اصلی تمام داده‌های در حال انتقال را از دست می‌دهد و بلافاصله بالا می‌آید، زیرا چیزی برای بازیابی وجود ندارد. JetStream استریم‌ها و موقعیت مصرف‌کنندگان (consumer positions) را از دایرکتوری ذخیره‌سازی بارگذاری می‌کند، بنابراین مصرف‌کنندگان از همان آفستی که داشتند ادامه می‌دهند. RabbitMQ صف‌های quorum را بدون توجه به حالت تحویل پیام از روی دیسک بازیابی می‌کند؛ صف‌های کلاسیک موقت و پیام‌های غیرماندگار در صف‌های کلاسیک از بین می‌روند. از نسخه 4.3 به بعد در RabbitMQ، صف‌های کلاسیک غیرماندگار و غیرانحصاری به‌صورت پیش‌فرض قابل تعریف نیستند. Kafka در زمان شروع، سگمنت‌های لاگ خود را بازپخش می‌کند و پس از یک خاموشی غیراستاندارد، این اسکن بازیابی ممکن است روی یک دیسک کوچک، پیش از آنکه بروکر اتصالی را بپذیرد، چندین دقیقه طول بکشد.

دو مورد وجود دارد که ارزش دارد یک‌بار تنظیم شوند. برای کانتینر یک سیاست راه‌اندازی مجدد (restart: unless-stopped) تعیین کنید یا unit مربوط به systemd را فعال کنید تا بروکر پس از راه‌اندازی مجدد سیستم‌عامل به‌دلیل ارتقای هسته، بدون دخالت شما بازگردد. سپس ترتیب را مدیریت کنید: بروکری که بیست ثانیه پس از برنامه شما آماده می‌شود، اتصالات اولیه را رد می‌کند و برخی کتابخانه‌های کلاینت به‌جای تلاش مجدد، از برنامه خارج می‌شوند. برنامه را با استفاده از Compose healthchecks that hold a dependent service back until the broker is ready به بروکر وابسته کنید.

هزینه روی VPS شخصی، اندازه‌گیری به‌جای نقل‌قول

ارقام توان عملیاتی (throughput) منتشرشده، روی سخت‌افزاری اندازه‌گیری شده‌اند که شما در اختیار ندارید؛ معمولاً یک سرور چند‌هسته‌ای با NVMe محلی. با آن‌ها به‌عنوان یک سقف حداکثری برخورد کنید و سرور خودتان را بسنجید.

docker stats --no-stream
free -m
sudo du -sh /var/lib/docker/volumes/*/_data

این تست‌ها را یک‌بار در حالی که broker در حالت بیکار (idle) است و بار دیگر تحت ترافیک واقعی خود اجرا کنید. شکاف بین این دو عدد، همان معیاری است که تعیین می‌کند آیا broker در کنار برنامه شما جای می‌گیرد یا خیر. برای به‌دست آوردن یک کفِ تقریبی برای توان عملیاتی، به‌جای تکیه بر پست‌های وبلاگی دیگران، از ابزار تولید بار (load generator) اختصاصی هر پروژه استفاده کنید: nats bench pub test --msgs 100000 --clients 2 برای NATS، bin/kafka-producer-perf-test.sh برای Kafka و PerfTest برای RabbitMQ. اجرای generator روی همان VPS، هم broker و هم generator را با هم می‌سنجد؛ این کار تا زمانی که هنگام گزارش عدد نهایی به آن اشاره کنید، مشکلی ندارد.

یک سقف واحد برای همه آن‌ها وجود دارد. ذخیره‌سازی پایدار (durable storage) در نهایت به دیسک وابسته است، اما تأییدیه (acknowledgement) همیشه منتظر fsync نمی‌ماند: تنظیمات پیش‌فرض Kafka قابلیت fsync برنامه را غیرفعال می‌کند و بازه زمانی همگام‌سازی پیش‌فرض در JetStream دو دقیقه است. روی یک VPS با فضای ذخیره‌سازی متصل به شبکه (network-attached storage)، توان عملیاتی دیسک و تأخیر flush را در کنار تنظیمات پایداری (durability) که انتخاب می‌کنید، اندازه‌گیری کنید.

سه بار کاری و صف پیامی که هر کدام نیاز دارند

  1. کارهای پس‌زمینه برای یک برنامه وب، مانند ارسال ایمیل، تغییر اندازه تصاویر یا تحویل webhooks. با Postgres و SKIP LOCKED شروع کنید. زمانی که به تاییدیه (ack) برای هر پیام، محدودیت در تحویل و یک صف پیام‌های ناموفق (dead letter queue) نیاز دارید که بتوانید بدون نوشتن منطق آن، بررسی‌اش کنید، یا زمانی که جدول کارهای شما به شلوغ‌ترین جدول در پایگاه داده تبدیل شده است، به سراغ RabbitMQ با quorum queues بروید.
  2. رویدادهایی که چندین سرویس داخلی به آن‌ها واکنش نشان می‌دهند، جایی که پیام از دست رفته به‌سرعت با یک پیام جدیدتر جایگزین می‌شود. از Core NATS با استفاده از موضوعات (subjects) به عنوان طرح مسیریابی و گروه‌های صف (queue groups) در جایی که نیاز به اشتراک‌گذاری کار دارید، استفاده کنید. برای مجموعه محدودی از موضوعات که باید پس از راه‌اندازی مجدد باقی بمانند، یک JetStream stream اضافه کنید و بقیه را در حافظه (memory) نگه دارید.
  3. یک لاگ رویداد که مصرف‌کنندگان (consumers) آن را از ابتدا می‌خوانند، برای مسیر حسابرسی (audit trail)، بازسازی یک مدل خواندن (read model) یا تغذیه تحلیل‌ها در آینده. از JetStream با ذخیره‌سازی فایل و محدودیت بایت صریح استفاده کنید. تنها زمانی Kafka را انتخاب کنید که یک ابزار پایین‌دستی به پروتکل Kafka نیاز داشته باشد و هزینه استفاده از JVM heap را به عنوان بهای آن سازگاری بپذیرید.

هزینه انتخاب اشتباه روی یک سرور، توان عملیاتی (throughput) نیست. بلکه بازیابی سیستم در ساعت 3 صبح است، زمانی که باید بدانید آیا پیام‌ها هنوز وجود دارند یا خیر. بر اساس آن انتخاب کنید.

FAQ

آیا می‌توانم Kafka را روی یک VPS با 2 GB رم اجرا کنم؟

اجرا می‌شود، اما منابع بسیار محدود خواهد بود. bin/kafka-server-start.sh مقدار KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" را در صورتی که آن را تغییر نداده باشید تنظیم می‌کند، بنابراین JVM پیش از ذخیره هر پیامی 1 GB رم اشغال می‌کند و Kafka برای page cache به حافظه آزاد فراتر از آن نیاز دارد. اگر برنامه و دیتابیس خود را هم روی همان سرور قرار دهید، سیستم وارد swap می‌شود. همچنین شما به replication factor 1 محدود می‌شوید، یعنی فقط یک نسخه دارید و هیچ replica پشتیبانی وجود ندارد؛ acks=all نیازی به fsync ندارد، بنابراین داده‌های تایید شده ممکن است همچنان در page cache سیستم‌عامل باقی بمانند. NATS JetStream روی همان سخت‌افزار، قابلیت replay پایدار را با مصرف حافظه بسیار کمتر ارائه می‌دهد.

آیا اگر از قبل Postgres دارم، باز هم به صف پیام (message queue) نیاز دارم؟

اغلب خیر. خواندن از یک جدول job با استفاده از SELECT ... FOR UPDATE SKIP LOCKED در یک تراکنش، تحویل حداقل یک‌باره (at-least-once)، کارگرهای همزمان ایمن، تلاش مجدد و جدول dead letter را فراهم می‌کند، بدون اینکه نیاز به مانیتورینگ سرویس اضافه یا پشتیبان‌گیری جدید باشد. نشانه‌های نیاز به تغییر سرویس مشخص هستند: جدول صف به سنگین‌ترین بار نوشتن شما تبدیل می‌شود و autovacuum عقب می‌افتد، کارهای طولانی‌مدت تراکنش‌ها را باز نگه می‌دارند و مانع vacuum کل دیتابیس می‌شوند، یا سرویس دومی نیاز دارد که همان رویدادها را به‌طور مستقل مصرف کند.

برای کارهای پس‌زمینه (background jobs) از NATS JetStream استفاده کنم یا RabbitMQ؟

اگر به تاییدیه (acknowledgement) برای هر پیام، محدودیت در تحویل و مسیریابی dead letter به عنوان رفتار پیش‌فرض نیاز دارید، RabbitMQ را انتخاب کنید. Quorum queues همیشه پایدار هستند و محدودیت تحویل از نسخه 4.0 RabbitMQ به‌طور پیش‌فرض روی 20 تنظیم شده است. از نسخه 4.3 به بعد، nackهای صریح با requeue در آن محدودیت لحاظ نمی‌شوند؛ برای خطاهای شمارش‌شده از basic.reject همراه با requeue استفاده کنید و یک DLX برای نگهداری پیام‌های تمام‌شده (exhausted) پیکربندی کنید. اگر همان رویدادها باید بعداً توسط مصرف‌کنندگان دیگر بازپخش (replay) شوند، از JetStream استفاده کنید، زیرا یک stream پیام‌ها را پس از تایید نگه می‌دارد اما صف این کار را نمی‌کند. در JetStream شما --max-deliver را تنظیم می‌کنید و مسیر dead letter را خودتان از طریق $JS.EVENT.ADVISORY.CONSUMER.MAX_DELIVERIES.> advisory می‌سازید.

چگونه بفهمم مصرف‌کنندگان من چقدر عقب هستند؟

هر بروکر یک دستور مخصوص دارد. برای RabbitMQ، دستور rabbitmqctl list_queues name messages messages_ready messages_unacknowledged کارهای منتظر برای مصرف‌کننده را از کارهای تحویل‌شده اما تایید نشده (ack نشده) جدا می‌کند. برای JetStream، دستور nats consumer report <stream> پیام‌های پردازش‌نشده و تاییدیه‌های معوق را به ازای هر مصرف‌کننده نشان می‌دهد. برای Kafka، دستور kafka-consumer-groups.sh --bootstrap-server localhost:9092 --describe --group <group> ستون LAG را به ازای هر پارتیشن چاپ می‌کند. Core NATS هیچ backlogای برای خواندن ندارد، چون چیزی ذخیره نمی‌کند؛ بنابراین به جای آن، شمارنده slow_consumers را در http://localhost:8222/varz مانیتور کنید: این شمارنده اتصالاتی را که سرور به دلیل عقب ماندن بسته است نشان می‌دهد، که به معنای از دست رفتن پیام است.

آیا این مقاله مفید بود؟

#nats#rabbitmq#kafka#message-queue#architecture