Caché con Redis: Configuración y Uso

Introducción

Redis (Remote Dictionary Server) es un almacén de estructuras de datos en memoria de código abierto que sirve como base de datos, caché, broker de mensajes y motor de streaming. Cuando se usa como caché, Redis puede mejorar drásticamente el rendimiento de las aplicaciones al almacenar datos de acceso frecuente en memoria, reduciendo consultas a la base de datos y minimizando la sobrecarga computacional. Con tiempos de respuesta submilisegundo y la capacidad de manejar millones de solicitudes por segundo, Redis se ha convertido en el estándar de la industria para almacenamiento en caché de alto rendimiento.

Implementar caché con Redis puede transformar el rendimiento de las aplicaciones, reduciendo los tiempos de respuesta en un 80-95% y la carga de la base de datos en un 70-90%. Sin embargo, una configuración incorrecta puede llevar a agotamiento de memoria, pérdida de datos o vulnerabilidades de seguridad. Comprender la arquitectura de Redis, opciones de persistencia, políticas de expulsión y técnicas de optimización es crucial para maximizar sus beneficios mientras se mantiene la confiabilidad del sistema.

Esta guía completa cubre la instalación de Redis, mejores prácticas de configuración, estrategias de almacenamiento en caché, optimización de rendimiento y ejemplos de implementación del mundo real. Aprenderás cómo aprovechar Redis para construir aplicaciones de alto rendimiento y escalables con mejoras de rendimiento medibles.

Comprendiendo Redis como Caché

¿Por Qué Redis para Caché?

Ventajas Clave:

• Velocidad: El almacenamiento en memoria proporciona latencia submilisegundo
• Estructuras de Datos: Tipos de datos ricos (strings, hashes, listas, sets, sorted sets)
• Opciones de Persistencia: Compensaciones configurables entre durabilidad y rendimiento
• Operaciones Atómicas: Soporte integrado para operaciones complejas
• Pub/Sub: Capacidades de mensajería en tiempo real
• Clustering: Soporte de escalado horizontal

Redis vs Otras Soluciones de Caché

Casos de Uso Comunes

1. Almacenamiento de Sesiones: Datos de sesión de usuario
2. Caché de Páginas: Páginas HTML completas
3. Resultados de Consultas de Base de Datos: Caché de consultas costosas
4. Caché de Respuestas API: Resultados de llamadas a APIs externas
5. Rate Limiting: Limitación de solicitudes
6. Tablas de Clasificación: Sets ordenados para rankings
7. Analíticas en Tiempo Real: Contadores y estadísticas

Instalación y Configuración Básica

Instalando Redis

# Ubuntu/Debian
apt-get update
apt-get install redis-server -y

# CentOS/RHEL/Rocky Linux
dnf install redis -y

# Desde fuente (última versión)
wget https://download.redis.io/redis-stable.tar.gz
tar xzf redis-stable.tar.gz
cd redis-stable
make
make install

# Verificar instalación
redis-server --version
redis-cli --version

Configuración Básica

# Archivo de configuración principal
vim /etc/redis/redis.conf

# Configuraciones esenciales
bind 127.0.0.1 ::1              # Escuchar solo en localhost
port 6379                        # Puerto predeterminado
daemonize yes                    # Ejecutar como daemon
pidfile /var/run/redis/redis.pid # Ubicación del archivo PID
logfile /var/log/redis/redis.log # Ubicación del archivo de log
dir /var/lib/redis               # Directorio de trabajo

Iniciando Redis

# Usando systemd
systemctl start redis
systemctl enable redis
systemctl status redis

# Verificar que Redis está corriendo
redis-cli ping
# Respuesta: PONG

# Verificar conexión
redis-cli
127.0.0.1:6379> INFO server
127.0.0.1:6379> exit

Pruebas de Rendimiento de Redis

Pruebas de Rendimiento Base

# Herramienta de benchmark incorporada
redis-benchmark -q -n 100000

# Resultados (típicos en hardware moderno):
# PING_INLINE: 98814.23 requests per second
# PING_BULK: 99502.48 requests per second
# SET: 97560.98 requests per second
# GET: 99009.90 requests per second
# INCR: 98814.23 requests per second
# LPUSH: 97560.98 requests per second
# RPUSH: 98522.17 requests per second
# LPOP: 98039.22 requests per second
# RPOP: 98039.22 requests per second
# SADD: 98814.23 requests per second
# HSET: 96525.09 requests per second
# SPOP: 99009.90 requests per second
# ZADD: 97560.98 requests per second
# ZPOPMIN: 98814.23 requests per second
# LPUSH (needed to benchmark LRANGE): 98039.22 requests per second
# LRANGE_100 (first 100 elements): 31887.76 requests per second
# LRANGE_300 (first 300 elements): 13055.53 requests per second
# LRANGE_500 (first 500 elements): 8885.97 requests per second
# LRANGE_600 (first 600 elements): 7436.22 requests per second
# MSET (10 keys): 74349.45 requests per second

Benchmarks Personalizados

# Probar operaciones específicas
redis-benchmark -t set,get -n 1000000 -q

# Probar con pipelines
redis-benchmark -n 100000 -P 16 -q

# Probar con diferentes tamaños de datos
redis-benchmark -t set -n 100000 -d 1024 -q  # Valores 1KB

# Prueba de clientes concurrentes
redis-benchmark -c 100 -n 1000000 -q

Tiempo de Respuesta Base de la Aplicación

Sin Caché de Redis:

# Ejemplo de consulta de base de datos
time curl http://localhost/api/products
# Tiempo de respuesta: 450ms
# Consultas a base de datos: 15
# Uso de CPU: 35%

Configuración y Optimización de Memoria

Configuración de Límite de Memoria

# Editar redis.conf
vim /etc/redis/redis.conf

# Establecer memoria máxima
maxmemory 2gb

# Establecer política de expulsión (discutida en la siguiente sección)
maxmemory-policy allkeys-lru

# Muestras de memoria para algoritmos LRU/LFU
maxmemory-samples 5

# Reiniciar Redis
systemctl restart redis

Verificando Uso de Memoria

# Conectar a Redis
redis-cli

# Ver estadísticas de memoria
127.0.0.1:6379> INFO memory

# Métricas clave:
# used_memory_human:1.23M           # Memoria real usada
# used_memory_peak_human:2.45M      # Pico de uso de memoria
# maxmemory_human:2.00G             # Límite configurado
# mem_fragmentation_ratio:1.23      # Ratio de fragmentación

# Verificar tamaño de claves individuales
127.0.0.1:6379> MEMORY USAGE keyname

Políticas de Expulsión

Redis proporciona varias políticas de expulsión cuando se alcanza el límite de memoria:

# En redis.conf:

# Sin expulsión - devolver errores cuando se alcanza el límite de memoria
maxmemory-policy noeviction

# LRU (Least Recently Used) - más común para caché
maxmemory-policy allkeys-lru    # Considerar todas las claves
maxmemory-policy volatile-lru   # Solo claves con TTL

# LFU (Least Frequently Used) - para caché basado en frecuencia
maxmemory-policy allkeys-lfu    # Considerar todas las claves
maxmemory-policy volatile-lfu   # Solo claves con TTL

# Expulsión aleatoria
maxmemory-policy allkeys-random # Aleatorio de todas las claves
maxmemory-policy volatile-random # Aleatorio de claves con TTL

# Expulsión basada en TTL
maxmemory-policy volatile-ttl   # Expulsar claves más cercanas a expiración

# Recomendado para caché: allkeys-lru o allkeys-lfu

Técnicas de Optimización de Memoria

# 1. Usar estructuras de datos apropiadas
# Malo: Muchas claves separadas
SET user:1:name "John"
SET user:1:email "[email protected]"
SET user:1:age "30"

# Bueno: Hash único
HMSET user:1 name "John" email "[email protected]" age 30

# 2. Establecer tiempos de expiración
SET cache:page:home "HTML content" EX 3600  # 1 hora

# 3. Comprimir valores grandes (nivel de aplicación)
# Antes de almacenar, comprimir con gzip/zlib

# 4. Usar prefijos de clave para organización
# user:session:abc123
# cache:api:users:list
# temp:calculation:xyz789

Configuración de Persistencia

Comprendiendo Opciones de Persistencia

RDB (Redis Database Backup):

• Snapshots en punto en el tiempo
• Mejor rendimiento, intervalos más largos entre guardados
• Riesgo de pérdida de datos entre snapshots

AOF (Append-Only File):

• Registra cada operación de escritura
• Mejor durabilidad, mínima pérdida de datos
• Tamaño de archivo mayor, recuperación más lenta

Configuración RDB

# Editar redis.conf
vim /etc/redis/redis.conf

# Snapshots RDB
save 900 1      # Guardar si 1 clave cambió en 900 segundos
save 300 10     # Guardar si 10 claves cambiaron en 300 segundos
save 60 10000   # Guardar si 10000 claves cambiaron en 60 segundos

# Recomendado para caché (guardados menos frecuentes)
save 3600 1     # Guardar cada hora si al menos 1 cambio
save 900 100    # Guardar cada 15 min si al menos 100 cambios
save 300 10000  # Guardar cada 5 min si al menos 10000 cambios

# Configuración de archivo RDB
dbfilename dump.rdb
dir /var/lib/redis
rdbcompression yes
rdbchecksum yes

# Detener escrituras si RDB falla (opcional)
stop-writes-on-bgsave-error yes

Configuración AOF

# Habilitar AOF
appendonly yes
appendfilename "appendonly.aof"

# Frecuencia de sincronización AOF
# Siempre: Más lento, más durable
# appendfsync always

# Cada segundo: Buen balance (RECOMENDADO para caché)
appendfsync everysec

# Sin fsync: Más rápido, menos durable
# appendfsync no

# Configuración de reescritura AOF
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# Reescritura AOF durante snapshot
no-appendfsync-on-rewrite no

Recomendaciones de Persistencia por Caso de Uso

# Caché puro (los datos pueden regenerarse)
save ""                    # Deshabilitar RDB
appendonly no             # Deshabilitar AOF

# Caché con algo de persistencia (recomendado)
save 3600 1               # Snapshots cada hora
appendonly yes
appendfsync everysec

# Datos críticos (no típico para caché)
save 300 10
appendonly yes
appendfsync always

Configuración de Seguridad

Autenticación

# Establecer contraseña en redis.conf
vim /etc/redis/redis.conf

# Agregar contraseña fuerte
requirepass your_very_strong_password_here

# Reiniciar Redis
systemctl restart redis

# Conectar con autenticación
redis-cli -a your_very_strong_password_here

# O autenticar después de conectar
redis-cli
127.0.0.1:6379> AUTH your_very_strong_password_here
OK

Seguridad de Red

# Vincular a interfaces específicas
# Predeterminado: bind 127.0.0.1 ::1 (solo localhost - RECOMENDADO)
bind 127.0.0.1 ::1

# Si se necesita acceso remoto, usar IPs específicas
bind 127.0.0.1 192.168.1.100

# O todas las interfaces (NO RECOMENDADO sin firewall)
# bind 0.0.0.0

# Habilitar modo protegido (predeterminado)
protected-mode yes

# Cambiar puerto predeterminado (seguridad por oscuridad)
port 6380

Configuración de Firewall

# UFW (Ubuntu)
ufw allow from 192.168.1.0/24 to any port 6379 proto tcp
ufw enable

# Firewalld (CentOS/Rocky)
firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="6379" accept'
firewall-cmd --reload

# Iptables
iptables -A INPUT -p tcp -s 192.168.1.0/24 --dport 6379 -j ACCEPT
iptables -A INPUT -p tcp --dport 6379 -j DROP

Deshabilitar Comandos Peligrosos

# En redis.conf
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command KEYS ""
rename-command CONFIG "CONFIG_abc123xyz"
rename-command SHUTDOWN ""

Optimización de Rendimiento

Connection Pooling

El pooling de conexiones es crítico para el rendimiento de la aplicación:

Ejemplo Python:

import redis

# Crear pool de conexiones
pool = redis.ConnectionPool(
    host='localhost',
    port=6379,
    password='your_password',
    max_connections=50,
    decode_responses=True
)

# Usar pool en aplicación
redis_client = redis.Redis(connection_pool=pool)

Ejemplo Node.js:

const redis = require('redis');

// Crear cliente con pooling
const client = redis.createClient({
    host: 'localhost',
    port: 6379,
    password: 'your_password',
    max_clients: 50,
    retry_strategy: function(options) {
        if (options.total_retry_time > 1000 * 60 * 60) {
            return new Error('Retry time exhausted');
        }
        return Math.min(options.attempt * 100, 3000);
    }
});

Pipelining

Reducir viajes de red por lotes agrupando comandos:

# Sin pipelining: 5 viajes de red
redis-cli SET key1 "value1"
redis-cli SET key2 "value2"
redis-cli SET key3 "value3"
redis-cli SET key4 "value4"
redis-cli SET key5 "value5"

# Con pipelining: 1 viaje de red
cat << EOF | redis-cli --pipe
SET key1 "value1"
SET key2 "value2"
SET key3 "value3"
SET key4 "value4"
SET key5 "value5"
EOF

Ejemplo Python:

# Sin pipeline
for i in range(10000):
    redis_client.set(f'key:{i}', f'value:{i}')
# Tiempo: ~5 segundos

# Con pipeline
pipe = redis_client.pipeline()
for i in range(10000):
    pipe.set(f'key:{i}', f'value:{i}')
pipe.execute()
# Tiempo: ~0.5 segundos (10x más rápido)

Convenciones de Nomenclatura de Claves

# Usar nombres de clave estructurados con dos puntos
# Formato: objeto:id:campo

# Buenos ejemplos:
user:1000:profile
user:1000:sessions
cache:api:users:list:page:1
temp:calculation:user:1000:result

# Malos ejemplos:
user_profile_1000        # Más difícil de consultar/organizar
u1000                    # No descriptivo
cache_20260111_users     # Fecha en nombre de clave (antipatrón)

Ajuste de Backlog TCP

# En redis.conf
tcp-backlog 511

# Aumentar para escenarios de alta conexión
tcp-backlog 65535

# También ajustar parámetros del kernel
echo "net.core.somaxconn = 65535" >> /etc/sysctl.conf
sysctl -p

Configuración de Timeout

# Timeout de cliente (segundos)
timeout 300

# Para servidor de caché, timeout más corto aceptable
timeout 60

# TCP keepalive
tcp-keepalive 300

Estrategias y Patrones de Caché

Cache-Aside (Lazy Loading)

Patrón más común para caché:

def get_user(user_id):
    # Intentar obtener de caché
    cached_user = redis_client.get(f'user:{user_id}')

    if cached_user:
        # Acierto de caché
        return json.loads(cached_user)

    # Fallo de caché - obtener de base de datos
    user = database.query(f"SELECT * FROM users WHERE id = {user_id}")

    # Almacenar en caché para futuras solicitudes
    redis_client.setex(
        f'user:{user_id}',
        3600,  # TTL de 1 hora
        json.dumps(user)
    )

    return user

# Mejora de rendimiento:
# Acierto de caché: 1ms (99% más rápido que base de datos)
# Fallo de caché: 100ms (tiempo de consulta de base de datos)
# Ratio de aciertos de caché: 95% típico
# Tiempo de respuesta promedio: 5.95ms (vs 100ms sin caché)

Read-Through Cache

El caché carga datos automáticamente en fallo:

class ReadThroughCache:
    def get(self, key, fetch_function, ttl=3600):
        # Intentar caché primero
        cached_value = redis_client.get(key)

        if cached_value:
            return json.loads(cached_value)

        # Obtener y cachear
        value = fetch_function()
        redis_client.setex(key, ttl, json.dumps(value))

        return value

# Uso
cache = ReadThroughCache()
user = cache.get(
    f'user:{user_id}',
    lambda: database.query(f"SELECT * FROM users WHERE id = {user_id}"),
    ttl=3600
)

Write-Through Cache

Actualizar caché y base de datos simultáneamente:

def update_user(user_id, user_data):
    # Actualizar base de datos
    database.update(f"UPDATE users SET ... WHERE id = {user_id}")

    # Actualizar caché inmediatamente
    redis_client.setex(
        f'user:{user_id}',
        3600,
        json.dumps(user_data)
    )

    return user_data

Write-Behind (Write-Back) Cache

Escribir en caché inmediatamente, base de datos asíncronamente:

def update_user_async(user_id, user_data):
    # Escribir en caché inmediatamente
    redis_client.setex(
        f'user:{user_id}',
        3600,
        json.dumps(user_data)
    )

    # Encolar actualización de base de datos para procesamiento en segundo plano
    redis_client.lpush('db_write_queue', json.dumps({
        'type': 'user_update',
        'user_id': user_id,
        'data': user_data
    }))

    return user_data

# Worker en segundo plano procesa cola
def process_write_queue():
    while True:
        item = redis_client.brpop('db_write_queue', timeout=1)
        if item:
            data = json.loads(item[1])
            database.update(...)  # Escritura real a base de datos

Estrategias de Invalidación de Caché

# 1. Basado en TTL (más simple)
redis_client.setex('key', 3600, 'value')  # Auto-expira en 1 hora

# 2. Invalidación basada en eventos
def update_user(user_id, user_data):
    database.update(...)
    redis_client.delete(f'user:{user_id}')  # Eliminar de caché

# 3. Invalidación basada en patrón
def clear_user_cache(user_id):
    # Eliminar todas las claves que coincidan con el patrón
    keys = redis_client.keys(f'user:{user_id}:*')
    if keys:
        redis_client.delete(*keys)

# 4. Invalidación basada en etiquetas (usando sets)
def tag_cache(key, tags):
    redis_client.set(key, value)
    for tag in tags:
        redis_client.sadd(f'tag:{tag}', key)

def invalidate_by_tag(tag):
    keys = redis_client.smembers(f'tag:{tag}')
    if keys:
        redis_client.delete(*keys)
        redis_client.delete(f'tag:{tag}')

Ejemplos de Implementación del Mundo Real

Ejemplo 1: Caché de Consultas de Base de Datos

import redis
import json
import hashlib
from functools import wraps

redis_client = redis.Redis(
    host='localhost',
    port=6379,
    password='your_password',
    decode_responses=True
)

def cache_query(ttl=3600):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Crear clave de caché desde nombre de función y argumentos
            cache_key = f"query:{func.__name__}:{hashlib.md5(str(args).encode() + str(kwargs).encode()).hexdigest()}"

            # Intentar obtener de caché
            cached_result = redis_client.get(cache_key)
            if cached_result:
                return json.loads(cached_result)

            # Ejecutar consulta
            result = func(*args, **kwargs)

            # Almacenar en caché
            redis_client.setex(cache_key, ttl, json.dumps(result))

            return result
        return wrapper
    return decorator

# Uso
@cache_query(ttl=1800)
def get_products(category, limit=10):
    # Consulta costosa de base de datos
    return database.query(f"SELECT * FROM products WHERE category = '{category}' LIMIT {limit}")

# Resultados de rendimiento:
# Primera llamada (fallo de caché): 450ms
# Llamadas subsiguientes (acierto de caché): 2ms
# Mejora de rendimiento de 225x

Ejemplo 2: Caché de Respuestas API

from flask import Flask, jsonify, request
import redis
import json

app = Flask(__name__)
redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

@app.route('/api/products')
def get_products():
    # Crear clave de caché desde parámetros de solicitud
    cache_key = f"api:products:{request.query_string.decode()}"

    # Intentar caché
    cached_response = redis_client.get(cache_key)
    if cached_response:
        return jsonify(json.loads(cached_response))

    # Obtener de base de datos
    products = fetch_products_from_db()

    # Cachear por 5 minutos
    redis_client.setex(cache_key, 300, json.dumps(products))

    return jsonify(products)

# Resultados:
# Antes de caché: 350ms tiempo de respuesta promedio
# Después de caché: 15ms tiempo de respuesta promedio (95% tasa de aciertos de caché)
# Consultas de base de datos reducidas en 95%

Ejemplo 3: Almacenamiento de Sesiones

from flask import Flask, session
from flask_session import Session
import redis

app = Flask(__name__)

# Configurar Redis para almacenamiento de sesiones
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(
    host='localhost',
    port=6379,
    password='your_password'
)
app.config['SESSION_PERMANENT'] = False
app.config['SESSION_USE_SIGNER'] = True
app.config['SECRET_KEY'] = 'your-secret-key'

Session(app)

@app.route('/login', methods=['POST'])
def login():
    # Almacenar datos de sesión en Redis
    session['user_id'] = user_id
    session['username'] = username
    return jsonify({'status': 'logged in'})

# Beneficios de rendimiento:
# Lecturas de sesión: < 1ms (vs 50ms consulta de base de datos)
# Escalabilidad: Sesiones compartidas entre servidores de app
# Expiración automática: Soporte TTL incorporado

Ejemplo 4: Rate Limiting

import redis
import time

redis_client = redis.Redis(host='localhost', port=6379)

def rate_limit(key, max_requests, window_seconds):
    """
    Rate limiting usando ventana deslizante
    """
    current_time = int(time.time())
    window_start = current_time - window_seconds

    # Eliminar solicitudes antiguas fuera de la ventana
    redis_client.zremrangebyscore(key, 0, window_start)

    # Contar solicitudes en ventana actual
    request_count = redis_client.zcard(key)

    if request_count < max_requests:
        # Agregar solicitud actual
        redis_client.zadd(key, {current_time: current_time})
        redis_client.expire(key, window_seconds)
        return True

    return False

# Uso en endpoint API
@app.route('/api/data')
def get_data():
    ip_address = request.remote_addr
    rate_limit_key = f"rate_limit:{ip_address}"

    if not rate_limit(rate_limit_key, max_requests=100, window_seconds=60):
        return jsonify({'error': 'Rate limit exceeded'}), 429

    return jsonify({'data': 'your data'})

# Resultados:
# Previene abuso de API: Aplica 100 solicitudes/minuto por IP
# Rendimiento: < 1ms por verificación
# Sin carga de base de datos para rate limiting

Ejemplo 5: Tabla de Clasificación

import redis

redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

def update_score(user_id, score):
    """Actualizar puntuación de usuario en tabla de clasificación"""
    redis_client.zadd('leaderboard', {user_id: score})

def get_top_players(count=10):
    """Obtener top N jugadores"""
    return redis_client.zrevrange('leaderboard', 0, count-1, withscores=True)

def get_user_rank(user_id):
    """Obtener rango del usuario (indexado desde 0)"""
    return redis_client.zrevrank('leaderboard', user_id)

def get_user_score(user_id):
    """Obtener puntuación actual del usuario"""
    return redis_client.zscore('leaderboard', user_id)

# Uso
update_score('user:1000', 9500)
update_score('user:1001', 10200)
update_score('user:1002', 8750)

top_10 = get_top_players(10)
# [('user:1001', 10200.0), ('user:1000', 9500.0), ('user:1002', 8750.0)]

rank = get_user_rank('user:1000')
# 1 (segundo lugar)

# Rendimiento:
# Actualizar puntuación: < 1ms
# Obtener tabla de clasificación: < 5ms para top 1000
# Obtener rango: < 1ms
# Maneja millones de usuarios eficientemente

Monitoreo y Mantenimiento

Métricas Clave a Monitorear

# Conectar a Redis
redis-cli

# Métricas esenciales
127.0.0.1:6379> INFO stats

# Monitorear comandos en tiempo real
127.0.0.1:6379> MONITOR

# Obtener log lento
127.0.0.1:6379> SLOWLOG GET 10

# Info de memoria
127.0.0.1:6379> INFO memory

# Conexiones de clientes
127.0.0.1:6379> CLIENT LIST

# Info de espacio de claves
127.0.0.1:6379> INFO keyspace

Script de Monitoreo

#!/bin/bash
# /usr/local/bin/redis-monitor.sh

REDIS_CLI="redis-cli -a your_password"
LOG_FILE="/var/log/redis-monitor.log"

echo "=== Monitor de Redis - $(date) ===" >> $LOG_FILE

# Uso de memoria
MEMORY=$($REDIS_CLI INFO memory | grep used_memory_human | cut -d: -f2)
echo "Memoria: $MEMORY" >> $LOG_FILE

# Clientes conectados
CLIENTS=$($REDIS_CLI INFO clients | grep connected_clients | cut -d: -f2)
echo "Clientes conectados: $CLIENTS" >> $LOG_FILE

# Operaciones por segundo
OPS=$($REDIS_CLI INFO stats | grep instantaneous_ops_per_sec | cut -d: -f2)
echo "Ops/sec: $OPS" >> $LOG_FILE

# Espacio de claves
KEYS=$($REDIS_CLI DBSIZE)
echo "Total de claves: $KEYS" >> $LOG_FILE

# Tasa de aciertos de caché
HITS=$($REDIS_CLI INFO stats | grep keyspace_hits | cut -d: -f2)
MISSES=$($REDIS_CLI INFO stats | grep keyspace_misses | cut -d: -f2)
TOTAL=$((HITS + MISSES))
if [ $TOTAL -gt 0 ]; then
    HIT_RATE=$((HITS * 100 / TOTAL))
    echo "Tasa de aciertos de caché: ${HIT_RATE}%" >> $LOG_FILE
fi

echo "" >> $LOG_FILE

chmod +x /usr/local/bin/redis-monitor.sh
# Ejecutar cada 5 minutos
*/5 * * * * /usr/local/bin/redis-monitor.sh

Tareas de Mantenimiento

# 1. Respaldar datos de Redis
redis-cli BGSAVE
# O programar respaldos regulares
0 2 * * * redis-cli -a password BGSAVE

# 2. Analizar uso de memoria
redis-cli --bigkeys

# 3. Limpiar claves expiradas
# Redis hace esto automáticamente, pero puedes forzarlo:
redis-cli --scan --pattern "temp:*" | xargs redis-cli DEL

# 4. Monitorear consultas lentas
redis-cli SLOWLOG GET 100

# 5. Verificar fragmentación
redis-cli INFO memory | grep mem_fragmentation_ratio
# Ratio > 1.5 puede indicar necesidad de reinicio

Solución de Problemas

Alto Uso de Memoria

# Identificar claves grandes
redis-cli --bigkeys

# Verificar uso de memoria por clave
redis-cli MEMORY USAGE keyname

# Analizar memoria por patrón
redis-cli --scan --pattern "user:*" | head -100 | xargs redis-cli MEMORY USAGE

# Solución: Implementar política de expulsión apropiada
# maxmemory-policy allkeys-lru

Rendimiento Lento

# Verificar log lento
redis-cli SLOWLOG GET 10

# Monitorear operaciones
redis-cli MONITOR | head -100

# Verificar operaciones bloqueantes
# Evitar: KEYS, FLUSHDB, FLUSHALL en producción
# Usar: SCAN en lugar de KEYS

# Solución: Usar pipelining, optimizar consultas

Problemas de Conexión

# Verificar conexiones
redis-cli CLIENT LIST

# Verificar máximo de conexiones
redis-cli CONFIG GET maxclients

# Aumentar si es necesario
redis-cli CONFIG SET maxclients 10000

# Hacer persistente en redis.conf
maxclients 10000

Conclusión

El caché con Redis es una técnica poderosa para mejorar drásticamente el rendimiento de las aplicaciones. Una configuración e implementación adecuadas pueden ofrecer beneficios sustanciales:

Mejoras de Rendimiento:

• Tiempo de respuesta: 80-95% de reducción
• Carga de base de datos: 70-90% de reducción
• Rendimiento: 5-50x de aumento
• Costos de infraestructura: 30-60% de reducción

Factores Clave de Éxito:

1. Elegir política de expulsión apropiada según caso de uso
2. Implementar estrategia apropiada de invalidación de caché
3. Usar connection pooling para eficiencia de aplicación
4. Monitorear tasas de aciertos de caché y ajustar TTLs
5. Balancear necesidades de persistencia vs rendimiento

Mejores Prácticas:

• Comenzar con patrón cache-aside
• Usar nomenclatura de claves estructurada
• Establecer TTLs apropiados en todas las claves
• Implementar connection pooling
• Monitorear uso de memoria y tasas de aciertos
• Usar pipelining para operaciones masivas
• Asegurar Redis apropiadamente (autenticación, restricciones de red)

Al implementar el caché de Redis estratégicamente con configuración y monitoreo apropiados, puedes transformar el rendimiento, la experiencia de usuario y la eficiencia de infraestructura de tu aplicación. Los ejemplos y técnicas en esta guía proporcionan una base sólida para construir soluciones de caché de alto rendimiento y escalables.