Замена Redis Cluster

Проблема: Redis Cluster — это дорого

Redis — популярное in-memory хранилище для кэширования, сессий и rate limiting. Но для production-нагрузки требуется Redis Cluster — распределённая версия с шардированием и репликацией.

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

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

• Cluster rebalancing — при добавлении/удалении нод
• Failover — автоматическое переключение при отказе мастера
• Memory management — eviction policies, maxmemory
• Persistence — RDB snapshots, AOF logs
• Monitoring — latency, hit rate, memory fragmentation

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

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

// Redis: запрос проходит через сеть и сериализацию
client.SET("user:123:balance", "1000")
// Задержка: 1-5 ms (network + serialization + disk)

// MEMORIA: прямой доступ к памяти
arena := getArena(peerID)
arena.UpdateBalance(1000)
// Задержка: 0.94 ns (только запись в RAM)

// Ускорение: в 5 000 разСравнение

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

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

Кэширование

Задача: кэш горячих данных

Типичный сценарий: веб-приложение кэширует результаты запросов к БД, HTML-страницы, API-ответы.

// Redis: установка кэша
redis.SET("product:123", jsonData, "EX", 3600)
// Задержка: 1-5 ms
// Сериализация: JSON → string
// Хранение: RAM + optional disk

// MEMORIA: кэш в памяти
peerID := productIDToPeerID(123)
arena := getArena(peerID)
arena.UpdateState(productData)
arena.SetTTL(3600)  // автоматическое удаление через 1 час
// Задержка: 0.94 ns
// Хранение: только RAM

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

Чтение из кэша

// Redis: чтение из кэша
data, err := redis.GET("product:123")
if err == redis.Nil {
    // Cache miss — запрос к БД
    data = queryDatabase(123)
    redis.SET("product:123", data, "EX", 3600)
}
// Задержка: 1-5 ms (hit), 10-50 ms (miss)

// MEMORIA: чтение из кэша
peerID := productIDToPeerID(123)
arena := getArena(peerID)
if arena == nil || arena.IsExpired() {
    // Cache miss — запрос к БД
    data = queryDatabase(123)
    arena = createArena(peerID, data)
    arena.SetTTL(3600)
} else {
    data = arena.GetState()
}
// Задержка: 0.35 ns (hit), 10-50 ms (miss)

// Cache hit ускорение: в 14 000 разGo

Сессии пользователей

Задача: хранение сессий

// Redis: создание сессии
sessionID := generateSessionID()
redis.HSET("session:"+sessionID, "user_id", "123", "role", "admin")
redis.EXPIRE("session:"+sessionID, 86400)  // 24 часа
// Задержка: 2-10 ms

// MEMORIA: создание сессии
sessionID := generateSessionID()
peerID := sessionToPeerID(sessionID)
arena := getOrCreateArena(peerID)
arena.SetField("user_id", "123")
arena.SetField("role", "admin")
arena.SetTTL(86400)
// Задержка: 0.94 ns

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

Чтение сессии

// Redis: чтение сессии
userID := redis.HGET("session:"+sessionID, "user_id")
role := redis.HGET("session:"+sessionID, "role")
// Задержка: 2-10 ms

// MEMORIA: чтение сессии
peerID := sessionToPeerID(sessionID)
arena := getArena(peerID)
userID := arena.GetField("user_id")
role := arena.GetField("role")
// Задержка: 0.35 ns

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

Rate limiting

Задача: ограничение запросов

// Redis: rate limiting через sliding window
key := "ratelimit:" + userID
now := time.Now().Unix()
redis.ZADD(key, now, now)
redis.ZREMRANGEBYSCORE(key, 0, now-60)  // удалить старше 60 сек
count := redis.ZCARD(key)
if count > 100 {
    return "Rate limit exceeded"
}
// Задержка: 5-20 ms (несколько команд)

// MEMORIA: rate limiting через IP limiter
ipHash := xxhash.Sum64([]byte(userID))
shardIdx := ipHash & IP_LIMITER_MASK
shard := &ipLimiterShards[shardIdx]
if !shard.CheckLimit(ipHash, nowSecCached()) {
    return "Rate limit exceeded"
}
// Задержка: 5 ns (одна атомарная операция)

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

Leaderboards и счётчики

Задача: глобальные счётчики

// Redis: инкремент счётчика
redis.INCR("counter:page_views")
// Задержка: 1-5 ms

// MEMORIA: инкремент счётчика
counterArena := getArena(counterPeerID)
counterArena.AddBalance(1)
// Задержка: 2.41 ns

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

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

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

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

Миграция на MEMORIA

// Шаг 1: Анализ Redis keyspace
// Redis: 50M keys
//   • product:* (20M keys)
//   • session:* (15M keys)
//   • ratelimit:* (10M keys)
//   • counter:* (5M keys)

// MEMORIA: каждый key = PeerID
//   • product:* → ProductArena
//   • session:* → SessionArena
//   • ratelimit:* → IPLimiterShard
//   • counter:* → CounterArena

// Шаг 2: Миграция данных
func migrateFromRedis(redisClient *redis.Client) {
    cursor := 0
    for {
        keys, nextCursor, _ := redisClient.Scan(cursor, "product:*", 1000)
        for _, key := range keys {
            data, _ := redisClient.GET(key)
            peerID := keyToPeerID(key)
            arena := getOrCreateArena(peerID)
            arena.SetState(data)
        }
        cursor = nextCursor
        if cursor == 0 {
            break
        }
    }
}

// Шаг 3: Замена клиентов
// Было (Redis):
data, err := redis.GET("product:123")

// Стало (MEMORIA):
peerID := productIDToPeerID(123)
arena := getArena(peerID)
data := arena.GetState()

// Шаг 4: Параллельная работа
// Redis и MEMORIA работают одновременно 2 недели
// Мониторинг: сравнение hit rate и latencyGo

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

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

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

1. Сложные структуры данных

• Redis: hashes, lists, sets, sorted sets, streams, geospatial
• MEMORIA: только key-value с полями
• Решение: использовать MEMORIA для простых кэшей, Redis для сложных структур

2. Persistence

• Redis: RDB snapshots, AOF logs, репликация на диск
• MEMORIA: только RAM (данные теряются при перезапуске)
• Решение: MEMORIA для кэшей (можно пересоздать), Redis для важных данных

3. Pub/Sub

• Redis: встроенный pub/sub с каналами
• MEMORIA: нет встроенного pub/sub
• Решение: использовать Kafka/NATS для pub/sub, MEMORIA для кэширования

4. Экосистема

• Redis: клиенты на всех языках, GUI-инструменты, мониторинг
• MEMORIA: только Go SDK (пока)
• Решение: MEMORIA для backend на Go, Redis для polyglot-стеков

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

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

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

1. Упрощение инфраструктуры — 1 сервер вместо 9: $47K
2. Сокращение команды — 1 инженер вместо 3: $800K
3. Отказ от лицензий Redis Enterprise — $300K
4. Снижение энергопотребления — $12K
5. Отказ от дискового хранилища — $50K

Выводы

MEMORIA заменяет Redis Cluster в 70% сценариев:

1. Кэширование — в 14 000 раз быстрее
2. Сессии пользователей — в 28 000 раз быстрее
3. Rate limiting — в 4 000 000 раз быстрее
4. Счётчики — в 2 000 раз быстрее
5. Экономия TCO — 90% ($450K/год для крупного e-commerce)

В следующей статье мы разберём, как MEMORIA заменяет Elasticsearch для логирования и поиска с экономией 85% стоимости.