Event-Driven архитектура: что это и зачем она нужна
Event-Driven архитектура: что это и зачем она нужна
Большинство backend-систем начинается одинаково: HTTP-запрос приходит, handler вызывает service, service дёргает repository, ответ уходит клиенту. Это request-response модель, и она отлично работает, пока у вас один сервис с простой логикой.
Проблемы начинаются, когда после основного действия нужно сделать три побочных: отправить email, обновить счётчик аналитики, начислить бонус. Каждый вызов добавляет латентность, и если одна из систем лежит, весь запрос падает. Event-Driven архитектура (EDA) решает именно эту проблему: основное действие выполняется быстро, а побочные эффекты обрабатываются асинхронно через события.
Request-Response vs Event-Driven
В синхронной модели сервис A напрямую вызывает сервис B и ждёт ответа. Каждый новый побочный эффект добавляет зависимость и время ожидания:
// Синхронный подход: handler знает обо всех побочных эффектах
func (h *LessonHandler) Complete(w http.ResponseWriter, r *http.Request) {
lessonID := extractLessonID(r)
userID := extractUserID(r)
// Основное действие
err := h.progressService.CompleteLessonForUser(r.Context(), userID, lessonID)
if err != nil {
http.Error(w, "failed to complete lesson", http.StatusInternalServerError)
return
}
// Побочные эффекты - каждый добавляет латентность и точку отказа
if err := h.emailService.SendLessonCompletedEmail(r.Context(), userID, lessonID); err != nil {
// урок уже засчитан, а клиент видит ошибку из-за упавшей почты
http.Error(w, "email failed", http.StatusBadGateway)
return
}
if err := h.analyticsService.TrackLessonCompletion(r.Context(), userID, lessonID); err != nil {
http.Error(w, "analytics failed", http.StatusBadGateway)
return
}
if err := h.bonusService.AwardPoints(r.Context(), userID, 10); err != nil {
http.Error(w, "bonus failed", http.StatusBadGateway)
return
}
w.WriteHeader(http.StatusOK)
}
<?php
// Синхронный подход: controller знает обо всех побочных эффектах
declare(strict_types=1);
#[Route('/lessons/{id}/complete', methods: ['POST'])]
public function complete(int $id, Request $request): Response
{
$userId = (int) $request->attributes->get('userId');
// Основное действие
$this->progressService->completeLessonForUser($userId, $id);
// Побочные эффекты - каждый добавляет латентность и точку отказа
$this->emailService->sendLessonCompletedEmail($userId, $id);
$this->analyticsService->trackLessonCompletion($userId, $id);
$this->bonusService->awardPoints($userId, 10);
return new Response(status: 200);
}
# Синхронный подход: handler знает обо всех побочных эффектах.
# Фреймворк-независимый класс: в FastAPI это тело @app.post("/lessons/{lesson_id}/complete"),
# в Django - метод view.
class LessonHandler:
def __init__(
self,
progress_service: ProgressService,
email_service: EmailService,
analytics_service: AnalyticsService,
bonus_service: BonusService,
) -> None:
self._progress_service = progress_service
self._email_service = email_service
self._analytics_service = analytics_service
self._bonus_service = bonus_service
def complete(self, request: Request) -> Response:
lesson_id = extract_lesson_id(request)
user_id = extract_user_id(request)
# Основное действие
try:
self._progress_service.complete_lesson_for_user(user_id, lesson_id)
except Exception:
return Response(status=500, body="failed to complete lesson")
# Побочные эффекты - каждый добавляет латентность и точку отказа
self._email_service.send_lesson_completed_email(user_id, lesson_id)
self._analytics_service.track_lesson_completion(user_id, lesson_id)
self._bonus_service.award_points(user_id, 10)
return Response(status=200)
В event-driven модели handler выполняет основное действие и публикует событие. Подписчики реагируют независимо:
// Event-Driven подход: handler публикует событие, подписчики реагируют сами
func (h *LessonHandler) Complete(w http.ResponseWriter, r *http.Request) {
lessonID := extractLessonID(r)
userID := extractUserID(r)
// Основное действие
err := h.progressService.CompleteLessonForUser(r.Context(), userID, lessonID)
if err != nil {
http.Error(w, "failed to complete lesson", http.StatusInternalServerError)
return
}
// Одна публикация - все подписчики обработают параллельно
h.eventBus.Publish(events.LessonCompleted{
UserID: userID,
LessonID: lessonID,
At: time.Now(),
})
w.WriteHeader(http.StatusOK)
}
<?php
// Event-Driven: controller публикует событие, подписчики реагируют сами
declare(strict_types=1);
use Symfony\Component\Messenger\MessageBusInterface;
#[Route('/lessons/{id}/complete', methods: ['POST'])]
public function complete(int $id, Request $request): Response
{
$userId = (int) $request->attributes->get('userId');
// Основное действие
$this->progressService->completeLessonForUser($userId, $id);
// Одна публикация. Асинхронно (после ответа клиенту) подписчики сработают,
// только если LessonCompleted направлен в async-транспорт:
// framework.messenger.routing: 'App\Event\LessonCompleted': async
// Без routing Messenger вызовет handler-ы синхронно и по очереди внутри dispatch().
$this->eventBus->dispatch(new LessonCompleted(
userId: $userId,
lessonId: $id,
occurredAt: new DateTimeImmutable(),
));
return new Response(status: 200);
}
from datetime import datetime
# Event-Driven подход: handler публикует событие, подписчики реагируют сами
class LessonHandler:
def __init__(self, progress_service: ProgressService, event_bus: EventBus) -> None:
self._progress_service = progress_service
self._event_bus = event_bus
def complete(self, request: Request) -> Response:
lesson_id = extract_lesson_id(request)
user_id = extract_user_id(request)
# Основное действие
try:
self._progress_service.complete_lesson_for_user(user_id, lesson_id)
except Exception:
return Response(status=500, body="failed to complete lesson")
# Одна публикация - все подписчики обработают параллельно
self._event_bus.publish(LessonCompleted(
user_id=user_id,
lesson_id=lesson_id,
at=datetime.now(),
))
return Response(status=200)
Handler больше не знает, кто слушает и что делает. Добавить новый побочный эффект (например, push-уведомление) - это добавить нового подписчика, не трогая handler.
Аналогия: ресторан
Представь ресторан. Официант (handler) принимает заказ от гостя и прикрепляет его на доску заказов (event bus). Повар, бариста и кондитер (subscribers) видят свои задачи и работают параллельно. Официант не стоит у каждого и не ждёт - он идёт к следующему столу.
Если ресторан нанимает нового повара на суши, официант ничего не меняет в своей работе - новый повар просто начинает читать заказы с доски. Это и есть слабая связность.
Ключевые понятия
Event (событие) - факт, который уже произошёл. Неизменяемый. Формулируется в прошедшем времени: LessonCompleted, UserRegistered, PaymentFailed. Прошедшее время здесь не стилистика, а проверка на вменяемость модели: если название читается как приказ, у тебя команда, а не событие. Правила именования, структура конверта и типичные промахи - в уроке про доменные события.
Producer (издатель) - компонент, который публикует событие. Не знает, кто его прочитает.
Consumer (подписчик) - компонент, который реагирует на событие. Не знает, кто его отправил.
Channel / Broker - транспорт между producer и consumer. Может быть Go-каналом внутри процесса или внешним брокером (Kafka, RabbitMQ).
Простая event-система
Минимальный пример: publisher публикует событие, два subscriber-а реагируют на него.
package main
import (
"fmt"
"sync"
"time"
)
// Event - базовое событие
type Event struct {
Type string
Payload map[string]any
OccurredAt time.Time
}
// EventBus - простейшая шина событий на каналах
type EventBus struct {
mu sync.RWMutex
subscribers map[string][]chan Event
}
func NewEventBus() *EventBus {
return &EventBus{
subscribers: make(map[string][]chan Event),
}
}
// Subscribe регистрирует подписчика на определённый тип события
func (b *EventBus) Subscribe(eventType string) <-chan Event {
b.mu.Lock()
defer b.mu.Unlock()
ch := make(chan Event, 16) // буферизованный канал
b.subscribers[eventType] = append(b.subscribers[eventType], ch)
return ch
}
// Publish отправляет событие всем подписчикам данного типа
func (b *EventBus) Publish(e Event) {
b.mu.RLock()
defer b.mu.RUnlock()
for _, ch := range b.subscribers[e.Type] {
// неблокирующая отправка: если подписчик не успевает - событие теряется
select {
case ch <- e:
default:
fmt.Printf("subscriber slow, event dropped: %s\n", e.Type)
}
}
}
func main() {
bus := NewEventBus()
// Подписчик 1: отправляет email
emailCh := bus.Subscribe("lesson.completed")
go func() {
for e := range emailCh {
fmt.Printf("[email] Урок %v пройден пользователем %v\n",
e.Payload["lesson_id"], e.Payload["user_id"])
}
}()
// Подписчик 2: обновляет аналитику
analyticsCh := bus.Subscribe("lesson.completed")
go func() {
for e := range analyticsCh {
fmt.Printf("[analytics] +1 completion для урока %v\n",
e.Payload["lesson_id"])
}
}()
// Публикация события
bus.Publish(Event{
Type: "lesson.completed",
Payload: map[string]any{"user_id": 42, "lesson_id": 7},
OccurredAt: time.Now(),
})
time.Sleep(100 * time.Millisecond) // даём горутинам отработать
}
<?php
// Простейшая in-process шина на массиве handler-ов
declare(strict_types=1);
final readonly class LessonCompleted
{
public function __construct(
public int $userId,
public int $lessonId,
public DateTimeImmutable $occurredAt,
) {}
}
final class EventBus
{
/** @var array<string, list<callable>> */
private array $subscribers = [];
public function subscribe(string $eventClass, callable $handler): void
{
$this->subscribers[$eventClass][] = $handler;
}
public function publish(object $event): void
{
foreach ($this->subscribers[$event::class] ?? [] as $handler) {
$handler($event);
}
}
}
// Подписчики - просто invokable классы
final class SendEmailOnLessonCompleted
{
public function __invoke(LessonCompleted $event): void
{
echo "[email] урок {$event->lessonId} пройден пользователем {$event->userId}\n";
}
}
final class TrackAnalyticsOnLessonCompleted
{
public function __invoke(LessonCompleted $event): void
{
echo "[analytics] +1 completion для урока {$event->lessonId}\n";
}
}
$bus = new EventBus();
$bus->subscribe(LessonCompleted::class, new SendEmailOnLessonCompleted());
$bus->subscribe(LessonCompleted::class, new TrackAnalyticsOnLessonCompleted());
$bus->publish(new LessonCompleted(
userId: 42,
lessonId: 7,
occurredAt: new DateTimeImmutable(),
));
// В Symfony та же роль у Messenger:
// final class SendEmailOnLessonCompleted
// {
// #[AsMessageHandler]
// public function __invoke(LessonCompleted $event): void { ... }
// }
# Простейшая in-process шина: как в Go-версии, у каждого подписчика своя
# ограниченная очередь (аналог буферизованного канала) и свой поток.
# publish не ждёт подписчиков: медленный теряет событие, упавший - не роняет
# publish и соседей.
import logging
import queue
import threading
import time
from collections import defaultdict
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any, Callable
logging.basicConfig(level=logging.INFO, format="%(message)s")
log = logging.getLogger(__name__)
@dataclass(frozen=True)
class Event:
"""Базовое событие."""
event_type: str
payload: dict[str, Any]
occurred_at: datetime = field(default_factory=datetime.now)
Handler = Callable[[Event], None]
class EventBus:
"""Простейшая шина событий на очередях и потоках."""
def __init__(self) -> None:
self._lock = threading.Lock()
self._subscribers: dict[str, list[queue.Queue[Event]]] = defaultdict(list)
def subscribe(self, event_type: str, handler: Handler) -> None:
"""Регистрирует подписчика на определённый тип события."""
q: queue.Queue[Event] = queue.Queue(maxsize=16) # как make(chan Event, 16)
with self._lock:
self._subscribers[event_type].append(q)
threading.Thread(target=self._consume, args=(q, handler), daemon=True).start()
def publish(self, event: Event) -> None:
"""Отправляет событие всем подписчикам данного типа, не дожидаясь их."""
with self._lock:
queues = list(self._subscribers[event.event_type])
for q in queues:
# Неблокирующая отправка, как select/default в Go:
# если подписчик не успевает - событие теряется
try:
q.put_nowait(event)
except queue.Full:
log.warning("subscriber slow, event dropped: %s", event.event_type)
@staticmethod
def _consume(q: queue.Queue[Event], handler: Handler) -> None:
"""Цикл подписчика: его исключение логируется и не роняет шину."""
while True:
event = q.get()
try:
handler(event)
except Exception:
log.exception("subscriber failed: %s", event.event_type)
def send_email(event: Event) -> None:
"""Подписчик 1: отправляет email."""
print(f"[email] Урок {event.payload['lesson_id']} пройден пользователем {event.payload['user_id']}")
def track_analytics(event: Event) -> None:
"""Подписчик 2: обновляет аналитику."""
print(f"[analytics] +1 completion для урока {event.payload['lesson_id']}")
def main() -> None:
bus = EventBus()
bus.subscribe("lesson.completed", send_email)
bus.subscribe("lesson.completed", track_analytics)
# Публикация события
bus.publish(Event(
event_type="lesson.completed",
payload={"user_id": 42, "lesson_id": 7},
))
time.sleep(0.1) # даём потокам отработать
if __name__ == "__main__":
main()
Поток событий в типичном приложении
Основное действие выполняется синхронно. Побочные эффекты - асинхронно. Если подписчик email упал, урок всё равно засчитан. Ровно эту схему мы собираем целиком в мини-проекте трека: один use-case, outbox-таблица (событие сохраняется в служебную таблицу той же транзакцией, что и данные, а отдельный процесс потом его публикует; подробно - в уроке 7) и три независимых подписчика на одном событии.
Когда использовать EDA
Хороший сценарий для событий - побочные эффекты, которые не влияют на основной результат:
- Отправка email / push-уведомлений
- Аналитика и метрики
- Начисление бонусов / ачивок
- Синхронизация данных между сервисами
- Аудит-лог
Плохой сценарий - когда нужен немедленный, консистентный результат:
- Простой CRUD без побочных эффектов (overhead не оправдан)
- Действия с требованием строгой консистентности (перевод денег между счетами)
- Запросы, где клиенту нужен результат побочного эффекта прямо сейчас
ℹ️ EDA ≠ микросервисы
Event-Driven архитектура прекрасно работает внутри монолита. Если у вас один Go-сервис с тремя модулями (progress, notifications, analytics), EventBus на каналах развяжет их не хуже, чем Kafka между тремя микросервисами. Не нужно разбивать монолит, чтобы использовать события.
⚠️ Сложности EDA
С событиями сложнее отлаживать: нет единого call stack. Нужен correlation ID, чтобы отследить цепочку от HTTP-запроса до последнего подписчика. Без дисциплины именования и версионирования событий система быстро превращается в хаос.
Типичные ошибки
- «Заэвентим всё» - каждое CRUD-действие → событие. Получаем хаос событий без бизнес-смысла, дебаг невозможен. Событие - про бизнес-факт (
OrderPlaced,PaymentReceived), не про техническое действие (RowUpdated). - EDA вместо синхронного API «потому что модно» - пользователь жмёт «купить» и ждёт ответ. Event-driven здесь даст eventual consistency и сложность ради ничего. EDA уместен для побочных эффектов (отправь email, начисли бонусы) - не для основного потока.
- Использовать события для строгой консистентности - «перевод денег между счетами через события» обычно даёт race conditions. Для атомарных операций - транзакция БД, а не «просто событие». Если операция по необходимости распределена между сервисами, - Saga с компенсациями, но она даёт согласованность в конечном счёте, а не атомарность и не изоляцию.
- Подписчик читает БД сразу после события и не находит данные - event опубликован внутри транзакции, ещё не закоммичено. Подписчик стартует, идёт в БД, видит «нет». Правильное место публикации - после commit, либо через Outbox.
- Один большой EventBus без bounded contexts - все события всех модулей в одной шине. Со временем каждый подписчик подписывается на каждое событие, EDA вырождается в RPC через посредника. Разделяй шины по domain area.
- Долгая обработка в синхронной шине - если Publish вызывает handler-ы прямо в своём цикле (как PHP-версия шины выше), HTTP-запрос ждёт всех слушателей. Асинхронная шина (Go и Python-версии) не блокирует, но при переполнении буфера теряет события - это осознанный компромисс, а не бесплатная скорость.
Смотри также
- Python - Kafka с aiokafka: producer, consumer, partitions - конкретная реализация event-driven архитектуры с Kafka в Python
Мини-задание
- Перечисли побочные эффекты в своём проекте (email, аналитика, нотификации, бонусы)
- Определи, какие из них можно выполнять асинхронно, не блокируя основной запрос
- Напиши простой EventBus на Go-каналах с методами
SubscribeиPublish - Подключи два подписчика к одному типу события и убедись, что оба получают сообщение
- Нарисуй поток данных своего приложения: где request-response, а где можно перейти на события