📨 Зачем брокер: Kafka или RabbitMQ
Брокер сообщений стоит между сервисами: один кладёт сообщение и сразу идёт дальше, другой забирает его, когда готов. Сервисы перестают ждать друг друга и падать вместе. За неделю 2026-W45 очереди сообщений встречаются в тексте 72% вакансий Go-мидла и 34% вакансий Node.js-мидла, поэтому вопрос «с какими брокерами работал» звучит почти на каждом собеседовании. Здесь разобрано, зачем брокер нужен, чем лог отличается от очереди и как выбрать между Kafka и RabbitMQ. Устройство каждого брокера, гарантии доставки, ретраи и outbox описаны на следующих страницах модуля
🔌 Синхронно или через брокер
Возьмём оформление заказа. После записи заказа нужно зарезервировать товар на складе, отправить письмо, посчитать заказ в аналитике и проверить его в антифроде. Синхронный вариант такой: сервис заказов по очереди вызывает четыре сервиса по HTTP или gRPC и отвечает клиенту после последнего ответа
У этой схемы три слабых места:
- Задержки складываются. Четыре вызова по 50 мс дают 200 мс ответа, хотя клиенту нужен только номер заказа
- Доступность перемножается. Если каждый из четырёх сервисов доступен 99,9% времени, цепочка доступна 0,999⁴ ≈ 99,6%: вместо 9 часов простоя в год получается 35
- Пик проходит насквозь. Распродажа дала в 10 раз больше заказов, и в 10 раз больше запросов получил сервис писем, хотя письмо спокойно может уйти через минуту
С брокером сервис заказов записывает заказ, публикует событие OrderCreated и отвечает клиенту. Склад, письма и аналитика читают событие сами, каждый в своём темпе. Упал сервис писем — сообщения ждут в брокере, заказы продолжают оформляться. Пришёл пик, и брокер становится буфером: потребители разбирают накопленное с той скоростью, которую выдерживают. Новому потребителю достаточно подписаться, сервис заказов о нём даже не узнает
Асинхронность не бесплатна, и на собеседовании ждут, что кандидат назовёт цену:
- Отправитель не получает ответа. Если результат нужен прямо сейчас, например прошла ли оплата, вызов остаётся синхронным
- Данные сходятся не сразу (eventual consistency). Письмо придёт через секунду, а если потребитель отстал, через час, и интерфейс должен это выдерживать
- Сообщение может прийти дважды. Брокеры в обычной настройке доставляют «хотя бы один раз», поэтому потребитель обязан спокойно переживать повтор
- Отладка сложнее. Путь запроса больше не виден в одном стектрейсе, без трейсов через брокер не понять, где застряло событие
- Записать заказ в базу и событие в брокер одной транзакцией нельзя. Эту дыру закрывает transactional outbox
Ещё одно различие пригодится в разговоре об архитектуре. Событие сообщает факт: «заказ создан», и отправителю всё равно, кто его прочитает. Команда просит действия: «отправь письмо», у неё есть конкретный исполнитель. Через брокер ходят и те и другие, путать их нельзя. Мартин Фаулер описывает типичную ловушку: команду маскируют под событие, отправитель на деле ждёт от получателя действия, а связь между сервисами нигде не записана
📜 Лог или очередь
Kafka и RabbitMQ часто ставят в один ряд, но устроены они по-разному, и это главный вопрос раздела
Очередь (RabbitMQ). Сообщение лежит в очереди, пока его не заберёт и не подтвердит один из потребителей. После подтверждения (ack) брокер удаляет сообщение. Несколько потребителей одной очереди конкурируют: каждое сообщение достаётся одному из них. Чтобы одно событие получили и склад, и письма, каждому нужна своя очередь, а копии по ним раскладывает exchange
Лог (Kafka). Сообщения дописываются в конец топика и хранятся по сроку, а не до прочтения: по умолчанию 7 суток (log.retention.hours=168). Чтение ничего не удаляет. Каждая группа потребителей (consumer group) помнит свою позицию в логе, офсет, и читает независимо от других групп. Любая группа может отмотать офсет назад и прочитать историю заново
Обе модели запущены на RabbitMQ 4.3.6 и Kafka 3.9 в Docker, клиенты на Go. В RabbitMQ два воркера разбирают очередь из шести писем, затем fanout exchange раскладывает три заказа по очередям billing и analytics, а очередь late создаётся уже после публикации:
map[worker-A:[email-1 email-4 email-5] worker-B:[email-2 email-3 email-6]]
в очереди после ack: 0
billing 3
analytics 3
late 0Воркеры поделили письма по три, и после подтверждений очередь пуста. Каждая из двух очередей получила свою копию заказов. Очередь late не получила ничего: у очереди нет прошлого, она видит только то, что пришло после её привязки к exchange
В Kafka в топик orders с тремя партициями записаны шесть событий трёх заказов, ключ сообщения — номер заказа. Его читают две группы, потом billing запускается повторно, потом появляются две новые группы: одна с настройками клиента по умолчанию, другая с явным чтением с начала:
billing 6 [p0/0 order-2=created p0/1 order-3=created p0/2 order-2=paid p0/3 order-3=paid p1/0 order-1=created p1/1 order-1=paid]
analytics 6 [p0/0 order-2=created p0/1 order-3=created p0/2 order-2=paid p0/3 order-3=paid p1/0 order-1=created p1/1 order-1=paid]
billing again 0
new group default reset 6
new group from start 6Обе группы получили все шесть событий, копий брокер не делал. Повторный запуск billing ничего не прочитал: группа сохранила офсеты и продолжает с места, где остановилась. Обе новые группы прочитали всю историю. Видно и порядок: события одного заказа легли в одну партицию (order-1 в p1, остальные в p0), и внутри партиции created идёт раньше paid. Порядок Kafka гарантирует только внутри партиции, поэтому всё, что должно обрабатываться по порядку, пишут с одним ключом
Go · Продюсер и группа потребителей Kafka на franz-go
func publishOrderEvent(ctx context.Context, cl *kgo.Client, orderID, event string) error {
// ключ — id заказа: все события одного заказа попадут в одну партицию
rec := &kgo.Record{Topic: "orders", Key: []byte(orderID), Value: []byte(event)}
return cl.ProduceSync(ctx, rec).FirstErr()
}
func consumeBilling(ctx context.Context) error {
cl, err := kgo.NewClient(
kgo.SeedBrokers("localhost:9092"),
kgo.ConsumerGroup("billing"), // у каждого сервиса своя группа и свой офсет
kgo.ConsumeTopics("orders"),
)
if err != nil {
return err
}
defer cl.Close()
for ctx.Err() == nil {
fs := cl.PollFetches(ctx)
fs.EachRecord(func(r *kgo.Record) {
fmt.Printf("p%d/%d %s=%s\n", r.Partition, r.Offset, r.Key, r.Value)
})
}
return ctx.Err()
}Go · Воркер очереди RabbitMQ на amqp091-go
func emailWorker(ch *amqp.Channel, sendEmail func([]byte) error) error {
// не больше одного неподтверждённого сообщения на воркера
if err := ch.Qos(1, 0, false); err != nil {
return err
}
msgs, err := ch.Consume("emails", "", false, false, false, false, nil)
if err != nil {
return err
}
for m := range msgs {
if err := sendEmail(m.Body); err != nil {
m.Nack(false, true) // вернуть в очередь
continue
}
m.Ack(false) // после ack брокер удаляет сообщение
}
return nil
}Сводка различий:
| RabbitMQ, очередь | Kafka, лог | |
|---|---|---|
| Сообщение после чтения | удаляется после ack | хранится до конца срока |
| Несколько потребителей | делят сообщения очереди | делят партиции: в группе одну партицию читает один потребитель |
| Одно событие нескольким сервисам | своя очередь на каждого, копии раскладывает exchange | своя группа на каждого, данные не копируются |
| Перечитать историю | нельзя, если это не stream | отмотать офсет |
| Подтверждение | каждого сообщения | офсетом: «обработал всё до N» |
| Маршрутизация | exchange типов direct, topic, fanout, headers | топик и ключ партиции |
| Порядок | FIFO, пока потребитель один | внутри партиции |
| Предел параллелизма | сколько угодно потребителей | в группе не больше, чем партиций |
⚖️ Как выбрать
Kafka берут, когда сообщения — это поток событий, который читают несколько сервисов. Плюс модели лога в истории: новый сервис стартует с начала топика, сломанную витрину пересобирают, прочитав события заново, а ошибку потребителя воспроизводят на реальных данных. Kafka держит большой поток, потому что пишет на диск последовательно, а позиция группы хранится одним числом на партицию вместо отметки у каждого сообщения. Ещё её выбирают за порядок по ключу: все события одного заказа или пользователя обрабатываются по очереди
RabbitMQ берут для очереди задач: письма, генерация отчётов, обработка загруженных файлов. Каждое сообщение — отдельная работа со своим подтверждением, воркеров добавляют сколько нужно, а медленная задача не держит остальные. У RabbitMQ гибкая маршрутизация через exchange, приоритеты, TTL сообщений и dead letter exchange из коробки. Для небольшой нагрузки его проще поднять и сопровождать
Граница между моделями размывается. В RabbitMQ есть streams: лог с повторным чтением и офсетами, но без TTL, приоритетов и dead letter exchange. В Kafka 4.2 (февраль 2026) стали готовы к продакшену share groups, они же «очереди для Kafka»: сообщения подтверждаются по одному, и потребителей в группе может быть больше, чем партиций. На собеседованиях пока спрашивают классические модели, но упомянуть новые возможности полезно
В вакансиях Go Kafka упоминается в 6,5 раза чаще RabbitMQ, поэтому Kafka учат глубоко, а RabbitMQ на уровне модели и основных настроек
Иногда брокер не нужен вовсе. Если задач немного и они живут рядом с данными в Postgres, очередь можно сделать таблицей: воркеры забирают строки через select ... for update skip locked, и задача создаётся в той же транзакции, что и заказ. Ни новой системы, ни проблемы двойной записи. Предел этого подхода — нагрузка на базу и отсутствие подписок: каждого нового потребителя придётся учить читать таблицу
⚠️ Где ошибаются
Делают через брокер то, где нужен ответ. Сервис кладёт запрос в очередь и ждёт ответ в другой очереди с таймаутом. Получается медленный и хрупкий RPC, в котором ошибку не отличить от задержки. Если без ответа дальше не пойти, это синхронный вызов
Считают, что опубликованное сообщение дошло. Без подтверждений от брокера (publisher confirms в RabbitMQ, acks у продюсера Kafka) сообщение теряется при сбое сети или рестарте брокера, а код считает отправку успешной
Пишут в базу, потом в брокер, двумя шагами. Сервис упал между ними, и заказ есть, а события нет, или наоборот. Лечится transactional outbox, ему посвящена отдельная страница модуля
Не проверяют, откуда новая группа начинает читать. В официальном Java-клиенте Kafka auto.offset.reset по умолчанию latest: новый сервис без сохранённого офсета начнёт с конца топика и не увидит историю. В franz-go по умолчанию чтение идёт с начала, это и показал запуск выше. Настройку выставляют явно
Делают из Kafka очередь медленных задач. Обработка сообщения на минуту держит всю партицию, а число параллельных воркеров упирается в число партиций. Для таких задач лучше подходят RabbitMQ, share groups или таблица в Postgres
Не следят за отставанием потребителей. Потребитель встал, сообщения копятся. В Kafka они исчезнут по сроку хранения, не дождавшись обработки. В RabbitMQ разросшиеся очереди съедают память и диск, срабатывает alarm, и брокер блокирует всех, кто публикует, во всём кластере. Отставание (consumer lag) и длину очередей выводят на дашборд и ставят на алерт
🎯 Вопросы с собеседований
Зачем нужен брокер сообщений?
Чтобы сервисы общались асинхронно. Отправитель публикует сообщение и не ждёт обработки, получатель читает, когда готов. Это развязывает сервисы по времени и по доступности: падение потребителя не роняет отправителя, сообщения ждут в брокере. Брокер сглаживает пики, работая буфером, и даёт подписаться на событие любому числу сервисов без изменений в отправителе
Какие плюсы и минусы у асинхронного взаимодействия по сравнению с синхронным?
Плюсы: задержки не складываются по цепочке, отказ одного сервиса не ломает остальных, пики гасятся очередью, новых потребителей добавляют без правок отправителя. Минусы: отправитель не получает ответа, данные согласуются не сразу, сообщения могут дублироваться и приходить не по порядку, отладка сложнее, появляется ещё одна система. Синхронно делают то, без чего нельзя ответить клиенту, остальное выносят в события
Чем Kafka отличается от RabbitMQ?
RabbitMQ — брокер очередей: сообщение удаляется после подтверждения, потребители одной очереди делят сообщения, маршрутизацией занимаются exchange. Kafka — распределённый лог: сообщения хранятся по сроку, а не до прочтения, каждая группа потребителей читает со своего офсета и может перечитать историю. Порядок в Kafka гарантирован внутри партиции, параллелизм группы ограничен числом партиций. Kafka выбирают для потоков событий и истории, RabbitMQ для очередей задач и сложной маршрутизации
Как доставить одно сообщение трём сервисам?
В RabbitMQ публикуют в fanout или topic exchange, а у каждого сервиса своя очередь, привязанная к нему. Брокер кладёт копию в каждую очередь. В Kafka все три сервиса читают один топик, но каждый своей consumer group: данные хранятся один раз, у каждой группы свой офсет. В Kafka новый сервис может прочитать и старые сообщения, в RabbitMQ очередь получит только то, что пришло после её привязки
Можно ли перечитать уже обработанные сообщения?
В Kafka да, пока сообщения не удалены по сроку хранения: группе сдвигают офсет назад, например через kafka-consumer-groups.sh --reset-offsets, или читают топик новой группой с начала. Так пересобирают витрины и исправляют последствия бага в потребителе. В классической очереди RabbitMQ подтверждённое сообщение удалено, перечитать нельзя, для этого в RabbitMQ есть отдельный тип stream
Что будет с сообщениями, если потребитель лежит час?
Они накопятся в брокере, отправитель продолжит работать. В Kafka группа после подъёма продолжит со своего офсета и догонит, если сообщения не успели истечь по сроку хранения. В RabbitMQ сообщения ждут в очереди, неподтверждённые вернутся в очередь и уйдут другому потребителю. Риск в объёме: длинная очередь давит на память и диск брокера, поэтому за отставанием следят алертом
Когда брокер не нужен?
Когда отправителю нужен ответ, чтобы продолжить: такой вызов остаётся синхронным. Когда задач мало и они живут рядом с данными, хватит таблицы-очереди в Postgres с for update skip locked: она создаётся в той же транзакции, что и бизнес-данные, и не добавляет новой системы. Брокер окупается, когда сообщений много, потребителей несколько или нужно развязать сервисы разных команд
Чем событие отличается от команды?
Событие сообщает о факте в прошлом: «заказ создан». Отправитель не знает, кто его прочитает, и ничего от читателей не ждёт. Команда просит сделать конкретное действие: «отправь письмо», у неё один адресат, и отправитель рассчитывает на результат. Если отправитель на самом деле ждёт действия, это команда, и называть её событием значит прятать зависимость между сервисами
📚 Что почитать
- Introduction — официальное введение в Kafka: события, топики, партиции, порядок по ключу и хранение после чтения
- Work Queues — учебник RabbitMQ на Go: round-robin между воркерами, ack, повторная доставка и prefetch
- Streams and Super Streams — как устроен лог внутри RabbitMQ и когда он лучше очереди
- What do you mean by "Event-Driven"? — Мартин Фаулер о четырёх разных вещах, которые называют событийной архитектурой, и о командах под видом событий