🐇 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
| Тип | Как выбирает очереди | Для чего |
|---|---|---|
| direct | routing 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 и потом не меняется
| classic | quorum | stream | |
|---|---|---|---|
| Репликация | нет | 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 и когда их не стоит брать