♻️ Ретраи и DLQ
Обработчик упал на сообщении, и у него три выхода: повторить сразу, повторить позже или отложить сообщение в сторону и идти дальше. Ретраи и dead letter queue (DLQ) — механика этого выбора. На собеседовании по брокерам спрашивают, что делать с сообщением, которое не обрабатывается, и как сделать повтор с задержкой в Kafka, где для этого нет готовой кнопки
🧠 Сначала решить, поможет ли повтор
Ретрай имеет смысл, только если следующая попытка может закончиться иначе. Поэтому первым делом ошибку делят на временную и постоянную
| Ошибка | Поможет ли повтор | Куда сообщение |
|---|---|---|
| таймаут, 503 от соседнего сервиса, обрыв соединения с базой | да, через паузу | повтор с задержкой |
| 429 от внешнего API | да, не раньше Retry-After | повтор с задержкой |
| deadlock или конфликт сериализации в Postgres | да, почти сразу | повтор на месте |
| невалидный JSON, неизвестная версия схемы | нет | сразу в DLQ |
| нарушено бизнес-правило: заказ уже отменён | нет | в DLQ или просто пропустить с логом |
| баг в коде обработчика | нет, пока не выкатят исправление | в DLQ, после фикса вернуть обратно |
Постоянную ошибку бессмысленно повторять: битый JSON не починится от пятой попытки, а сообщение займёт обработчик и отодвинет DLQ на часы. В коде это выглядит как типизированная ошибка, которую обработчик возвращает, а цикл потребителя проверяет через errors.Is
Повторы бывают трёх уровней, и в рабочем сервисе обычно есть все три:
- Повтор на месте. Две-три попытки внутри обработчика с паузой в десятки миллисекунд. Дёшево и закрывает мелкие сбои, но всё это время сообщение держит потребителя: в Kafka стоит вся партиция, в RabbitMQ занят слот prefetch
- Отложенный повтор. Сообщение уходит из основной очереди и возвращается через секунды, минуты или часы. Потребитель свободен и берёт следующие сообщения
- DLQ. Попытки кончились или ошибка постоянная. Сообщение паркуется в отдельной очереди или топике, пока его не разберёт человек
Экспонента и jitter
Паузу между попытками увеличивают: 100 мс, 200, 400 и так до потолка. Так упавший сосед получает время подняться, а не тысячу запросов в секунду от ретраев. Но если сто потребителей упали одновременно, они и повторят одновременно, волной. Поэтому к экспоненте добавляют jitter: пауза выбирается случайно от нуля до текущего потолка
const (
base = 100 * time.Millisecond
maxDelay = 10 * time.Second
)
// backoff возвращает паузу перед попыткой attempt (с нуля): экспонента с потолком и full jitter
func backoff(attempt int) time.Duration {
d := base << attempt // base * 2^attempt
if d <= 0 || d > maxDelay {
d = maxDelay // потолок, заодно защита от переполнения сдвига
}
return rand.N(d) // math/rand/v2: случайно от 0 до d
}Прогон на Go 1.27 для восьми попыток дал паузы 26 мс, 159 мс, 363 мс, 501 мс, 472 мс, 2,2 с, 6,3 с и 3,4 с при потолках от 100 мс до 10 с. Пятая пауза короче четвёртой, и это нормально: важен разброс, а не монотонность
Ретраи на каждом уровне стека перемножаются. В статье AWS о таймаутах и ретраях приведён расчёт: пять слоёв по три повтора дают базе в 243 раза больше запросов, когда она и так лежит. Повторяй в одном месте, а не на каждом этаже
🐇 Повтор с задержкой в RabbitMQ
Классическая схема держится на двух механизмах из страницы «RabbitMQ»: TTL сообщений в очереди и dead letter exchange. Для каждой паузы заводят очередь ожидания без потребителей. У неё задан x-message-ttl, а истёкшие сообщения она отправляет обратно в рабочую очередь
for _, d := range []time.Duration{time.Second, 3 * time.Second} {
ch.QueueDeclare("orders.wait."+d.String(), true, false, false, false, amqp.Table{
"x-queue-type": "quorum",
"x-message-ttl": d.Milliseconds(),
"x-dead-letter-exchange": "", // default exchange
"x-dead-letter-routing-key": "orders", // обратно в рабочую очередь
})
}Воркер при временной ошибке публикует копию в очередь ожидания со своим заголовком-счётчиком x-attempt и только потом подтверждает оригинал. При постоянной ошибке или исчерпанных попытках копия идёт в orders.dlq с текстом ошибки в заголовке. Прогон на RabbitMQ 4.3.6 с четырьмя заказами: o-2 падает дважды, o-3 битый, o-4 падает всегда
0.0s o-1 попытка 1: ok
0.0s o-2 попытка 1: timeout → orders.wait.1s
0.0s o-3 попытка 1: bad json: permanent → orders.dlq
0.0s o-4 попытка 1: timeout → orders.wait.1s
1.0s o-2 попытка 2: timeout → orders.wait.3s
1.0s o-4 попытка 2: timeout → orders.wait.3s
4.1s o-2 попытка 3: ok
4.1s o-4 попытка 3: timeout → orders.dlq
в orders.dlq: 2Битый заказ ушёл в DLQ без попыток, o-2 прошёл с третьего раза через 4 секунды, o-4 попал в DLQ после всех пауз. Между публикацией копии и Ack воркер может упасть, и тогда сообщение окажется и в очереди ожидания, и снова в рабочей. Это обычный at-least-once, обработчик должен быть идемпотентным, как на странице «Гарантии доставки»
Почему очередь на каждую паузу, а не одна очередь с TTL у каждого сообщения? RabbitMQ выбрасывает истёкшее сообщение, только когда оно дошло до головы очереди. Проверка: в одну очередь ожидания положил сообщение с TTL 5 с, следом с TTL 1 с
5.0s пришло «через 5 с»
5.0s пришло «через 1 с»Секундное сообщение простояло пять секунд за пятисекундным. Об этом предупреждает документация TTL, поэтому паузы разводят по разным очередям
В другом варианте воркер отвечает Nack с requeue=false, рабочая очередь через свой DLX отправляет сообщение в очередь ожидания, а та возвращает его обратно. Попытки тогда считает брокер в заголовке x-death, поле count. Цикл без единого отказа брокер выбросил бы как зацикливание, но здесь в каждом круге есть Nack. Пауза в такой схеме одна на рабочую очередь
Нативная задержка. В RabbitMQ 4.4 (октябрь 2026) quorum-очереди научились откладывать доставку сами: продюсер ставит заголовок x-opt-delivery-time с моментом доставки в Unix-миллисекундах, очередь сразу реплицирует и подтверждает сообщение, а потребителю отдаёт в назначенное время. Плагин rabbitmq-delayed-message-exchange, который раньше ставили для задержек, в сентябре 2026 перевели в архив: он хранил отложенные сообщения в одной копии на одном узле и не работает без Mnesia, которую убрали в 4.3. Тот же заголовок на 4.3.6 брокер просто игнорирует: три сообщения с задержками 5 с, 1 с и без задержки пришли в момент публикации
📜 Повтор с задержкой в Kafka
У обычной группы потребителей Kafka нет ни Nack, ни задержки сообщения. Потребитель двигается по партиции офсетами, и пока он повторяет одно сообщение, остальные в этой партиции ждут. Короткий повтор на месте это терпит. Длинный упрётся в max.poll.interval.ms (5 минут по умолчанию), группа выкинет потребителя, и партиция переедет к соседу вместе с проблемой
Поэтому отложенные повторы делают retry-топиками, схему подробно описала Uber в 2018 году. Упавшее сообщение публикуется в orders.retry.2s, коммит офсета в основном топике идёт дальше. Потребитель retry-топика ждёт, пока сообщению исполнится 2 секунды от метки времени, и обрабатывает. Не вышло — следующий уровень orders.retry.1m, потом orders.dlq. Сообщения в retry-топике лежат в порядке поступления, и задержка у всех одинаковая, поэтому ждать приходится только голове. Вместо sleep в цикле потребителя партицию ставят на паузу (PauseFetchPartitions во franz-go, pause в Java-клиенте), иначе снова встаёт вопрос max.poll.interval.ms
Цена — порядок. Прогон на Kafka 3.9.0: в топике четыре события, ключ — номер заказа, o-2 created падает на первой попытке
3.4s [orders] o-1 created: ok
3.4s [orders] o-2 created: timeout → orders.retry.2s
3.4s [orders] o-2 paid: ok
3.4s [orders] o-3 created: ok
5.4s [orders.retry.2s] o-2 created: ok orders/0/1Оплата заказа o-2 обработана на две секунды раньше, чем его создание. Если обработчику это важно, вариантов три. Сделать его терпимым к порядку: paid без created откладывается или сохраняет состояние так, что порядок не важен. Парковать ключ целиком: пока по o-2 что-то лежит в retry, новые события этого ключа отправляются туда же, без обработки. Или повторять на месте до победы, сознательно останавливая партицию, когда порядок дороже задержки
Готовые DLQ в экосистеме Kafka. В Kafka Connect их включают настройками sink-коннектора errors.tolerance=all и errors.deadletterqueue.topic.name, по умолчанию коннектор падает на первой ошибке. В Kafka Streams с версии 4.2 есть errors.dead.letter.queue.topic.name: обработчик исключений сам пишет запись в DLQ с заголовками об ошибке, топике, партиции и офсете. В share groups (очереди поверх Kafka) потребитель отвечает на каждую запись ACCEPT, RELEASE для временной ошибки или REJECT для постоянной. Запись, которую доставили share.delivery.count.limit раз (по умолчанию 5) и так и не приняли, брокер больше не выдаёт, а с Kafka 4.4 может переложить её в DLQ-топик. В обычной группе потребителей DLQ пишет твой код
🗃️ Что делать с DLQ
DLQ, которую никто не смотрит, — медленное удаление сообщений. Работа с ней складывается из четырёх вещей
Что класть. Оригинальное тело и ключ без изменений, плюс заголовки: текст ошибки, откуда сообщение (очередь или топик, партиция и офсет), номер попытки, время, версия сервиса. По одному тексту ошибки потом не поймёшь, какой заказ пострадал
Алерт. На рост DLQ, а лучше на любое сообщение в ней. Без алерта о проблеме узнают от пользователей через неделю
Хранение. Топик DLQ в Kafka живёт по своему retention.ms, и его ставят длиннее, чем у основного, иначе сообщения удалятся до разбора. В RabbitMQ dead-lettering по умолчанию идёт без подтверждений, и сообщение может потеряться по пути в DLQ. Quorum-очереди умеют надёжный режим: dead-letter-strategy: at-least-once и overflow: reject-publish в политике
Возврат. Разбор начинают с группировки по ошибке: сотни сообщений, упавших после одного релиза, обычно чинятся одним фиксом. Чинят код, выкатывают и возвращают сообщения в основную очередь или в первый retry-топик отдельной утилитой, с ограничением скорости. Возврат — это ещё одна повторная доставка, так что без идемпотентного обработчика он создаст дубли
⚠️ Где ошибаются
Повторяют всё подряд. Битое сообщение проходит все пять пауз и попадает в DLQ через час, хотя было ясно с первой попытки. Постоянные ошибки отправляют в DLQ сразу
Делают экспоненту без jitter. После сбоя все потребители повторяют синхронно, и сосед, который только поднялся, ложится под волной ретраев
Подтверждают оригинал до публикации копии. Воркер сделал Ack, упал, копия в очередь ожидания не ушла. Сообщение потеряно без следа. Порядок всегда такой: копия с подтверждением от брокера, потом Ack или коммит офсета
Ставят x-opt-delivery-time на RabbitMQ до 4.4. Ошибки нет, сообщение приходит сразу, и повтор с задержкой молча становится повтором без задержки
Возвращают DLQ в работу разом. Десять тысяч сообщений за секунду кладут ту же зависимость, из-за которой они туда попали
🎯 Вопросы с собеседований
Что такое DLQ и зачем она нужна?
Dead letter queue — отдельная очередь или топик для сообщений, которые не удалось обработать: попытки кончились или ошибка постоянная. Она убирает такие сообщения с пути, чтобы они не блокировали остальные и не крутились бесконечно, и сохраняет их для разбора. В DLQ кладут оригинальное сообщение и заголовки с ошибкой, источником и числом попыток. На неё ставят алерт, а после исправления сообщения возвращают в работу
Какие ошибки стоит повторять, а какие нет?
Повторяют временные: таймауты, 503, обрывы соединения, 429, deadlock в базе. Следующая попытка у них может пройти. Постоянные ошибки повтором не лечатся: невалидный формат, нарушенное бизнес-правило, баг в коде. Их сразу отправляют в DLQ. Баг в коде становится обрабатываемым после фикса, поэтому такие сообщения возвращают из DLQ, когда выкатили исправление
Как сделать повтор с задержкой в RabbitMQ?
Через очередь ожидания без потребителей с x-message-ttl и dead letter exchange, который возвращает истёкшие сообщения в рабочую очередь. На каждую паузу своя очередь, потому что истёкшее сообщение уходит только из головы очереди. Номер попытки хранят в своём заголовке или берут count из x-death. С RabbitMQ 4.4 quorum-очередь умеет откладывать доставку сама по заголовку x-opt-delivery-time. Плагин delayed message exchange больше не поддерживается
Как сделать ретраи в Kafka?
Короткие повторы делают на месте, понимая, что партиция в это время стоит. Длинные выносят в retry-топики: упавшее сообщение публикуется в топик с задержкой, офсет основного топика коммитится, потребитель retry-топика ждёт нужное время от метки сообщения. Уровней обычно несколько, с растущей паузой, последний — DLQ-топик. Ждут через паузу партиции, а не сном в цикле, чтобы не выйти за max.poll.interval.ms
Что происходит с порядком сообщений при ретраях через отдельный топик?
Он ломается: пока упавшее событие ждёт в retry-топике, следующие события того же ключа проходят через основной. Оплата может обработаться раньше создания заказа. Решения: обработчик, которому порядок не важен; парковка всего ключа, пока по нему есть сообщение в retry; или повтор на месте с остановкой партиции, если порядок дороже задержки
Зачем в экспоненциальной задержке jitter?
Без него все клиенты, упавшие в один момент, повторяют тоже в один момент, и нагрузка приходит волнами. Случайная пауза от нуля до текущего потолка размазывает повторы по времени. Экспонента даёт зависимости время подняться, jitter не даёт клиентам синхронизироваться. Ещё у паузы ставят потолок, а у попыток лимит
Что такое poison message и как с ним бороться?
Сообщение, на котором обработчик падает каждый раз, часто вместе с процессом. Без защиты оно возвращается в очередь и роняет воркеры по кругу. В RabbitMQ quorum-очередь считает доставки и после delivery-limit (по умолчанию 20) отправляет сообщение в DLX. В share groups Kafka есть свой лимит доставок, по умолчанию 5. В обычной группе потребителей лимит считает код, а ошибки десериализации сразу отправляют в DLQ, не давая им остановить партицию
Как вернуть сообщения из DLQ в работу?
Сначала понять, почему они там: сгруппировать по ошибке, исправить причину, выкатить. Потом переложить сообщения в основную очередь или в первый retry-топик отдельной утилитой с ограничением скорости, чтобы не уронить зависимость. Обработчик должен быть идемпотентным, потому что часть сообщений могла быть обработана до падения. Сообщения, которые чинить не нужно, удаляют осознанно и с записью, почему
📚 Что почитать
- RabbitMQ: Dead Letter Exchanges — когда сообщение уходит в DLX, что лежит в
x-deathи почему цикл без отказа обрывается - RabbitMQ: Quorum Queues — delivery-limit, надёжный dead-lettering и нативная задержка доставки
- Uber: Building Reliable Reprocessing and Dead Letter Queues with Kafka — исходное описание retry-топиков и работы с DLQ
- AWS: Timeouts, retries and backoff with jitter — почему ретраи эгоистичны, как они перемножаются по слоям и зачем jitter