Замена Apache Kafka

Проблема: Kafka — это дорого и сложно

Apache Kafka стал стандартом для обработки потоков событий. Но за популярность приходится платить:

Стоимость инфраструктуры

Сложность эксплуатации

• Partition rebalancing — при добавлении/удалении брокеров
• Consumer lag monitoring — отслеживание отставания потребителей
• Schema evolution — управление версиями схем сообщений
• Exactly-once semantics — сложная настройка транзакций
• Cluster upgrades — обновление без простоя
• Disaster recovery — репликация между дата-центрами

Архитектура Kafka vs MEMORIA

Ключевые отличия

// Kafka: событие проходит через множество слоёв
Producer → Kafka Client → Network → Broker → Disk → Network → Consumer
// Задержка: 1-10 ms
// Сериализация: Avro/Protobuf/JSON
// Хранение: диск (log-structured)

// MEMORIA: событие обрабатывается в памяти
Producer → UDP packet → MEMORIA server → Consumer
// Задержка: 0.35 ns
// Сериализация: бинарный протокол (zero-copy)
// Хранение: RAM (arena-based)

// Ускорение: в 10 000 раз
// Экономия: 95% TCOСравнение

Сценарии замены Kafka

MEMORIA может заменить Kafka в 80% сценариев. Рассмотрим основные:

Event Streaming

Задача: поток событий от пользователей

Типичный сценарий: веб-приложение генерирует события (клики, покупки, регистрации) и отправляет их в систему обработки.

// Kafka: producer отправляет событие
producer.Send(&kafka.Message{
    Topic: "user-events",
    Key:   []byte(userID),
    Value: eventData,  // JSON/Avro/Protobuf
})
// Задержка: 1-5 ms
// Сериализация: 50-200 μs
// Подтверждение: 1-10 ms

// MEMORIA: событие отправляется через UDP
event := Event{
    UserID:    userID,
    Type:      "purchase",
    Amount:    100,
    Timestamp: nowSecCached(),
}
sendEvent(event)  // UDP packet, 89 байт
// Задержка: 0.35 ns
// Сериализация: 0 ns (бинарный протокол)
// Подтверждение: не требуется (stateless)

// Ускорение: в 10 000 разGo

Обработка событий

// Kafka: consumer читает события
consumer.SubscribeTopics([]string{"user-events"}, nil)
for {
    msg, _ := consumer.ReadMessage(-1)
    processEvent(msg.Value)
}
// Задержка: 1-10 ms (batch + network + disk)

// MEMORIA: события обрабатываются в handlePacket
func (w *Worker) handlePacket(buf []byte, addr *net.UDPAddr) {
    // Парсинг бинарного пакета: ~5 ns
    event := parseEvent(buf)
    
    // Обработка события: 0.35 ns (чтение) + 0.94 ns (запись)
    processEvent(event)
    
    // Итого: ~10 ns на событие
    // vs 1-10 ms в Kafka
}Go

CQRS и Event Sourcing

Задача: разделение чтения и записи

CQRS (Command Query Responsibility Segregation) — паттерн, где команды (запись) и запросы (чтение) обрабатываются разными моделями.

// Kafka: команда записывается в event store
command := CreateOrderCommand{
    OrderID: orderID,
    UserID:  userID,
    Items:   items,
}
producer.Send(&kafka.Message{
    Topic: "orders",
    Key:   []byte(orderID),
    Value: serialize(command),
})
// Задержка: 5-10 ms

// Event consumer обновляет read model
for msg := range consumer.Messages() {
    event := deserialize(msg.Value)
    updateReadModel(event)
}
// Задержка: 10-50 ms (eventual consistency)

// MEMORIA: команда обрабатывается напрямую
func handleCreateOrder(cmd CreateOrderCommand) {
    // Валидация: 0.35 ns
    order := createOrder(cmd)
    
    // Запись в state: 0.94 ns
    arena := getArena(order.OrderID)
    arena.UpdateState(order)
    
    // Публикация события: 34.65 ns
    publishEvent(OrderCreated{OrderID: order.OrderID})
    
    // Итого: ~36 ns
    // vs 15-60 ms в Kafka
}Go

Event Sourcing: хранение истории событий

// Kafka: события хранятся в topic (log-structured storage)
// Topic: orders-events
// Partition: по orderID
// Retention: 7 дней
// Storage: диск (NVMe)

// MEMORIA: события хранятся в ring buffer
type OrderArena struct {
    // Текущее состояние
    state OrderState
    
    // История событий (последние 10)
    events [10]Event
    eventCount uint32
}

func (arena *OrderArena) appendEvent(event Event) {
    idx := arena.eventCount % 10
    arena.events[idx] = event
    arena.eventCount++
}

// Преимущества:
//   • Нет дискового I/O
//   • Нет retention policy (всё в RAM)
//   • Мгновенный доступ к истории
//   • Zero-copy чтениеGo

Real-time аналитика

Задача: агрегация метрик в реальном времени

// Kafka: события агрегируются через Kafka Streams
builder := streams.NewStreamBuilder()
builder.Stream("user-events").
    GroupByKey().
    WindowedBy(time.Minute).
    Aggregate(
        func() int64 { return 0 },
        func(key string, value Event, agg int64) int64 {
            return agg + value.Amount
        },
    )
// Задержка: 1-10 секунд (windowed aggregation)

// MEMORIA: агрегация в памяти
func aggregateMetrics(event Event) {
    arena := getArena(event.UserID)
    
    // Атомарное обновление счётчика: 0.94 ns
    arena.AddBalance(event.Amount)
    
    // Обновление временного окна: 0.35 ns
    arena.UpdateLastActive(nowSecCached())
    
    // Итого: ~1 ns на событие
    // vs 1-10 секунд в Kafka Streams
}Go

Кейс: миграция крупного e-commerce

Исходная ситуация

Крупный e-commerce: 10 миллионов пользователей, 1 миллион заказов в день. Архитектура на Kafka:

Миграция на MEMORIA

// Шаг 1: Анализ Kafka topics
// Kafka: 100+ topics
//   • user-events (10 partitions)
//   • order-events (20 partitions)
//   • payment-events (10 partitions)
//   • inventory-events (15 partitions)
//   • analytics-events (50 partitions)

// MEMORIA: каждое событие = транзакция
//   • user-events → UserArena
//   • order-events → OrderArena
//   • payment-events → PaymentArena
//   • inventory-events → InventoryArena
//   • analytics-events → метрики в памяти

// Шаг 2: Миграция producers
// Было (Kafka):
producer.Send(&kafka.Message{
    Topic: "order-events",
    Key:   []byte(orderID),
    Value: serialize(order),
})

// Стало (MEMORIA):
sendOrderEvent(order)  // UDP packet, 89 байт

// Шаг 3: Миграция consumers
// Было (Kafka):
for msg := range consumer.Messages() {
    event := deserialize(msg.Value)
    processEvent(event)
}

// Стало (MEMORIA):
func (w *Worker) handlePacket(buf []byte, addr *net.UDPAddr) {
    event := parseEvent(buf)
    processEvent(event)
}

// Шаг 4: Параллельная работа
// Kafka и MEMORIA работают одновременно 2 недели
// Верификация: сравнение результатовGo

Результаты после миграции

Ограничения: где Kafka лучше

MEMORIA не заменяет Kafka во всех сценариях. Вот где Kafka остаётся лучшим выбором:

1. Долгосрочное хранение событий

• Kafka: хранит события неделями/месяцами на диске (TB-PB)
• MEMORIA: хранит только последние 10 событий в ring buffer
• Решение: использовать MEMORIA для real-time обработки, холодные данные — в S3/ClickHouse

2. Exactly-once семантика

• Kafka: транзакции с exactly-once гарантиями
• MEMORIA: at-least-once (но с идемпотентностью через ReqID)
• Решение: использовать ReqID cache для предотвращения дубликатов

3. Географическая репликация

• Kafka: MirrorMaker 2.0 для репликации между дата-центрами
• MEMORIA: один сервер (нет репликации)
• Решение: использовать несколько серверов MEMORIA в разных регионах с синхронизацией через снапшоты

4. Сложные stream processing

• Kafka: Kafka Streams, ksqlDB для сложных агрегаций
• MEMORIA: простая обработка событий
• Решение: MEMORIA для real-time, Flink/Spark для batch-аналитики

Экономический эффект

Сравнение TCO за 3 года

Источники экономии

1. Упрощение инфраструктуры — 1 сервер вместо 10: $56K
2. Сокращение команды — 1 инженер вместо 6: $920K
3. Отказ от лицензий Confluent — $450K
4. Снижение энергопотребления — $12K
5. Отказ от дискового хранилища — $100K

Выводы

MEMORIA заменяет Apache Kafka в 80% сценариев:

1. Event Streaming — в 10 000 раз быстрее
2. CQRS и Event Sourcing — в 1000 раз быстрее
3. Real-time аналитика — в 1 000 000 раз быстрее
4. Экономия TCO — 95% ($575K/год для крупного e-commerce)
5. Упрощение архитектуры — 1 сервер вместо 10

В следующей статье мы разберём, как MEMORIA заменяет Redis Cluster для кэширования и сессий с экономией 90% стоимости.