Event Bus vs Message Broker: в чём разница
Когда ты решил использовать события, первый вопрос: как их доставлять? Есть два принципиально разных подхода. Event Bus - это in-process механизм: события передаются внутри одного приложения через каналы или callback-функции. Message Broker - это отдельный сервис (Kafka, RabbitMQ, NATS), который принимает, хранит и доставляет сообщения между разными процессами.
Выбор между ними - это не вопрос «что лучше», а вопрос масштаба задачи. Начинать стоит с самого простого решения, которое работает, и усложнять только когда появляются реальные ограничения.
Event Bus: события внутри процесса
Event Bus живёт в памяти приложения. Это обычная структура с подписчиками и методами Subscribe / Publish. Никакой сети, никаких зависимостей.
package eventbus
import (
"log/slog"
"sync"
)
// Handler - функция-обработчик события
type Handler func(event any)
// Bus - in-process шина событий
type Bus struct {
mu sync.RWMutex
handlers map[string][]Handler
logger *slog.Logger
}
func New(logger *slog.Logger) *Bus {
return &Bus{
handlers: make(map[string][]Handler),
logger: logger,
}
}
// Subscribe регистрирует обработчик для указанного типа события
func (b *Bus) Subscribe(eventType string, h Handler) {
b.mu.Lock()
defer b.mu.Unlock()
b.handlers[eventType] = append(b.handlers[eventType], h)
b.logger.Info("subscriber registered",
slog.String("event_type", eventType),
)
}
// Publish отправляет событие всем подписчикам в отдельных горутинах
func (b *Bus) Publish(eventType string, event any) {
b.mu.RLock()
handlers := b.handlers[eventType]
b.mu.RUnlock()
for i, h := range handlers {
go func(idx int, handler Handler) {
defer func() {
if r := recover(); r != nil {
b.logger.Error("subscriber panicked",
slog.String("event_type", eventType),
slog.Int("subscriber_index", idx),
slog.Any("panic", r),
)
}
}()
handler(event)
}(i, h)
}
}
<?php
// src/Infrastructure/EventBus/InProcessEventBus.php
declare(strict_types=1);
namespace App\Infrastructure\EventBus;
use Psr\Log\LoggerInterface;
use Throwable;
interface EventBus
{
public function subscribe(string $eventClass, callable $handler): void;
public function publish(object $event): void;
}
final class InProcessEventBus implements EventBus
{
/** @var array<class-string, list<callable>> */
private array $handlers = [];
public function __construct(
private readonly LoggerInterface $logger,
) {}
public function subscribe(string $eventClass, callable $handler): void
{
$this->handlers[$eventClass][] = $handler;
$this->logger->info('subscriber registered', ['event_class' => $eventClass]);
}
public function publish(object $event): void
{
foreach ($this->handlers[$event::class] ?? [] as $idx => $handler) {
try {
$handler($event);
} catch (Throwable $e) {
// Один сбойный подписчик не должен ронять остальных.
$this->logger->error('subscriber failed', [
'event_class' => $event::class,
'subscriber_index' => $idx,
'err' => $e->getMessage(),
]);
}
}
}
}
// В Symfony роль EventBus выполняет MessageBusInterface (Messenger).
// Подписчики помечаются #[AsMessageHandler] и автоматически связываются по типу.
# eventbus/bus.py
import logging
import threading
from collections import defaultdict
from typing import Any, Callable
# Handler - функция-обработчик события
Handler = Callable[[Any], None]
class Bus:
"""In-process шина событий."""
def __init__(self, logger: logging.Logger) -> None:
self._lock = threading.Lock()
self._handlers: dict[str, list[Handler]] = defaultdict(list)
self._logger = logger
def subscribe(self, event_type: str, handler: Handler) -> None:
"""Регистрирует обработчик для указанного типа события."""
with self._lock:
self._handlers[event_type].append(handler)
self._logger.info("subscriber registered", extra={"event_type": event_type})
def publish(self, event_type: str, event: Any) -> None:
"""Отправляет событие всем подписчикам в отдельных потоках
(аналог горутин - threading; подписчики в основном ждут I/O, GIL не мешает).
"""
with self._lock:
handlers = list(self._handlers[event_type])
for idx, handler in enumerate(handlers):
threading.Thread(
target=self._safe_call, args=(event_type, idx, handler, event), daemon=True,
).start()
def _safe_call(self, event_type: str, idx: int, handler: Handler, event: Any) -> None:
try:
handler(event)
except Exception:
# Исключение одного подписчика не должно ронять остальных
self._logger.exception(
"subscriber failed", extra={"event_type": event_type, "subscriber_index": idx},
)
Использование:
func main() {
logger := slog.Default()
bus := eventbus.New(logger)
// Подписчик: отправка email
bus.Subscribe("lesson.completed", func(event any) {
e := event.(events.LessonCompleted)
fmt.Printf("Sending email for user %d, lesson %d\n", e.UserID, e.LessonID)
})
// Подписчик: аналитика
bus.Subscribe("lesson.completed", func(event any) {
e := event.(events.LessonCompleted)
fmt.Printf("Tracking completion for lesson %d\n", e.LessonID)
})
// Публикация
bus.Publish("lesson.completed", events.LessonCompleted{
UserID: 42,
LessonID: 7,
})
// Publish не ждёт подписчиков: без паузы main завершится раньше, чем
// горутины что-то напечатают, и события пропадут - так же, как при рестарте сервиса.
time.Sleep(100 * time.Millisecond)
}
<?php
// public/index.php (или bin/console-команда)
declare(strict_types=1);
use App\Domain\Event\LessonCompleted;
use App\Infrastructure\EventBus\InProcessEventBus;
use Psr\Log\NullLogger;
require __DIR__ . '/../vendor/autoload.php';
$bus = new InProcessEventBus(new NullLogger());
// Подписчик: отправка email
$bus->subscribe(LessonCompleted::class, function (LessonCompleted $e): void {
printf('Sending email for user %d, lesson %d', $e->userId, $e->lessonId);
});
// Подписчик: аналитика
$bus->subscribe(LessonCompleted::class, function (LessonCompleted $e): void {
printf('Tracking completion for lesson %d', $e->lessonId);
});
// Публикация
$bus->publish(LessonCompleted::create(
userId: 42,
lessonId: 7,
trackSlug: 'event-driven',
timeSpentSec: 0,
correlationId: 'demo',
));
import logging
import time
from eventbus.bus import Bus
from events.lesson_completed import LessonCompleted
def main() -> None:
logger = logging.getLogger("eventbus")
bus = Bus(logger)
# Подписчик: отправка email
def send_email(event: LessonCompleted) -> None:
print(f"Sending email for user {event.user_id}, lesson {event.lesson_id}")
bus.subscribe("lesson.completed", send_email)
# Подписчик: аналитика
def track_completion(event: LessonCompleted) -> None:
print(f"Tracking completion for lesson {event.lesson_id}")
bus.subscribe("lesson.completed", track_completion)
# Публикация
bus.publish("lesson.completed", LessonCompleted.create(
user_id=42,
lesson_id=7,
track_slug="event-driven",
time_spent=0,
correlation_id="demo",
))
# publish не ждёт подписчиков, а потоки daemon=True: без паузы процесс
# завершится раньше, чем они что-то напечатают, и события пропадут.
time.sleep(0.1)
if __name__ == "__main__":
main()
Достоинства Bus: нулевая латентность, нет внешних зависимостей, легко тестировать. Недостатки: события теряются при перезапуске процесса, нельзя масштабировать подписчиков отдельно.
Message Broker: события между процессами
Message Broker - это отдельный сервис, который принимает сообщения от producer-ов и доставляет их consumer-ам. Основные игроки:
Apache Kafka - распределённый лог. Сообщения хранятся на диске, можно перечитать. Гарантирует порядок внутри partition. Масштабируется через consumer group: Kafka распределяет партиции топика между экземплярами consumer-а одной группы, поэтому больше экземпляров (но не больше, чем партиций) - больше пропускная способность. Подходит для высоких нагрузок (миллионы сообщений/сек).
RabbitMQ - классический брокер с очередями. Сообщения удаляются после обработки. Поддерживает сложный routing (exchanges, bindings). Подходит для задач с разными паттернами доставки.
NATS - минималистичный брокер. Очень быстрый, простой протокол. В базовой версии - at-most-once. NATS JetStream добавляет persistence и at-least-once.
Сравнение
| Характеристика | Event Bus (in-process) | Message Broker (Kafka/RabbitMQ) |
|---|---|---|
| Латентность | Микросекунды | Миллисекунды |
| Durability | Нет - всё в памяти | Да - сообщения на диске |
| Масштабирование | Только вертикальное | Горизонтальное (consumer groups) |
| Failure handling | Паника = потеря событий | Retry, dead letter queue |
| Внешние зависимости | Нет | Нужен отдельный сервис |
| Тестирование | Unit-тесты, всё in-process | Integration-тесты, testcontainers |
| Ordering | Только при синхронном вызове подписчиков; шина с горутиной/потоком на вызов порядок не гарантирует | По partition (Kafka) / по очереди |
| Replay | Невозможен | Kafka: да; RabbitMQ: classic/quorum-очереди нет, Streams (с 3.9) да |
Типизированный Event Bus для продакшна
В реальном проекте хочется типобезопасности. Начинается она не с шины, а с самих событий: пока событие - это map[string]any, никакие generic-и не помогут, поэтому сначала фиксируем структуру доменного события. Вот Bus с generic-подписчиками:
package eventbus
import (
"context"
"fmt"
"log/slog"
"sync"
)
// TypedHandler - типизированный обработчик
type TypedHandler[E any] func(ctx context.Context, event E) error
// Subscription хранит обработчик с типизацией через замыкание
type Subscription struct {
handler func(ctx context.Context, event any) error
}
// TypedBus - шина с поддержкой контекста и ошибок
type TypedBus struct {
mu sync.RWMutex
subs map[string][]Subscription
logger *slog.Logger
}
func NewTypedBus(logger *slog.Logger) *TypedBus {
return &TypedBus{
subs: make(map[string][]Subscription),
logger: logger,
}
}
// Subscribe регистрирует типизированный обработчик
func Subscribe[E any](bus *TypedBus, eventType string, handler TypedHandler[E]) {
bus.mu.Lock()
defer bus.mu.Unlock()
sub := Subscription{
handler: func(ctx context.Context, event any) error {
typed, ok := event.(E)
if !ok {
return fmt.Errorf("unexpected event type: %T", event)
}
return handler(ctx, typed)
},
}
bus.subs[eventType] = append(bus.subs[eventType], sub)
}
// Publish вызывает всех подписчиков, логирует ошибки
func (b *TypedBus) Publish(ctx context.Context, eventType string, event any) {
b.mu.RLock()
subs := b.subs[eventType]
b.mu.RUnlock()
var wg sync.WaitGroup
for _, sub := range subs {
wg.Add(1)
go func(s Subscription) {
defer wg.Done()
if err := s.handler(ctx, event); err != nil {
b.logger.Error("subscriber failed",
slog.String("event_type", eventType),
slog.String("err", err.Error()),
)
}
}(sub)
}
wg.Wait()
}
<?php
// src/Infrastructure/EventBus/TypedEventBus.php
declare(strict_types=1);
namespace App\Infrastructure\EventBus;
use Psr\Log\LoggerInterface;
use Throwable;
// В PHP типобезопасность - через class-string и invokable handlers.
// Типизация подписчика на конкретный event-класс делается через signature `__invoke`.
final class TypedEventBus
{
/** @var array<class-string, list<callable>> */
private array $subs = [];
public function __construct(
private readonly LoggerInterface $logger,
) {}
/**
* @template T of object
* @param class-string<T> $eventClass
* @param callable(T): void $handler
*/
public function subscribe(string $eventClass, callable $handler): void
{
$this->subs[$eventClass][] = $handler;
}
public function publish(object $event): void
{
// PHP-FPM однопоточный per request - подписчики выполняются последовательно.
// Для параллели используй Symfony Messenger с async-транспортом
// (Redis/AMQP) и несколькими worker-процессами.
foreach ($this->subs[$event::class] ?? [] as $handler) {
try {
$handler($event);
} catch (Throwable $e) {
$this->logger->error('subscriber failed', [
'event_class' => $event::class,
'err' => $e->getMessage(),
]);
}
}
}
}
# eventbus/typed_bus.py
import logging
import threading
from collections import defaultdict
from dataclasses import dataclass
from typing import Any, Callable, TypeVar
E = TypeVar("E")
# TypedHandler - типизированный обработчик; ошибка - исключение, а не возвращаемое значение
TypedHandler = Callable[[E], None]
@dataclass(frozen=True)
class Subscription:
"""Хранит обработчик с типизацией через замыкание."""
handler: Callable[[Any], None]
class TypedBus:
"""Шина с ожиданием подписчиков и логированием ошибок."""
def __init__(self, logger: logging.Logger) -> None:
self._lock = threading.Lock()
self._subs: dict[str, list[Subscription]] = defaultdict(list)
self._logger = logger
def subscribe(self, event_type: str, event_cls: type[E], handler: TypedHandler[E]) -> None:
"""Регистрирует типизированный обработчик.
Generic-методы в Python разрешены, поэтому это метод, а не свободная функция.
Компилятора нет: тип события передаём явно (event_cls - это E), проверка
делается isinstance в момент доставки, а mypy сверяет сигнатуру handler.
"""
def typed(event: Any) -> None:
if not isinstance(event, event_cls):
raise TypeError(f"unexpected event type: {type(event).__name__}")
handler(event)
with self._lock:
self._subs[event_type].append(Subscription(handler=typed))
def publish(self, event_type: str, event: Any) -> None:
"""Вызывает всех подписчиков в потоках, ждёт завершения (аналог WaitGroup), логирует ошибки."""
with self._lock:
subs = list(self._subs[event_type])
threads = [
threading.Thread(target=self._run, args=(event_type, sub, event)) for sub in subs
]
for t in threads:
t.start()
for t in threads:
t.join()
def _run(self, event_type: str, sub: Subscription, event: Any) -> None:
try:
sub.handler(event)
except Exception as err:
self._logger.error(
"subscriber failed", extra={"event_type": event_type, "err": str(err)},
)
Использование типизированной подписки:
bus := eventbus.NewTypedBus(slog.Default())
// Компилятор проверяет тип события
eventbus.Subscribe(bus, "lesson.completed",
func(ctx context.Context, e events.LessonCompleted) error {
// e уже типизирован - не нужен type assertion
return sendEmail(ctx, e.UserID, e.LessonID)
},
)
<?php
declare(strict_types=1);
use App\Domain\Event\LessonCompleted;
use App\Infrastructure\EventBus\TypedEventBus;
$bus = new TypedEventBus($logger);
// Сигнатура замыкания фиксирует тип события на этапе static analysis (Psalm/PHPStan)
$bus->subscribe(LessonCompleted::class, function (LessonCompleted $e) use ($emails): void {
// $e уже типизирован - type assertion не нужен
$emails->send($e->userId, $e->lessonId);
});
import logging
from eventbus.typed_bus import TypedBus
from events.lesson_completed import LessonCompleted
bus = TypedBus(logging.getLogger("eventbus"))
# mypy проверяет сигнатуру по event_cls, шина - isinstance при доставке
def on_lesson_completed(e: LessonCompleted) -> None:
# e уже типизирован - isinstance в обработчике не нужен
send_email(e.user_id, e.lesson_id)
bus.subscribe("lesson.completed", LessonCompleted, on_lesson_completed)
Стратегия миграции: Bus сегодня, Broker завтра
Правильный подход - определить интерфейс publisher/subscriber и начать с in-process реализации. Готовый пример такой развязки, где use-case не знает про транспорт, а подписчики регистрируются одной строкой в main.go, разобран в мини-проекте трека:
// Publisher - порт (интерфейс), не привязан к реализации
type Publisher interface {
Publish(ctx context.Context, eventType string, event any) error
}
// Сегодня: InProcessPublisher (EventBus)
// Завтра: KafkaPublisher (без изменения use-case кода)
<?php
// src/Application/Port/EventPublisher.php
declare(strict_types=1);
namespace App\Application\Port;
// Publisher - порт. Use-case зависит от него, не от транспорта.
interface EventPublisher
{
public function publish(object $event): void;
}
// Сегодня: InProcessPublisher (Symfony Messenger sync-транспорт)
// Завтра: AsyncPublisher (Messenger async-транспорт - Redis Streams / AMQP)
// Меняется одна строка в config/packages/messenger.yaml, бизнес-код не трогаем.
# application/ports.py
from typing import Any, Protocol
class Publisher(Protocol):
"""Порт (Protocol), не привязан к реализации."""
def publish(self, event_type: str, event: Any) -> None: ...
# Сегодня: InProcessPublisher (EventBus)
# Завтра: KafkaPublisher (без изменения use-case кода)
Use-case зависит от интерфейса Publisher, а не от конкретной реализации. Когда придёт время Kafka - меняется только DI-конфигурация (Wire), бизнес-логика остаётся нетронутой.
ℹ️ Начни с EventBus, перейди на брокер когда нужно
90% Go-монолитов прекрасно работают с in-process EventBus. Переходи на Kafka/RabbitMQ когда появится хотя бы одно из: (1) нужна гарантия доставки при перезапуске, (2) нужно масштабировать consumer-ы горизонтально, (3) появился второй сервис, которому нужны события первого.
⚠️ Kafka - не база данных
Kafka хранит сообщения, но это не замена PostgreSQL. Retention period по умолчанию - 7 дней. Не рассчитывай на Kafka как на permanent storage. Для event sourcing нужен отдельный event store.
Типичные ошибки
- Брокер «потому что серьёзный проект» - Kafka на старте маленького сервиса = месяцы пробоя operations (топологии, KRaft-контроллеры, ACL, мониторинг) при том же бизнес-результате, что EventBus на каналах. Брокер ставят, когда прижала потребность (durability, multi-consumer, бэкэп нагрузки).
- In-process EventBus без panic recovery - неперехваченная panic в горутине подписчика завершает весь процесс Go: падают все запросы и все подписчики, а события в памяти теряются. Оборачивай каждый вызов подписчика в
defer recover()+ лог, как вPublishвыше. - Использовать
chanкак «бесконечную очередь» -chan Eventс буфером 1000 однажды заполнится; publisher заблокируется, HTTP-запросы зависнут. Чёткий контракт: либо ограниченный буфер + drop policy при overflow, либо очередь в БД. - Брокер выбран по «модности», не по семантике - Kafka хороша для upstream-логов и event sourcing (партиции, retention, replay), RabbitMQ - для рабочих очередей (per-message ack, routing, RPC-like). Выбор по фану выливается в боль через год.
- Один топик/exchange на все события -
eventsсо всеми типами вперемешку. Consumer вынужден читать всё, фильтровать сам, плохо масштабируется. Разделяй по domain area или event type (orders.events,users.events). EventBusопубликовал событие до commit транзакции - внутри Bus подписчик уже читает БД, видит «нет данных», падает. Ни EventBus, ни брокер не «подождут коммит»: они ничего не знают о транзакции приложения, и сообщение, отправленное в Kafka/RabbitMQ до коммита, consumer тоже может прочитать раньше него. Публикация - после успешногоtx.Commit()(или через Outbox).- Тесты «всё в один EventBus» - параллельные тесты делят bus, подписчики одного теста ловят события другого. Создавай новый EventBus в
t.Run/ setup, не глобальный.
Смотри также
-
Go - Работа с базами данных - транзакции и Outbox pattern: связь между БД и брокером
-
Python - Kafka с aiokafka: broker в деталях - практика работы с Kafka как с message broker: topics, partitions, consumer groups
Мини-задание
- Реализуй
EventBusс методамиSubscribe(eventType, handler)иPublish(eventType, event) - Добавь recover в горутину подписчика, чтобы паника одного не убила весь процесс
- Определи интерфейс
Publisher, чтобы use-case не зависел от реализации (Bus или Broker) - Раздели свои события на две категории: внутренние (Bus) и межсервисные (Broker)
- Напиши тест: опубликуй событие, проверь, что два подписчика оба получили его