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

Python Road Map

🐇 RabbitMQ

В вакансиях RabbitMQ встречается в разы реже Kafka: у Go-мидлов за неделю 2026-W45 это 9% против 59%. Но если он есть в стеке компании, на собеседовании спросят конкретику: как сообщение находит очередь, чем topic exchange отличается от direct, что будет с неподтверждённым сообщением и зачем нужен prefetch. Здесь разобрана модель RabbitMQ, типы очередей и подтверждения. Чем очередь отличается от лога Kafka, описано на странице «Зачем брокер: Kafka или RabbitMQ», ретраи и dead letter queue подробно — на странице «Ретраи и DLQ»

🧠 Exchange, binding, очередь

Продюсер в RabbitMQ никогда не пишет в очередь напрямую. Он публикует сообщение в exchange и указывает routing key, строку вроде order.eu.created. Exchange смотрит на свои bindings (привязки очередей с правилом) и кладёт копию сообщения в каждую подходящую очередь. Потребитель читает уже из очереди. Получается три слоя: куда отправили, по какому правилу разложили, откуда читают

Есть и обходной путь, на нём построены все учебники. Default exchange с пустым именем "" автоматически привязан к каждой очереди по её имени. Вызов ch.Publish("", "emails", ...) выглядит как запись в очередь emails, но на деле проходит через этот exchange

Работа с брокером идёт через два уровня соединений. Connection — долгоживущее TCP-соединение с авторизацией, его открывают при старте сервиса. Channel — лёгкое логическое соединение внутри TCP, все операции идут через канал. Принятая схема: одно соединение на сервис и свой канал на каждую горутину, которая публикует или читает. Документация называет публикацию в общий канал из разных потоков небезопасной

🔀 Типы exchange

ТипКак выбирает очередиДля чего
directrouting key сообщения равен ключу привязкизадачи по типу: resize, email
fanoutво все привязанные очереди, ключ не смотритсобытие для всех подписчиков
topicключ сравнивается с шаблоном по словам через точкусобытия с иерархией: сущность, регион, действие
headersпо заголовкам сообщения, x-match равен all или anyредко, когда маршрут не ложится в строку

В шаблоне topic * заменяет ровно одно слово, # — ноль или больше слов. К exchange events привязаны три очереди, и в него опубликованы пять сообщений. Прогон на RabbitMQ 4.3.6 показывает, что досталось каждой очереди

q-created  order.*.created  [order.eu.created]
q-orders   order.#          [order.eu.created order.us.paid order order.eu.created.v2]
q-eu       *.eu.*           [order.eu.created user.eu.created]

Ключ order попал в order.#, потому что # совпадает и с нулём слов. А order.eu.created.v2 не попал в order.*.created: здесь четыре слова, шаблон ждёт ровно три. Одно сообщение order.eu.created получили все три очереди, у каждой своя копия

Самое неприятное поведение exchange связано с сообщением, которое не подошло ни одной привязке. По умолчанию RabbitMQ его молча выбрасывает, и publisher confirm при этом приходит положительный. Проверка на том же exchange с ключом payment.done, которого никто не слушает:

mandatory=false: confirm ack = true
mandatory=true: return 312 NO_ROUTE confirm ack = true

Продюсер в первом случае уверен, что всё отправил. С флагом mandatory брокер возвращает сообщение отправителю с кодом NO_ROUTE, и это можно залогировать или повторить. Второй способ — alternate exchange: exchange, куда уходят все сообщения без маршрута. Опечатка в routing key или забытая привязка в новой версии сервиса тогда видна в очереди, а не теряется

📦 Classic, quorum и stream

Тип очереди задаётся при объявлении аргументом x-queue-type и потом не меняется

classicquorumstream
РепликациянетRaft, по умолчанию 3 репликида
Что после чтенияудаляется после ackудаляется после ackостаётся, читают по офсету
Переживает падение узланет, очередь недоступна, пока узел не вернётсяда, пока живо большинство репликда
Когда братьвременные и exclusive-очереди, ответы на RPCрабочие очереди, данные которых нельзя терятьистория, повторное чтение, огромный fan-out

Quorum queue — выбор по умолчанию для всего, что важно. Она хранит сообщение на нескольких узлах и подтверждает публикацию только после записи на большинство реплик: из трёх реплик очередь переживает потерю одной. Quorum-очереди всегда durable и всегда пишут сообщения на диск, exclusive-очередью быть не могут. Старый способ репликации, зеркалирование classic-очередей, убрали в RabbitMQ 4.0. Если на собеседовании речь о mirrored queues, стоит сказать, что это устаревший механизм

У classic-очереди две независимые настройки надёжности. Очередь должна быть durable, иначе она пропадёт после рестарта брокера. А сообщение должно быть persistent (DeliveryMode: amqp.Persistent), иначе пропадёт оно, хотя очередь останется. Для quorum-очередей этого выбора нет, там всё на диске

У quorum-очередей с версии 4.0 есть delivery-limit, по умолчанию 20. Сообщение, которое столько раз вернулось в очередь неподтверждённым, брокер выбрасывает или отправляет в dead letter exchange, если он настроен. Так одно битое сообщение не крутится вечно. Запуск с x-delivery-limit=3: воркер каждый раз получает сообщение и закрывает канал без ack, как при падении:

crash: доставок=4, в tasks=0, в tasks.dead=true delivery_limit

После четвёртой доставки сообщение ушло в tasks.dead с причиной delivery_limit в заголовке x-first-death-reason. С Nack и requeue=true картина другая. С версии 4.3 такой явный возврат не считается неудачной доставкой, и в прогоне на 4.3.6 сообщение пришло 30 раз подряд и осталось в очереди. Защита от ядовитых сообщений срабатывает на падения воркера, а от собственного бесконечного Nack код защищает себя сам

✅ Подтверждения и prefetch

Потребитель выбирает режим подтверждений при подписке. С autoAck=true брокер считает сообщение доставленным в момент отправки в сеть. Упал воркер посреди обработки — сообщение потеряно. Документация предупреждает, что этот режим небезопасен

С ручными подтверждениями у воркера три ответа:

  • Ack — обработано, брокер удаляет сообщение
  • Nack или Reject с requeue=true — вернуть в очередь, по возможности на прежнее место
  • Nack или Reject с requeue=false — выбросить или отправить в dead letter exchange

Если канал или соединение закрылись, все неподтверждённые сообщения возвращаются в очередь и уходят другому потребителю с флагом Redelivered. Поэтому RabbitMQ даёт at-least-once: воркер, который обработал заказ и упал до Ack, получит его снова. Есть и таймаут: сообщение без подтверждения дольше 30 минут (consumer_timeout) брокер возвращает в очередь, а подписку потребителя отменяет или закрывает его канал. С версии 4.3 таймаут действует только для quorum-очередей

Prefetch (ch.Qos(n, 0, false)) — сколько неподтверждённых сообщений брокер выдаст одному потребителю вперёд. Ноль значит без ограничений. Пусть два воркера читают одну очередь, быстрый тратит на задачу 10 мс, медленный 500 мс, и в очередь приходят 20 задач:

prefetch=0 fast=10 slow=10 за 5.0 с
prefetch=1 fast=19 slow=1 за 0.5 с
prefetch=10 fast=10 slow=10 за 5.0 с

Без ограничения и с prefetch 10 брокер раздал задачи по кругу, поровну, и быстрый воркер простаивал, пока медленный 5 секунд разбирал свои десять. С prefetch 1 медленный держит одну задачу, а остальные достаются тому, кто освободился, и всё заканчивается за полсекунды. В первом прогоне той же программы задачи лежали в очереди до подписки, и при неограниченном prefetch первый подписавшийся воркер забрал все 20 сразу, а второй не получил ни одной

Отсюда правило выбора. Задачи долгие и разные по времени — prefetch маленький, вплоть до 1. Задачи короткие и одинаковые — большой: документация называет значения 100–300 оптимальными для пропускной способности. Без лимита не оставляют никогда: один потребитель вытянет в память всю очередь

С другой стороны тоже нужны подтверждения. Publisher confirms включают на канале вызовом Confirm, и брокер подтверждает каждое сообщение: для persistent-сообщения после записи на диск, для quorum-очереди после записи на большинство реплик. Без них сообщение, отправленное за секунду до рестарта брокера, пропадёт, а код будет считать отправку успешной. Ждать подтверждения после каждой публикации документация называет антипаттерном: это медленно. Подтверждения обрабатывают асинхронно или пачками

Go · Топология, публикация с подтверждением и воркер на amqp091-go

func declareTopology(ch *amqp.Channel) error {
	if err := ch.ExchangeDeclare("orders", "topic", true, false, false, false, nil); err != nil {
		return err
	}
	_, err := ch.QueueDeclare("billing", true, false, false, false, amqp.Table{
		"x-queue-type":           "quorum",
		"x-dead-letter-exchange": "orders.dlx", // сюда уйдут отвергнутые и превысившие лимит
	})
	if err != nil {
		return err
	}
	return ch.QueueBind("billing", "order.*.created", "orders", false, nil)
}

func publish(ctx context.Context, ch *amqp.Channel, key string, body []byte) error {
	// канал переведён в режим подтверждений один раз: ch.Confirm(false)
	dc, err := ch.PublishWithDeferredConfirmWithContext(ctx, "orders", key,
		true, // mandatory: вернуть, если ни одна очередь не подошла
		false,
		amqp.Publishing{DeliveryMode: amqp.Persistent, ContentType: "application/json", Body: body})
	if err != nil {
		return err
	}
	ok, err := dc.WaitContext(ctx)
	if err != nil {
		return err
	}
	if !ok {
		return fmt.Errorf("брокер не принял сообщение %s", key)
	}
	return nil
}

func consume(ch *amqp.Channel, handle func(amqp.Delivery) error) error {
	if err := ch.Qos(50, 0, false); err != nil {
		return err
	}
	msgs, err := ch.Consume("billing", "billing-worker", false, false, false, false, nil)
	if err != nil {
		return err
	}
	for m := range msgs {
		err := handle(m)
		switch {
		case err == nil:
			m.Ack(false)
		case errors.Is(err, errPermanent):
			m.Nack(false, false) // повтор не поможет: в dead letter exchange
		default:
			m.Nack(false, true) // временный сбой: вернуть в очередь
		}
	}
	return errors.New("канал закрыт") // переподключение — забота вызывающего
}

В примере публикация ждёт подтверждения по одному сообщению, чтобы код был коротким. Для большого потока подтверждения собирают пачкой или слушают через NotifyPublish. Возвращённые по mandatory сообщения приходят в канал из NotifyReturn, его нужно читать

⚠️ Где ошибаются

Включают autoAck, потому что так в первом примере. Сообщения теряются при каждом падении или рестарте воркера, и никто этого не замечает, пока не начнут искать пропавшие письма

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

Не включают mandatory и alternate exchange. Новая версия сервиса шлёт order.created вместо order.eu.created, привязка не срабатывает, брокер подтверждает и выбрасывает. Продюсер видит успех, потребитель тишину

Отвечают Nack с requeue=true на любую ошибку. Сообщение возвращается в голову очереди и сразу приходит снова: воркер крутит его в горячем цикле и грузит CPU и брокер. Ошибку, которую повтор не исправит, отправляют в DLX через requeue=false, а для временных делают повтор с задержкой

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

Держат важные данные в classic-очередях кластера. Classic-очередь живёт на одном узле: узел упал, и очередь недоступна, а с ней и все сообщения в ней

🎯 Вопросы с собеседований

Как сообщение попадает от продюсера в очередь?

Продюсер публикует его в exchange с routing key. Exchange проверяет свои привязки: у каждой очереди, привязанной к нему, есть ключ или шаблон. Копия сообщения кладётся в каждую подходящую очередь, и уже оттуда её читает потребитель. Если подходящих очередей нет, сообщение по умолчанию выбрасывается. Публикация «прямо в очередь» на деле идёт через default exchange, привязанный к каждой очереди по её имени

Какие бывают типы exchange?

Direct кладёт сообщение в очереди, у которых ключ привязки равен routing key. Fanout кладёт во все привязанные очереди, не глядя на ключ. Topic сравнивает ключ с шаблонами по словам через точку: * заменяет одно слово, # ноль или больше. Headers выбирает очереди по заголовкам сообщения, с условием all или any. На практике чаще всего используют direct для задач и topic для событий

Что будет с сообщением, если воркер упал, не подтвердив его?

Когда закрывается канал или соединение воркера, брокер возвращает все неподтверждённые сообщения в очередь и отдаёт их другому потребителю с флагом redelivered. Значит, сообщение может быть обработано дважды, и обработчик должен быть идемпотентным. Если воркер жив, но завис, сообщение вернётся по consumer_timeout, по умолчанию через 30 минут. С autoAck сообщение при падении просто потеряно

Что такое prefetch и как выбрать его значение?

Prefetch — сколько неподтверждённых сообщений брокер выдаёт одному потребителю вперёд. Маленькое значение распределяет работу честно: медленный воркер не копит задачи, свободный берёт следующую. Большое значение даёт пропускную способность на коротких одинаковых задачах, документация советует 100–300. Без ограничения не оставляют: один потребитель заберёт в память всю очередь

Чем quorum queue отличается от classic?

Quorum queue реплицируется на несколько узлов по Raft, по умолчанию на три, и работает, пока живо большинство реплик. Публикацию она подтверждает после записи на большинство. Она всегда durable, хранит всё на диске и умеет ограничивать число повторных доставок, по умолчанию 20. Classic queue живёт на одном узле и подходит для временных и exclusive-очередей. Зеркалирование classic-очередей убрали в RabbitMQ 4.0, на смену ему пришли quorum queues

Как не потерять сообщение по пути от продюсера до потребителя?

На каждом шаге своя защита. Публикация: publisher confirms, флаг mandatory или alternate exchange для сообщений без маршрута. Хранение: quorum-очередь, либо durable classic-очередь с persistent-сообщениями. Обработка: ручной ack только после того, как результат сохранён, и идемпотентный обработчик на случай повторной доставки. Разрыв между записью в базу и публикацией закрывает transactional outbox

Что делать с сообщением, которое всё время падает с ошибкой?

Не возвращать его в очередь бесконечно: с requeue=true оно будет крутиться в горячем цикле. Если ошибка постоянная, например неверный формат, воркер отвечает Nack с requeue=false, и сообщение уходит в dead letter exchange, где его разбирают отдельно. Quorum-очередь сама отправит туда сообщение, которое превысило delivery-limit из-за падений воркера. Временные ошибки повторяют с задержкой

Чем connection отличается от channel?

Connection — TCP-соединение с брокером, тяжёлое в установке, его держат открытым всё время работы сервиса. Channel — логическое соединение внутри него, их много и они дешёвые. Все операции идут через канал. Канал не делят между горутинами, у каждой свой, а соединение на сервис обычно одно или несколько

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

  • AMQP 0-9-1 Model Explained — официальное описание модели: exchange, привязки, очереди, соединения и каналы
  • Topics — учебник RabbitMQ на Go про topic exchange и шаблоны * и #
  • Consumer Acknowledgements and Publisher Confirms — ack, requeue, prefetch и подтверждения публикации с объяснением, что гарантирует каждый режим
  • Quorum Queues — как устроены реплицируемые очереди, delivery-limit и когда их не стоит брать