К содержимому
Войти

Python Road Map

♻️ Ретраи и DLQ

Обработчик упал на сообщении, и у него три выхода: повторить сразу, повторить позже или отложить сообщение в сторону и идти дальше. Ретраи и dead letter queue (DLQ) — механика этого выбора. На собеседовании по брокерам спрашивают, что делать с сообщением, которое не обрабатывается, и как сделать повтор с задержкой в Kafka, где для этого нет готовой кнопки

🧠 Сначала решить, поможет ли повтор

Ретрай имеет смысл, только если следующая попытка может закончиться иначе. Поэтому первым делом ошибку делят на временную и постоянную

ОшибкаПоможет ли повторКуда сообщение
таймаут, 503 от соседнего сервиса, обрыв соединения с базойда, через паузуповтор с задержкой
429 от внешнего APIда, не раньше Retry-Afterповтор с задержкой
deadlock или конфликт сериализации в Postgresда, почти сразуповтор на месте
невалидный JSON, неизвестная версия схемынетсразу в DLQ
нарушено бизнес-правило: заказ уже отменённетв DLQ или просто пропустить с логом
баг в коде обработчиканет, пока не выкатят исправлениев DLQ, после фикса вернуть обратно

Постоянную ошибку бессмысленно повторять: битый JSON не починится от пятой попытки, а сообщение займёт обработчик и отодвинет DLQ на часы. В коде это выглядит как типизированная ошибка, которую обработчик возвращает, а цикл потребителя проверяет через errors.Is

Повторы бывают трёх уровней, и в рабочем сервисе обычно есть все три:

  1. Повтор на месте. Две-три попытки внутри обработчика с паузой в десятки миллисекунд. Дёшево и закрывает мелкие сбои, но всё это время сообщение держит потребителя: в Kafka стоит вся партиция, в RabbitMQ занят слот prefetch
  2. Отложенный повтор. Сообщение уходит из основной очереди и возвращается через секунды, минуты или часы. Потребитель свободен и берёт следующие сообщения
  3. 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-топик отдельной утилитой с ограничением скорости, чтобы не уронить зависимость. Обработчик должен быть идемпотентным, потому что часть сообщений могла быть обработана до падения. Сообщения, которые чинить не нужно, удаляют осознанно и с записью, почему

📚 Что почитать