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-processIntegration-тесты, 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, не глобальный.

Смотри также

Мини-задание

  • Реализуй EventBus с методами Subscribe(eventType, handler) и Publish(eventType, event)
  • Добавь recover в горутину подписчика, чтобы паника одного не убила весь процесс
  • Определи интерфейс Publisher, чтобы use-case не зависел от реализации (Bus или Broker)
  • Раздели свои события на две категории: внутренние (Bus) и межсервисные (Broker)
  • Напиши тест: опубликуй событие, проверь, что два подписчика оба получили его

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.