В чем разница между Kafka и Redis?

# Разница между Kafka и Redis

Оба инструмента работают с данными в памяти, но предназначены для принципиально разных задач:

Краткая таблица

Kafka - Message Broker для потоков данных

Распределённая очередь сообщений для обработки больших потоков данных в real-time.

Архитектура:

Producer → Topic → Partition → Consumer
         → Partition
         → Partition

Ключевые особенности:

1. Topics и Partitions:

   • Данные организованы в topics
   • Каждый topic разбит на partitions
   • Partition хранится на одном brokerе (или реплицируется)

2. Персистентность:

   • Все сообщения пишутся на диск
   • Данные хранятся долго (дни, недели)
   • Consumer может перечитать данные

3. Consumer Groups:

   • Несколько consumers могут читать один topic
   • Каждое сообщение попадает ровно одному consumer в группе
   • Гарантия обработки: exactly once

4. Масштабируемость:

   • Горизонтальное масштабирование
   • Partitions распределяются по brokerам
   • Линейный рост пропускной способности

Пример использования на Java (Spring Boot):

// Producer - отправитель
@Service
public class OrderProducer {
    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
    public void sendOrder(OrderEvent event) {
        kafkaTemplate.send("orders-topic", event.getOrderId(), event);
    }
}

// Consumer - получатель
@Service
public class OrderConsumer {
    @KafkaListener(topics = "orders-topic", groupId = "order-processors")
    public void processOrder(OrderEvent event) {
        System.out.println("Processing: " + event.getOrderId());
        // Гарантировано: это сообщение обработает только один consumer
    }
}

Когда использовать Kafka:

1. Потоки событий: логирование, метрики, аналитика
2. Интеграция микросервисов: асинхронная коммуникация
3. Real-time обработка: Stream processing (Kafka Streams, Flink)
4. Гарантии доставки: важна надёжность
5. История данных: нужно перечитать прошлые события
6. Масштабирование: растущие объёмы

Redis - In-Memory data store

Быстрое in-memory хранилище для часто используемых данных.

Структуры данных:

String  → "value"
Hash    → {field: value}
List    → [item1, item2]
Set     → {item1, item2}
Sorted Set → {item: score}
HyperLogLog → приблизительный счётчик

Ключевые особенности:

1. Скорость:

   • Все данные в памяти
   • Микросекундные операции
   • Идеален для кэширования

2. Простота:

   • Простые операции: GET, SET, DEL
   • Нет схемы (schema-less)
   • TTL для автоудаления

3. Структуры данных:

   • Строки, числа
   • Хеш-таблицы
   • Списки (очереди)
   • Множества
   • Отсортированные множества

4. Опции персистентности:

   • RDB: периодические снимки
   • AOF: логирование команд
   • Можно отключить (pure cache)

Пример использования на Java (Spring Boot):

// Конфигурация
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        return template;
    }
}

// Использование
@Service
public class CacheService {
    private final RedisTemplate<String, Object> redisTemplate;
    
    public void cacheUser(User user) {
        // Кэширование с TTL 1 час
        redisTemplate.opsForValue().set(
            "user:" + user.getId(),
            user,
            Duration.ofHours(1)
        );
    }
    
    public User getCachedUser(Long id) {
        return (User) redisTemplate.opsForValue().get("user:" + id);
    }
    
    // Очередь заданий
    public void pushTask(Task task) {
        redisTemplate.opsForList().rightPush("task-queue", task);
    }
    
    public Task popTask() {
        return (Task) redisTemplate.opsForList().leftPop("task-queue");
    }
}

Когда использовать Redis:

1. Кэширование: сессии пользователей, DB кэш
2. Очереди: простые задачи, job queue
3. Счётчики: просмотры, лайки
4. Рейтинг: лидерборды (sorted sets)
5. Pub/Sub: простая коммуникация
6. Сессии: веб-приложений
7. Rate limiting: API throttling

Прямое сравнение

Сценарий 1: Логирование приложения

// Kafka: долгосрочное хранилище, обработка потока
KafkaTemplate.send("app-logs", LogEvent);
// Consumer читает логи, анализирует, отправляет в ELK

// Redis: временное хранилище
redisTemplate.opsForList().rightPush("logs-buffer", LogEvent);
// TTL: 1 час, затем автоудаление

Сценарий 2: Кэширование результатов

// Kafka: НЕ подходит (слишком медленно)

// Redis: идеален
String cached = redisTemplate.opsForValue().get("user:123");
if (cached == null) {
    User user = loadFromDatabase();
    redisTemplate.opsForValue().set("user:123", user, Duration.ofMinutes(30));
}

Сценарий 3: Распределённая система обработки событий

// Kafka: идеален
kafkaTemplate.send("user-events", UserEvent);
// Несколько сервисов читают один топик
// Гарантия: каждый сервис получит сообщение

// Redis pub/sub: есть риск потери (если нет подписчика)
redisTemplate.convertAndSend("user-events", UserEvent);

Архитектурное решение

Условная архитектура микросервисов:

┌─────────────┐
│ User        │ → Redis (кэш профилей)
│ Service     │ → Kafka (событие: user-created)
└─────────────┘
        ↓
   Kafka Topic: user-events
        ↓
    ┌───┴───┐
    ↓       ↓
  Order   Email
  Service Service
  
  Order Service: читает из Kafka, кэширует в Redis
  Email Service: читает из Kafka, отправляет письма

Итоговое резюме

Выбирай Kafka когда:

• Нужна надёжная доставка событий
• Много producers и consumers
• Нужна история данных
• Важна гарантия обработки
• Растущие объёмы

Выбирай Redis когда:

• Нужна максимальная скорость
• Кэширование, сессии
• Простая очередь
• Ограниченный объём данных
• Временные данные

Идеальная комбинация: Kafka для потоков событий + Redis для кэширования и сессий