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

Node.js Road Map

📨 Зачем брокер: Kafka или RabbitMQ

Брокер сообщений стоит между сервисами: один кладёт сообщение и сразу идёт дальше, другой забирает его, когда готов. Сервисы перестают ждать друг друга и падать вместе. За неделю 2026-W45 очереди сообщений встречаются в тексте 72% вакансий Go-мидла и 34% вакансий Node.js-мидла, поэтому вопрос «с какими брокерами работал» звучит почти на каждом собеседовании. Здесь разобрано, зачем брокер нужен, чем лог отличается от очереди и как выбрать между Kafka и RabbitMQ. Устройство каждого брокера, гарантии доставки, ретраи и outbox описаны на следующих страницах модуля

🔌 Синхронно или через брокер

Возьмём оформление заказа. После записи заказа нужно зарезервировать товар на складе, отправить письмо, посчитать заказ в аналитике и проверить его в антифроде. Синхронный вариант такой: сервис заказов по очереди вызывает четыре сервиса по HTTP или gRPC и отвечает клиенту после последнего ответа

У этой схемы три слабых места:

  1. Задержки складываются. Четыре вызова по 50 мс дают 200 мс ответа, хотя клиенту нужен только номер заказа
  2. Доступность перемножается. Если каждый из четырёх сервисов доступен 99,9% времени, цепочка доступна 0,999⁴ ≈ 99,6%: вместо 9 часов простоя в год получается 35
  3. Пик проходит насквозь. Распродажа дала в 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"? — Мартин Фаулер о четырёх разных вещах, которые называют событийной архитектурой, и о командах под видом событий