Когда стоит использовать key-value БД?

Когда стоит использовать key-value БД?

Key-value базы данных (KV-store) — это специализированные хранилища для быстрого доступа к данным по ключу. Redis, Memcached, DynamoDB, Cassandra — примеры популярных решений. Выбор KV-БД зависит от конкретных требований проекта.

Основные характеристики key-value БД

1. Что такое key-value хранилище?

Это простая модель данных: ключ → значение. Нет сложных связей, схем или индексов:

# В памяти (Redis)
key: "user:1001"
value: {"name": "John", "email": "john@example.com"}

# Операции
SET key value      # Сохранить
GET key            # Получить
DEL key            # Удалить
INCR counter       # Атомарное увеличение

Когда использовать key-value БД

2. Кеширование (главный сценарий)

Кеширование — это основное применение KV-БД. Быстрое получение часто используемых данных:

import redis

class UserCache:
    def __init__(self):
        self.cache = redis.Redis(host="localhost", port=6379)
    
    def get_user(self, user_id: int) -> dict:
        """Получить пользователя с кешированием"""
        
        # 1. Попробуй получить из кеша (быстро)
        cached = self.cache.get(f"user:{user_id}")
        if cached:
            return json.loads(cached)
        
        # 2. Если нет, получи из БД (медленнее)
        user = db.query(User).filter(User.id == user_id).first()
        
        # 3. Сохрани в кеш на 1 час
        self.cache.setex(
            f"user:{user_id}",
            3600,  # TTL в секундах
            json.dumps(user.to_dict())
        )
        
        return user.to_dict()

Преимущества:

• Очень быстрое получение (микросекунды вместо миллисекунд)
• Снижает нагрузку на основную БД
• Улучшает скорость отклика приложения

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

Хранение активных сессий и их данных:

from datetime import datetime, timedelta

class SessionManager:
    def __init__(self):
        self.cache = redis.Redis()
    
    def create_session(self, user_id: int) -> str:
        """Создать сессию пользователя"""
        session_token = generate_uuid()
        
        session_data = {
            "user_id": user_id,
            "created_at": datetime.now().isoformat(),
            "ip_address": request.remote_addr,
        }
        
        # Сохранить с TTL (автоматически удалится через 24 часа)
        self.cache.setex(
            f"session:{session_token}",
            86400,  # 24 часа
            json.dumps(session_data)
        )
        
        return session_token
    
    def validate_session(self, token: str) -> Optional[dict]:
        """Проверить сессию (очень быстро)"""
        data = self.cache.get(f"session:{token}")
        return json.loads(data) if data else None

4. Очереди задач (Message Queue)

Кеширование может использоваться для простых очередей:

class TaskQueue:
    def __init__(self):
        self.redis = redis.Redis()
    
    def enqueue(self, task_id: str, task_data: dict):
        """Добавить задачу в очередь"""
        self.redis.lpush("task_queue", json.dumps(task_data))
    
    def dequeue(self) -> Optional[dict]:
        """Получить следующую задачу"""
        task = self.redis.rpop("task_queue")
        return json.loads(task) if task else None
    
    def process_queue(self):
        """Обработать очередь"""
        while True:
            task = self.dequeue()
            if not task:
                time.sleep(1)
                continue
            
            process_task(task)

5. Счётчики и рейтинг-листы

Атомарные операции для счётчиков:

class Analytics:
    def __init__(self):
        self.redis = redis.Redis()
    
    def track_page_view(self, page_id: str):
        """Отслеживать просмотры страницы"""
        # Атомарное увеличение счётчика
        self.redis.incr(f"views:{page_id}")
        # Добавить в сортированное множество (для рейтинга)
        self.redis.zincrby("popular_pages", 1, page_id)
    
    def get_top_pages(self, limit: int = 10) -> list:
        """Получить самые популярные страницы"""
        # Получить top N из отсортированного множества (быстро)
        return self.redis.zrevrange(
            "popular_pages",
            0,
            limit - 1,
            withscores=True
        )
    
    def get_page_views(self, page_id: str) -> int:
        """Получить количество просмотров"""
        count = self.redis.get(f"views:{page_id}")
        return int(count) if count else 0

6. Real-time уведомления и pub/sub

Pub/Sub паттерн для сообщений между компонентами:

class NotificationSystem:
    def __init__(self):
        self.redis = redis.Redis()
    
    def publish_notification(self, user_id: int, message: str):
        """Опубликовать уведомление"""
        channel = f"user:{user_id}:notifications"
        self.redis.publish(channel, message)
    
    def subscribe_to_notifications(self, user_id: int, callback):
        """Подписаться на уведомления (WebSocket backend)"""
        pubsub = self.redis.pubsub()
        channel = f"user:{user_id}:notifications"
        pubsub.subscribe(channel)
        
        for message in pubsub.listen():
            if message["type"] == "message":
                callback(message["data"])

Сравнение key-value БД и SQL БД

7. Когда использовать что?

Выбор конкретного KV-хранилища

8. Популярные опции

# Redis — универсальный выбор (памяти, TTL, data structures)
redis.Redis(host="localhost", port=6379)

# Memcached — простой, быстрый (только for кеширования)
import memcache
memcached = memcache.Client(["localhost:11211"])

# DynamoDB (AWS) — управляемый, масштабируемый
import boto3
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")

# Cassandra — распределённый, high-availability
from cassandra.cluster import Cluster
cluster = Cluster(["127.0.0.1"])

Практическая рекомендация

Используй key-value БД когда:

• Нужен кеш для часто используемых данных
• Требуется очень быстрый доступ (микросекунды)
• Данные структурированы как простые пары ключ-значение
• Нужна высокая параллельность (много одновременных читателей)
• Требуется TTL (автоматическое удаление старых данных)
• Нужны счётчики или рейтинги
• Нужна сессионная памяти для веб-приложений

Не используй KV-БД как основное хранилище:

• Для критичных данных (используй SQL с резервными копиями)
• Если нужны сложные запросы и связи между данными
• Если требуется надёжная персистентность (только Redis с AOF/RDB)

Лучший подход — комбинированный: основная БД (PostgreSQL) + кеш (Redis) для оптимальной производительности.