Отложенные сообщения в RabbitMQ: 4 способа и код (2026)

16/11/2026
·
Обновлено
11.16.2026
Как реализовать отложенные сообщения с RabbitMQ? С примерами кода — обложка

Главное

• Отложенное сообщение в RabbitMQ делают четырьмя способами: TTL + Dead Letter Exchange, плагин x-delayed-message, повторы quorum-очередей (RabbitMQ 4.3) и нативная задержка в quorum-очередях (RabbitMQ 4.4). Выбор зависит от версии брокера и от того, одинаковая ли задержка у всех сообщений.

• С 20 октября 2026 года задержка есть в самом RabbitMQ. В версии 4.4 сообщение публикуют в quorum-очередь с меткой x-opt-delivery-time, и очередь держит его до этого момента. Плагин и особый тип обменника не нужны.

• Официальный плагин x-delayed-message закрыт. Команда RabbitMQ перевела репозиторий в архив: плагин держался на Mnesia, а её убрали в RabbitMQ 4.3. На 4.3.3+ работает только форк CloudAMQP, и он по-прежнему хранит одну копию сообщения на одном узле.

• TTL + DLX работает на любой версии, но очередь обрабатывается по порядку: сообщение на минуту, стоящее за сообщением на час, уйдёт через час. Лечится отдельной очередью на каждую ступень задержки.

• Задержки на дни и недели держите вне брокера: в базе данных, Temporal или облачном планировщике. RabbitMQ хорош для «сейчас плюс несколько минут или часов».

Обновлено в ноябре 2026: статья переписана — нативная задержка RabbitMQ 4.4, повторы quorum-очередей 4.3, статус плагина x-delayed-message, код на Node.js и четыре схемы.

Почти в каждом продукте есть действие, которое нужно выполнить не сейчас, а позже или по кругу: пуш через 10 минут после начала урока, повтор платёжного вебхука после ошибки, письмо за сутки до конца подписки, ночная очистка временных файлов. Пока сервер один, хватает cron или библиотеки node-schedule. Когда серверов несколько, такие задачи начинают срабатывать дважды или теряются при перезапуске узла.

Брокер сообщений RabbitMQ решает эту задачу для кластера: отложенное сообщение лежит в очереди, переживает деплой и падение одного сервера и приходит к тому обработчику, который свободен. Первую версию этой статьи мы написали в 2022 году. С тех пор RabbitMQ дважды поменял правила: в версии 4.3 появились встроенные повторы с задержкой, а в 4.4 — нативные отложенные сообщения. Ниже все четыре способа с кодом на Node.js (amqplib), их ограничения и дерево выбора на ноябрь 2026 года.

Почему этот разбор пишет Фора Софт

Мы разрабатываем видеосвязь, стриминг, онлайн-обучение и продукты с ИИ с 2005 года: больше 250 сданных проектов, команда около 50 инженеров. Почти в каждом таком проекте есть отложенные задачи: напоминания, повторы вебхуков, передача загруженного видео на обработку. Поэтому выбор способа задержки — постоянный вопрос на ревью архитектуры бэкенда, когда заказчик приносит систему, которая теряет или дублирует уведомления.

Мы запускали в продакшене TTL + DLX и плагин x-delayed-message, переносили очереди на quorum и знаем, где каждый способ ломается. Версии, аргументы и цены в статье сверены с релизами RabbitMQ 4.3 и 4.4 и официальной документацией в ноябре 2026 года.

Сообщения теряются или приходят дважды?

Покажите схему очередей и логи. За 30 минут найдём причину и предложим, как перестроить задержки под вашу версию RabbitMQ.

Обсудить проект →Позвонить →Написать на почту →

Как отправить отложенное сообщение в RabbitMQ: короткий ответ

На RabbitMQ 4.4 и новее опубликуйте сообщение в quorum-очередь с заголовком x-opt-delivery-time, где указано время доставки в миллисекундах Unix. На 4.3 для повторов после ошибки используйте встроенные повторы quorum-очередей, а для фиксированной задержки — TTL + Dead Letter Exchange. На 4.2 и старше остаются TTL + DLX и плагин x-delayed-message.

  • TTL + DLX. Сообщение кладут в очередь ожидания со сроком жизни. Когда срок истекает, RabbitMQ переносит его в рабочую очередь. Работает на любой версии без плагинов.
  • Плагин x-delayed-message. Обменник особого типа, задержка у каждого сообщения своя (заголовок x-delay). Официальная сборка в архиве, жив только форк CloudAMQP.
  • Повторы quorum-очереди (4.3+). Очередь сама откладывает сообщение, обработка которого упала, и выдаёт его снова через растущую паузу. Подходит только для повторов.
  • Нативная задержка (4.4+). Время доставки задаётся при публикации, очередь реплицирует сообщение сразу и прячет его от потребителей до нужного момента.
Дерево выбора способа отложенных сообщений в RabbitMQ: четыре вопроса и пять ответов

Рисунок 1. Как выбрать способ задержки: идите по вопросам сверху вниз, первое «да» даёт ответ.

ПараметрTTL + DLXПлагин x-delayed-messageПовторы quorum (4.3+)Нативная задержка (4.4+)
Своя задержка у каждого сообщенияНет, одна на очередь (делают ступени)Да, заголовок x-delayЛинейный рост по числу попытокДа, x-opt-delivery-time
Блокировка головы очередиЕстьНетНетНет
Репликация в кластереДа, на quorum-очередяхНет, одна копия на узлеДа, RaftДа, Raft
ЁмкостьМиллионы, упор в диск≈ 100 тыс. отложенныхМиллионыНе опубликована, нужен нагрузочный тест
Разумный горизонтСекунды — часыСекунды — часы, «день-два максимум»Секунды — минутыСекунды — часы
Поддержка в 2026 годуЯдро RabbitMQОфициальный в архиве, форк CloudAMQPЯдро с 4.3Ядро с 4.4

Когда нужны отложенные сообщения

Отложенные сообщения окупаются в четырёх сценариях, которые встречаются почти в каждом нашем проекте:

  1. Повтор с паузой. Вебхук, списание оплаты или запрос к стороннему API упал с ошибкой 5xx. Повторяем через 30 секунд, потом через 2 минуты, потом через 10 и только после этого сдаёмся.
  2. Напоминания по времени. SMS за 10 минут до занятия, письмо за сутки до конца аренды фильма, напоминание о брошенной корзине через 20 минут.
  3. Отложенный шаг конвейера. Пользователь загрузил видео на 2 ГБ: подтверждаем загрузку сразу, а задачу на перекодирование отдаём обработчику через 15 секунд, когда файл точно доступен в объектном хранилище.
  4. Уборка. Просроченные одноразовые коды, брошенные папки загрузок, гостевые сессии. Отложенное сообщение надёжнее общего cron, который гоняется наперегонки на нескольких серверах.

Задержка на недели? Если задержка измеряется неделями, привязана к календарю или это многошаговый бизнес-процесс, сразу переходите к разделу «Когда RabbitMQ не подходит».

Почему не cron и node-schedule

Cron запускает скрипт на сервере по расписанию, а node-schedule делает то же внутри процесса Node.js. Оба способа хороши, пока сервер один. В кластере возникают три проблемы:

  • непонятно, на каком из серверов или сервисов запускать задачу, и она легко срабатывает на всех сразу;
  • выбранный сервер может упасть вместе со всеми запланированными задачами;
  • оркестратор может удалить под или ноду, чтобы освободить ресурсы, и таймеры в памяти пропадут.

Отложенное сообщение в брокере не привязано к конкретному процессу. Оно лежит в очереди на диске, а забирает его любой свободный обработчик. Если система уже упирается в нагрузку и задачи копятся, начните с разбора что делать, если система не справляется с нагрузкой.

Способ 1: TTL + Dead Letter Exchange

Идея простая: публикуем сообщение в обменник, за которым стоит очередь без потребителей. Она только держит сообщения, пока не истечёт срок жизни (TTL). Когда срок вышел, RabbitMQ переносит сообщение в «мёртвый» обменник (dead letter exchange, DLX). Им назначен рабочий обменник, где ждут обработчики. Это единственный способ, который без изменений работает на любой версии RabbitMQ, поэтому в переносимом коде мы начинаем с него.

Схема отложенных сообщений через TTL и Dead Letter Exchange в RabbitMQ и ловушка головы очереди

Рисунок 2. Сообщение ждёт TTL в очереди ожидания, затем RabbitMQ переносит его в рабочую очередь с исходным ключом маршрутизации.

Шаг 1. Создаём два обменника

Рабочий обменник hello нужен обработчикам, обменник ожидания helloDelayed держит задержку.

// broker/const/exchanges.ts
export const HELLO_EXCHANGE = Object.freeze({
  name: 'hello',
  type: 'direct',
  options: { durable: true },
  queues: {},
});

export const HELLO_DELAYED_EXCHANGE = Object.freeze({
  name: 'helloDelayed',
  type: 'direct',
  options: { durable: true },
  queues: {},
});

Шаг 2. Создаём по очереди в каждом обменнике

Ключ привязки (binding) у очередей одинаковый, имена разные. Очередь ожидания получает аргумент x-dead-letter-exchange с именем рабочего обменника: туда брокер отправит сообщение, когда истечёт его срок.

// очереди HELLO_EXCHANGE
queues: {
  WORLD: {
    name: 'hello.world',          // на эту очередь подписываются обработчики
    binding: 'hello.world',
    options: { durable: true, arguments: { 'x-queue-type': 'quorum' } },
  },
},

// очереди HELLO_DELAYED_EXCHANGE
queues: {
  WORLD: {
    name: 'helloDelayed.world',
    binding: 'hello.world',
    options: {
      durable: true,
      arguments: {
        'x-queue-type': 'quorum',                      // реплики на нескольких узлах
        'x-dead-letter-exchange': HELLO_EXCHANGE.name, // куда уйдёт сообщение после истечения TTL
      },
    },
  },
},

В версии 2022 года мы ставили очереди ожидания режим lazy, чтобы сообщения лежали на диске. В RabbitMQ 4.x классического lazy-режима больше нет, а quorum-очереди и так пишут сообщения на диск и реплицируют их, поэтому обе очереди объявляем как quorum.

Шаг 3. Публикуем сообщение со сроком жизни

// broker/hello/publisher.ts
export const publishHelloDelayedWorld = createPublisher({
  exchangeName: HELLO_DELAYED_EXCHANGE.name,
  queue: HELLO_DELAYED_EXCHANGE.queues.WORLD,
  expirationInMs: 30_000,   // сообщение «умрёт» и уйдёт в рабочую очередь через 30 секунд
});

Шаг 4. Подписываемся на рабочую очередь

// broker/hello/consumer.ts
export const initHelloExchange = () => Promise.all([
  createConsumer(
    { queueName: HELLO_EXCHANGE.queues.WORLD.name, prefetch: 50, log: true },
    controller.consumeHelloWorld,
  ),
]);

// broker/hello/controller.ts
export const consumeHelloWorld: IBrokerHandler = async ({ payload }) => {
  const result = await world({ name: payload.name });
  logger.info(result.message);
  // для периодической задачи снова отправляем сообщение в очередь ожидания:
  // await publishHelloDelayedWorld({ name: payload.name });
};

Последняя строка обработчика заменяет cron: если в конце обработки снова отправить сообщение в очередь ожидания, задача будет повторяться с заданным интервалом. Цикл переживает перезапуск узлов, потому что сообщение всё время лежит в надёжной реплицируемой очереди.

Ловушка головы очереди

Отложенное сообщение может прийти позже, чем нужно: очередь RabbitMQ работает по принципу FIFO, а TTL проверяется только у сообщения в голове очереди. Пример:

  1. Публикуем сообщение A с TTL 1 час. Оно встаёт в голову очереди ожидания.
  2. Через секунду публикуем сообщение B с TTL 1 минута.
  3. Через минуту срок B истёк, но RabbitMQ перенесёт его, только когда истечёт A. B опоздает примерно на 59 минут.

Есть два чистых решения. Первое — отдельная очередь на каждую ступень задержки: retry.5s, retry.30s, retry.5m, retry.1h. У всех сообщений внутри очереди одинаковый TTL, блокировать нечему. Это стандартная схема ступенчатых повторов. Второе — задержка на уровне сообщения: нативная в 4.4, повторы quorum-очередей в 4.3 или форк плагина на старых версиях. Там сообщения выходят по времени готовности, порядок прихода не важен.

Способ 2: плагин x-delayed-message

Плагин добавляет обменник типа x-delayed-message: задержку в миллисекундах передают заголовком x-delay при публикации, и плагин сам доставит сообщение в нужную очередь, когда время выйдет. Нужны всего один обменник, одна очередь, один издатель и один потребитель. Сообщения выходят по мере истечения задержки, поэтому сообщение на минуту, опубликованное после сообщения на час, придёт первым.

Статус на ноябрь 2026 года. Команда RabbitMQ перевела официальный репозиторий плагина в архив: плагин хранил сообщения в Mnesia, а Mnesia полностью убрали в RabbitMQ 4.3 (апрель 2026 года). Официальная сборка на 4.3 и новее не загрузится. Компания CloudAMQP поддерживает форк плагина: он хранит сообщения в локальном хранилище Leveled и требует RabbitMQ 4.3.3 или новее, а версия форка 4.2.6 — последняя на Mnesia и мост для миграции кластеров 4.2.

Установка форка: скачайте файл .ez под свою серию RabbitMQ со страницы релизов форка, положите его в папку плагинов и включите плагин.

# Сборка форка CloudAMQP под вашу серию (4.3.3+ или v4.2.6 для 4.2.x)
rabbitmq-plugins directories -s          # где лежит папка плагинов
# копируем rabbitmq_delayed_message_exchange-*.ez в эту папку, затем:
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

Объявляем обменник. Аргумент x-delayed-type задаёт, как маршрутизировать сообщение после задержки: direct, topic или fanout.

// broker/const/exchanges.ts
export const HELLO_PLUGIN_DELAYED_EXCHANGE = Object.freeze({
  name: 'helloPluginDelayed',
  type: 'x-delayed-message',
  options: {
    durable: true,
    arguments: { 'x-delayed-type': 'direct' },
  },
  queues: {
    WORLD_PLUGIN_DELAYED: {
      name: 'helloPluginDelayed.world',
      binding: 'helloPluginDelayed.world',
      options: { durable: true },
    },
  },
});

Издатель передаёт задержку, потребитель ничем не отличается от обычного:

// broker/hello/publisher.ts
export const publishHelloPluginDelayedWorld = createPublisher({
  exchangeName: HELLO_PLUGIN_DELAYED_EXCHANGE.name,
  queue: HELLO_PLUGIN_DELAYED_EXCHANGE.queues.WORLD_PLUGIN_DELAYED,
  delayInMs: 60_000,   // доставить через 60 секунд
});

// под капотом amqplib публикует так:
// channel.publish('helloPluginDelayed', routingKey, payload, {
//   headers: { 'x-delay': 60000 },
// });

Обновляете кластер 4.2 с отложенными сообщениями? По README форка: поставьте форк 4.2.6 на все узлы до включения флага khepri_db, иначе сообщения из Mnesia не переедут; затем переходите на RabbitMQ 4.3.3+ с соответствующей сборкой форка. Плагин посреди обновления не выключайте и сначала прогоните сценарий на тестовом кластере.

Ограничения плагина

README плагина честно пишет, где он ломается. Прочитайте это до того, как строить на нём продакшен:

  1. Только короткие задержки. Плагин задуман для задержек на секунды, минуты и часы, «день-два максимум». Для расписаний на недели он не подходит.
  2. Одна копия на одном узле. Отложенные сообщения не реплицируются: они переживают перезапуск узла, но потеря узла теряет и сообщения. Флаг mandatory не поддерживается.
  3. Мягкий потолок около 100 тысяч. По README, архитектура не рассчитана на сотни тысяч и миллионы отложенных сообщений. Таймеры приблизительные, точности до миллисекунды не ждите.
  4. Отключение плагина удаляет всё, что ещё не доставлено. Перед отключением очередь нужно вычерпать.
  5. Это мост, а не цель. Новый проект на 4.4 стоит начинать с нативной задержки, повторов quorum-очередей или TTL + DLX.
Потолки ёмкости способов задержки RabbitMQ: плагин около 100 тысяч, quorum-очереди миллионы, Tanzu 100 млн и больше

Рисунок 3. Сколько отложенных сообщений выдержит каждый способ: порядок величины на ноябрь 2026 года.

Уходите с архивного плагина?

Мы переносили продакшен-конвейеры с плагина на quorum-очереди и TTL + DLX без потери сообщений. Покажите топологию — наметим безопасный путь миграции.

Обсудить проект →Позвонить →Написать на почту →

Способ 3: повторы quorum-очередей в RabbitMQ 4.3

В RabbitMQ 4.3 (23 апреля 2026 года) quorum-очереди научились сами откладывать повторы. Если обработчик вернул сообщение с ошибкой, очередь не гоняет его через DLX и не публикует заново, а держит внутри себя и выдаёт снова только после паузы. Сообщение не переписывается, дубли не появляются, всё реплицируется через Raft. Для самой частой задачи, повтора после сбоя, это теперь лучший вариант (анонс RabbitMQ 4.3).

Настраивается тремя аргументами очереди или политикой. Пауза растёт линейно с числом неудачных попыток: min(delayed-retry-min × delivery-count, delayed-retry-max).

# RabbitMQ 4.3+: откладываем только неудачные доставки, 30 с -> 60 с -> 90 с -> 120 с (потолок)
rabbitmqctl set_policy delayed-retry "^orders\." \
  '{"delivery-limit":20,
    "delayed-retry-type":"failed",
    "delayed-retry-min":30000,
    "delayed-retry-max":120000}' \
  --apply-to queues

// То же аргументами при объявлении очереди (amqplib):
await channel.assertQueue('orders.process', {
  durable: true,
  arguments: {
    'x-queue-type': 'quorum',
    'x-delayed-retry-type': 'failed',   // 'all' | 'returned' | 'failed'
    'x-delayed-retry-min': 30000,       // 30 с
    'x-delayed-retry-max': 120000,      // потолок 120 с
  },
});
// Неудачная доставка (reject с возвратом в очередь) запускает паузу.
Линейная задержка повторов в quorum-очередях RabbitMQ 4.3: 30, 60, 90, 120 и 120 секунд

Рисунок 4. Повторы quorum-очереди: каждая неудачная попытка ждёт дольше, пока пауза не упрётся в delayed-retry-max.

С min = 30 с и max = 120 с сообщение, которое продолжает падать, придёт снова через 30, 60, 90, а затем каждый раз через 120 секунд. Нужно точное время для одного сообщения, например сторонний API ответил 429 с заголовком Retry-After? Потребитель на AMQP 1.0 может задать его аннотацией x-opt-delivery-time. Ещё одно полезное изменение 4.3: очередь считает отдельно acquired-count (все возвраты) и delivery-count (только неудачи), поэтому обычные возвраты больше не приближают сообщение к лимиту delivery-limit (по умолчанию 20).

Ограничение одно: это повторы. Пауза привязана к числу попыток, а не к моменту «отправь в 15:00». Для настоящей задержки по времени нужна нативная задержка 4.4, форк плагина на 4.3 или внешний планировщик.

Способ 4: нативная задержка в RabbitMQ 4.4

Без плагина RabbitMQ умеет откладывать сообщения с версии 4.4, которая вышла 20 октября 2026 года. Любая quorum-очередь принимает сообщение с меткой x-opt-delivery-time (время доставки в миллисекундах Unix) и прячет его от потребителей до этого момента. Плагин, особый тип обменника и аргументы очереди не нужны (анонс RabbitMQ 4.4).

Маршрутизация происходит в момент публикации, очередь подтверждает сообщение, когда реплицировала его, и никакой внутренней повторной публикации потом нет. Значит, нет и шанса потерять сообщение по дороге. В AMQP 1.0 время передаётся аннотацией сообщения, клиенты AMQP 0-9-1 передают его заголовком типа long (по release notes 4.4.0).

// RabbitMQ 4.4+: своя задержка у каждого сообщения в quorum-очереди, без плагина (amqplib, AMQP 0-9-1)
await channel.assertQueue('reminders', {
  durable: true,
  arguments: { 'x-queue-type': 'quorum' },
});

const deliverAt = Date.now() + 24 * 60 * 60 * 1000;   // абсолютное время, Unix ms
channel.sendToQueue('reminders', Buffer.from(JSON.stringify(job)), {
  persistent: true,
  messageId: job.eventId,                              // для идемпотентных обработчиков
  headers: { 'x-opt-delivery-time': { '!': 'long', value: deliverAt } },
});

// AMQP 1.0 (Java-клиент RabbitMQ AMQP 1.0), та же идея:
// publisher.message(body).annotation("x-opt-delivery-time", deliverAt);

Что учесть, прежде чем переносить таймеры на нативную задержку:

  1. Только quorum-очереди. Классические очереди и стримы эту функцию не поддерживают.
  2. Отложенные сообщения входят в лимит длины очереди. Если очередь ограничена x-max-length, гора будущих напоминаний вытеснит живую работу. Дайте отложенным сообщениям свою очередь.
  3. Их видно. В Management UI появилась колонка Delayed, очередь будущих таймеров видна без отдельной метрики плагина.
  4. Ёмкость не опубликована. Анонс 4.4 не называет потолок. Прежде чем переносить больше 100 тысяч таймеров, проведите нагрузочный тест на своём объёме, а расписания на дни вперёд пока держите в базе данных.
  5. Откладывать может и потребитель. В 4.4 появились deferred messages: потребитель паркует сообщение с токеном до 256 байт и забирает его позже, а x-opt-delivery-time служит крайним сроком, после которого сообщение снова доступно всем.

Как перейти на RabbitMQ 4.4 с плагина

Переход стоит планировать заранее: у веток 4.x короткий срок бесплатной поддержки, а плагин на 4.4 есть только в виде форка.

Сроки поддержки. По странице релизов RabbitMQ бесплатная поддержка 4.3 заканчивается 31 января 2027 года, 4.4 — 31 июля 2027 года (проверено в ноябре 2026 года). Путь с плагином на 4.2 такой: форк 4.2.6, затем 4.3, затем 4.4, после чего таймеры по одной очереди переносятся с обменника на нативную задержку.

Когда RabbitMQ не подходит

RabbitMQ закрывает большую часть задач с задержкой, которые мы видим. Остальное лучше отдать инструментам, сделанным под конкретную нишу:

  1. Temporal (или Cadence). Движок бизнес-процессов с таймерами, повторами и компенсациями. Подходит для многошаговых процессов, которые ждут днями и неделями: онбординг, возвраты, согласования.
  2. Yandex Message Queue и Amazon SQS. Управляемые очереди с задержкой, но не больше 15 минут на сообщение (документация Yandex Cloud; у SQS DelaySeconds от 0 до 900). Для более долгих задержек у AWS есть EventBridge Scheduler.
  3. Azure Service Bus. Отложенная постановка в очередь (ScheduledEnqueueTime) на дни и недели без плагинов.
  4. Redis (сортированное множество) и воркер. Ключ — время готовности, воркер раз в секунду забирает созревшие задачи. Так работают BullMQ, Sidekiq и Celery beat. Быстро и просто, но эксплуатация на вас.
  5. Таблица в PostgreSQL. Колонка due_at и воркер, который опрашивает её каждые 5 секунд. При тысяче задержек в сутки этого хватает, а историю легко проверить.
  6. Tanzu RabbitMQ Delayed Queues. Коммерческий преемник плагина от Broadcom: репликация через Raft, x-opt-delivery-time и x-opt-delivery-delay, сотни миллионов отложенных сообщений и поддержка вендора.

Простое правило: RabbitMQ — для «сейчас плюс X в пределах нескольких часов», а не для «каждый вторник в 9:00». Календарные расписания отдайте Kubernetes CronJob или облачному планировщику.

Где запускать RabbitMQ в 2026 году

Для российского продукта чаще всего RabbitMQ разворачивают сами: на своих серверах или виртуальных машинах в российском облаке. Так проще с 152-ФЗ, если в сообщениях есть персональные данные, и с оплатой. Готовый образ в маркетплейсе Yandex Cloud — RabbitMQ 3, поэтому под нативную задержку 4.4 версию ставят самостоятельно.

ВариантЦена на стартеКакие задержки доступныКому подходит
Свой кластер (серверы или ВМ в российском облаке)Только инфраструктураВсё из открытой версии: TTL + DLX, повторы 4.3, нативная задержка 4.4Командам с DevOps и требованиями 152-ФЗ
CloudAMQPБесплатно для разработки; выделенный узел от $50, кластер из 3 узлов от $297 в месяц (cloudamqp.com, ноябрь 2026)TTL + DLX, повторы quorum-очередейЗарубежным продуктам, которым нужен быстрый старт
Amazon MQ for RabbitMQПочасовая оплата узлов, считайте в калькуляторе AWSTTL + DLX, повторы 4.3 (с сентября 2026 года)Продуктам, целиком живущим в AWS
Tanzu RabbitMQ (Broadcom)Цена по запросуРеплицируемые Delayed Queues на 100 млн+Крупным компаниям с требованиями к поддержке

Как мы сделали это в Vodeo

Мы применяли отложенные сообщения во многих проектах. Самый показательный — интернет-кинотеатр Vodeo для Janson Media: прокат фильмов в цифровом формате. RabbitMQ закрывал три главные функции сервиса: SMS и письма с напоминанием об окончании аренды, уведомления об оплате через сокет с показом сообщения пользователю и передачу загруженных видео на дальнейшую обработку.

Сначала напоминания жили на одном Node.js-сервере с node-schedule. Когда за балансировщиком появился второй сервер приложений, таймеры стали срабатывать дважды или не срабатывать вовсе, в зависимости от того, какой узел перезапускался. Мы перенесли каждое расписание в отложенный обменник, а обработчик сделали идемпотентным по ID события. Напоминания и вебхуки разнесли по разным обменникам, а самые нагруженные очереди повторов вебхуков перевели на TTL + DLX. Сегодня эти повторы переносятся на встроенные повторы quorum-очередей, а напоминания — на нативную задержку 4.4: схема становится проще.

Такой событийный контур мы проектируем вместе с видеочастью в разработке OTT- и IPTV-платформ. Как устроена такая платформа целиком, от загрузки видео до счёта за CDN, разобрано в курсе «OTT-платформа», а взгляд заказчика на этот проект — в отзыве CEO Vodeo.

Идемпотентность обязательна

RabbitMQ гарантирует доставку «хотя бы один раз». В конвейерах с задержкой повторы, повторные публикации и переключение узлов могут доставить сообщение дважды. Поэтому каждый обработчик отложенных задач должен быть идемпотентным, иначе при первом же перезапуске узла пользователь получит два одинаковых письма. Схема, которую мы ставим в каждый проект:

  • у каждого сообщения стабильный event_id: UUID или естественный ключ вроде reminder:rental:123:24h;
  • обработчик пишет строку «событие обработано» в PostgreSQL в той же транзакции, что и само действие;
  • уникальный индекс по event_id превращает вторую доставку в пустую операцию;
  • для действий вне транзакции, например отправки письма, проверяем колонку sent_at и берём короткую блокировку в Redis.

Мониторинг: три метрики

Снимайте метрики RabbitMQ в Prometheus каждые 15–30 секунд. Три алерта закрывают сбои, которые мы встречаем в продакшене:

  • Задержка доставки. p99 от публикации до обработки по каждой отложенной очереди. Если 30-секундная задержка приходит с p99 в 2 минуты, планировщик не успевает. Алерт ставьте на p99 больше трёх заданных задержек.
  • Глубина очереди «мёртвых» сообщений. Каждое сообщение там означает задачу, от которой обработчик отказался. Любое ненулевое значение в рабочее время требует разбора.
  • Доля повторных доставок. Если значение устойчиво не равно нулю, это след бесконечного цикла повторов «ядовитого» сообщения. На 4.3 ограничьте его через delivery-limit, чтобы такое сообщение уходило в DLQ.

Пять ошибок, которые мы находим в аудитах

  1. Одна очередь TTL + DLX на все ступени повторов. Короткие задержки застревают за длинными. Решение — очередь на ступень или повторы quorum-очередей на 4.3+.
  2. Новый проект на архивном плагине. Официальную сборку никто не поддерживает, а форк хранит одну копию сообщения. На 4.4 начинайте с нативной задержки.
  3. Нет идемпотентности. Event_id и таблица обработанных событий нужны с первого дня. Добавлять их после жалоб на двойные уведомления куда больнее.
  4. Расписания на дни вперёд через брокер. Память растёт вместе с числом отложенных сообщений. Долгие расписания храните в PostgreSQL или Temporal и отдавайте в RabbitMQ, когда до срока остаются часы.
  5. Никто не разбирает DLQ. Мы получали проекты, где очередь «мёртвых» сообщений не разбирали годами. Архивируйте её, ставьте алерт на глубину и держите инструмент повторной отправки.

Такие ошибки быстрее всего видны на аудите кода: он показывает, где обработчики не идемпотентны и где повторы крутятся по кругу. Если цикл повторов уже съедает процессор в продакшене, этим занимается наша команда по доработке и оптимизации ПО.

Частые вопросы

Как сделать отложенное сообщение в RabbitMQ?

На RabbitMQ 4.4+ опубликуйте сообщение в quorum-очередь с заголовком x-opt-delivery-time — временем доставки в миллисекундах Unix. На более старых версиях используйте TTL + Dead Letter Exchange: очередь ожидания со сроком жизни сообщения, которая после истечения срока переносит его в рабочую очередь.

Поддерживает ли RabbitMQ отложенные сообщения без плагина?

Да, с версии 4.4 (20 октября 2026 года): quorum-очереди принимают x-opt-delivery-time и выдают сообщение потребителям в заданное время. В 4.3 без плагина доступны только повторы с задержкой, а TTL + DLX работает на всех версиях.

Работает ли плагин rabbitmq_delayed_message_exchange в 2026 году?

Официальный плагин в архиве: он хранил данные в Mnesia, которую удалили в RabbitMQ 4.3. На 4.3.3+ работает форк CloudAMQP, но он хранит одну копию сообщения на одном узле. Для новых проектов на 4.4 берите нативную задержку.

Чем TTL + DLX отличается от плагина x-delayed-message?

TTL + DLX собран из штатных механизмов брокера, реплицируется в quorum-очередях и держит миллионы сообщений, но задержка одна на очередь. Плагин даёт свою задержку каждому сообщению, но держит около 100 тысяч сообщений и не реплицирует их.

Почему отложенное сообщение пришло позже, чем нужно?

Скорее всего, сработала ловушка головы очереди: в TTL + DLX срок проверяется только у первого сообщения, и короткая задержка ждёт длинную. Сделайте отдельную очередь на каждую ступень задержки или перейдите на задержку на уровне сообщения.

Как сделать повтор с задержкой (retry) в RabbitMQ?

На RabbitMQ 4.3+ включите у quorum-очереди delayed-retry-type, delayed-retry-min и delayed-retry-max: пауза растёт линейно с числом неудачных попыток до потолка. На старых версиях используйте цепочку очередей TTL + DLX по ступеням, например 5 с, 30 с и 5 минут.

На какой срок можно откладывать сообщения в RabbitMQ?

Надёжно — на секунды, минуты и часы. Плагин рассчитан максимум на день-два, а ёмкость нативной задержки 4.4 пока не опубликована. Задержки на дни и недели храните в базе данных, Temporal или облачном планировщике.

Можно ли использовать Yandex Message Queue для отложенных задач?

Да, если задержка не больше 15 минут: это предел и для очереди с задержкой, и для отдельного сообщения. Для более долгих задержек нужен свой RabbitMQ, таблица в PostgreSQL или планировщик задач.

Читать дальше

Что делать, если система не справляется с нагрузкой?

Система не справляется с нагрузкой? Узнайте, как стресс-тесты и проверка кода помогут избежать полного переписывания — в нашей статье

Читать дальше

Что такое Traefik: настройка v3 в Docker и Kubernetes

Traefik — обратный прокси для Docker и Kubernetes. Разбор v3.7: traefik.yml и compose, Let’s Encrypt, wildcard через Selectel и Яндекс, сравнение с NGINX.

Читать дальше

Как выбрать решение для чата: Firebase, SendBird или Node.js с Socket.IO?

В статье разбираем популярные способы создания чатов — с плюсами и минусами каждого. От команды мультимедиа-разработчиков.

Читать дальше

Канареечный релиз и фича-флаги: как обновлять приложения без простоев

Канареечный релиз, фича-флаги, поэтапная раскатка в App Store, Google Play и RuStore, OTA и принудительные обновления: как выпускать версии без простоев.

Читать дальше

Как выбрать подрядчика для OTT-платформы в 2026: 12 модулей, 10 вопросов и сроки

Как выбрать подрядчика для OTT-платформы в 2026 году: 12 модулей, 10 вопросов, оценочная карта, сроки с ИИ и без, оплата, CDN и закон в России.

Итог: какой способ задержки выбрать в 2026 году

На RabbitMQ 4.4 своя задержка у каждого сообщения делается штатно: x-opt-delivery-time в quorum-очереди. Повторы после ошибок на 4.3+ отдайте встроенным повторам quorum-очередей. TTL + DLX остаётся переносимым вариантом для любой версии, если помнить про очередь на каждую ступень. Плагин x-delayed-message держите только как мост на старых кластерах и планируйте уход с него.

Чаще всего ошибаются вокруг выбора способа: нет идемпотентности, никто не смотрит в DLQ, а расписания на недели лежат в брокере. Закройте эти три пункта, и отложенные сообщения перестанут теряться и дублироваться.

Спроектируем отложенные задачи под ваш RabbitMQ

30 минут с архитектором Фора Софт: приходите со схемой очередей и версией брокера, уходите с планом — какие задержки переносить на 4.4, что оставить на TTL + DLX и где нужна идемпотентность.

Обсудить проект →Позвонить →Написать на почту →

  • Разработка