Как ускорить хранение в памяти в Redis?

Как ускорить хранение в памяти в Redis?

Редис — чрезвычайно быстра система хранения данных, но даже её производительность может быть оптимизирована. Рассмотрим основные стратегии ускорения хранения в памяти.

1. Выбор правильного типа данных

Разные типы данных в Redis имеют разные характеристики производительности:

import redis
r = redis.Redis()

# ❌ Неэффективно: Много отдельных ключей
for i in range(10000):
    r.set(f'user:{i}:name', f'User {i}')
    r.set(f'user:{i}:email', f'user{i}@example.com')

# ✅ Эффективно: Hash для сложных объектов
for i in range(10000):
    r.hset(f'user:{i}', mapping={
        'name': f'User {i}',
        'email': f'user{i}@example.com'
    })

Hash структуры занимают на 40-50% меньше памяти, чем набор ключей строк.

2. Сжатие данных

Для больших значений используйте сжатие перед сохранением:

import redis
import json
import zlib

class CompressedRedis:
    def __init__(self):
        self.r = redis.Redis()
    
    def set_compressed(self, key, value):
        json_str = json.dumps(value)
        compressed = zlib.compress(json_str.encode())
        self.r.set(key, compressed)
    
    def get_compressed(self, key):
        compressed = self.r.get(key)
        if not compressed:
            return None
        decompressed = zlib.decompress(compressed)
        return json.loads(decompressed)

cr = CompressedRedis()
large_data = {'data': 'x' * 10000}
cr.set_compressed('doc:1', large_data)

3. Optimized serialization с MessagePack

JSON часто содержит излишние символы. MessagePack компактнее:

import redis
import msgpack

class FastRedis:
    def __init__(self):
        self.r = redis.Redis()
    
    def set_fast(self, key, value):
        packed = msgpack.packb(value)
        self.r.set(key, packed)
    
    def get_fast(self, key):
        packed = self.r.get(key)
        if not packed:
            return None
        return msgpack.unpackb(packed, raw=False)

fr = FastRedis()
data = {'users': [{'id': i, 'name': f'User {i}'} for i in range(100)]}
fr.set_fast('bulk:users', data)

4. Pipeline для массовых операций

Множественные запросы — это узкое место. Используйте pipeline:

import redis

r = redis.Redis()

# ❌ Медленно: 1000 RTT
for i in range(1000):
    r.set(f'key:{i}', f'value{i}')

# ✅ Быстро: 1 RTT
pipe = r.pipeline()
for i in range(1000):
    pipe.set(f'key:{i}', f'value{i}')
pipe.execute()

Pipeline может ускорить операции в 10-100 раз.

5. Использование Lua скриптов

Для сложной логики с множественными ключами используйте Lua:

import redis

r = redis.Redis()

# Lua скрипт выполняется атомарно на сервере
script_code = 'local key = KEYS[1]; return redis.call("GET", key)'
result = r.eval(script_code, 1, 'mykey')
print(result)

6. Memory optimization flags

Настройте Redis конфиг для минимизации overhead:

# redis.conf
maxmemory-policy allkeys-lru
save ""
appendonly no
lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes

7. Connection pooling

Используйте connection pool для параллельных операций:

import redis
from redis.connection import BlockingConnectionPool

pool = redis.ConnectionPool(host='localhost', max_connections=50)
r = redis.Redis(connection_pool=pool)

for _ in range(1000):
    r.get('key')

8. Batch операции с MGET/MSET

Для множественных ключей используйте батч-команды:

import redis

r = redis.Redis()

# ❌ Много запросов
values = [r.get(f'key:{i}') for i in range(100)]

# ✅ Один запрос
values = r.mget([f'key:{i}' for i in range(100)])

mapping = {f'key:{i}': f'value{i}' for i in range(1000)}
r.mset(mapping)

9. Expire и TTL

Устанавливайте TTL для автоматической очистки:

import redis

r = redis.Redis()

r.setex('temp:data', 3600, 'value')
r.set('cache:key', 'value')
r.expire('cache:key', 3600)

ttl = r.ttl('cache:key')
print(f'Удалится через {ttl} секунд')

10. Мониторинг памяти

Регулярно проверяйте использование памяти:

import redis

r = redis.Redis()
info = r.info('memory')
print(f'Используемая память: {info["used_memory_human"]}')
print(f'Efficiency: {info["used_memory"] / info["used_memory_rss"] * 100:.1f}%')

for key in r.scan_iter(count=1000):
    size = r.memory_usage(key)
    if size and size > 1000000:
        print(f'{key}: {size / 1024 / 1024:.2f}MB')

Лучшие практики

• Используйте Hash вместо отдельных ключей для объектов
• Сжимайте большие значения (>1KB)
• Используйте Pipeline для массовых операций (100x ускорение)
• Устанавливайте TTL для временных данных
• Мониторьте память в production
• Выбирайте правильный тип данных для задачи
• Отключайте RDB/AOF если не нужна persistence

Комбинирование этих техник может дать 5-10x ускорение и уменьшение памяти на 30-50%.