Redis

Databases
cache
Message Brokers
Valkey

📘 Documentación y Alternativas

Community Edition - Docs
Alternativa open source: Valkey Documentation Quick start guide-
- Valkey surge como una bifurcación de Redis mantenida por la comunidad tras cambios en la licencia de Redis.
- Ofrece compatibilidad con el protocolo Redis, por lo que se puede usar como reemplazo directo.
- Enfocada en mantener un modelo 100% open source y extender las capacidades de Redis en entornos distribuidos.
What is BullMQ BullMQ-

⚙️ Conceptos Fundamentales

Base de datos NoSQL tipo Key-Value:
Redis almacena datos como pares clave-valor, soportando tipos complejos como listas, hashes, sets, y sorted sets.
Es extremadamente rápido debido a que trabaja principalmente en memoria (RAM).
Cache, Disco y Streaming:
Redis puede actuar como:
- Cache en memoria (baja latencia y alto rendimiento).
- Persistencia en disco mediante snapshots (RDB) o logs de operaciones (AOF).
- Sistema de streaming con Redis Streams, ideal para colas de mensajes y procesamiento de eventos.
1 solo hilo (single-threaded):
El procesamiento de comandos se ejecuta en un único hilo principal, aunque puede haber procesos auxiliares para tareas de E/S o persistencia.
Redis aprovecha operaciones atómicas en memoria, eliminando la necesidad de locks complejos.
Estructuras de datos principales:
- Strings: valores simples o binarios.
- Lists: colas FIFO/LIFO.
- Sets: conjuntos sin duplicados.
- Sorted Sets: conjuntos ordenados con puntuación (ranking).
- Hashes: representación eficiente de objetos (similar a JSON o diccionarios).
- Streams: listas de eventos con IDs únicos, ideales para mensajería o logs.

🧩 Persistencia y Recuperación de Datos

RDB (Redis Database Backup):
- Crea snapshots periódicos del dataset.
- Rápido para restaurar pero puede perder los últimos cambios si Redis se apaga abruptamente.
AOF (Append Only File):
- Registra cada comando de escritura.
- Permite reconstruir el estado exacto del servidor tras un fallo.
- Puede combinarse con RDB (modo híbrido) para optimizar rendimiento y seguridad.
Recuperación de datos (AOF / RDB):
- Configurable en redis.conf.
- Puede activarse la reescritura del AOF para reducir tamaño y mejorar eficiencia.
Pérdida de datos:
- Si solo se usa RDB, existe riesgo de pérdida entre snapshots.
- Usar AOF o replicación minimiza este riesgo.
- Redis también soporta appendfsync always para máxima seguridad (aunque con menor rendimiento).

🔒 Transacciones y Modo Multi

Transacciones (MULTI / EXEC):
- Agrupan comandos que se ejecutan secuencialmente sin interrupciones.
- No hay rollback automático, pero sí aislamiento durante la ejecución.
Modo Multi / Atomicidad:
- Todos los comandos entre MULTI y EXEC son atómicos.
- Puede usarse junto con WATCH para detectar cambios y evitar condiciones de carrera.

⚡️ Conjuntos, Rankings y Operaciones Avanzadas

Ranking:
- Con ZADD, ZRANGE, ZREVRANK, Redis permite crear sistemas de puntuación o leaderboards.
- Ideal para aplicaciones de juegos o métricas.
Índices y búsquedas:
- Redis no tiene índices como SQL, pero puede simularlos usando hashes o sorted sets.
- RedisJSON y RediSearch extienden estas capacidades.

🔄 Integración con Node.js

Getting Started with Node and Redis
- Uso de redis (cliente oficial) o ioredis.
- Ejemplo básico:

Ejemplo: conexión y set/get

import { createClient } from 'redis';

const client = createClient();

await client.connect();
await client.set('message', 'Hola Redis!');
const value = await client.get('message');
console.log(value);

await client.quit();

🧰 Recursos y Cheatsheets

Redis Commands Cheat sheet
- Incluye comandos esenciales: SET, GET, DEL, INCR, LPUSH, SADD, HSET, ZADD, etc.
- Útil para recordatorio rápido de sintaxis y opciones.

🎥 Videos y Aprendizaje Visual

Redis: base de datos multi-propósito - YouTube
- Explica el uso de Redis como cache, base de datos, y message broker.
- Incluye demostraciones prácticas y casos de uso reales.

💡 Casos de Uso Recomendados

Cachear resultados de consultas SQL o API.
Sesiones de usuario en aplicaciones web.
Sistemas de colas y eventos (con Streams o Pub/Sub).
Rankings y conteo de puntuaciones.
Control de tasa (rate limiting) mediante incrementos atómicos.
Almacenamiento temporal de tokens o datos de sesión.

🔧 Consejos de Configuración

Ajustar maxmemory-policy para definir qué hacer cuando se llena la memoria (por ejemplo, volatile-lru).
Activar persistencia híbrida (AOF + RDB) para equilibrio entre rendimiento y seguridad.
Usar réplicas (replicaof) para alta disponibilidad.
Configurar redis-cli --latency para medir rendimiento.

Redis - Avanzado y Arquitectura

Redis
Databases
cache
Message Brokers
High Availability
Scalability
Security
Performance Tuning
Observability
Cluster Mode
Replication

🧱 Arquitectura Interna

Modelo en memoria:
Redis mantiene todos los datos en RAM, con respaldo opcional en disco.
Esto permite tiempos de respuesta del orden de microsegundos.
El trade-off es el consumo de memoria y el coste de almacenamiento.
Event Loop:
Redis usa un bucle de eventos no bloqueante basado en epoll (Linux) o kqueue (BSD/Mac).
Todas las conexiones se manejan de forma asíncrona en un único hilo principal, maximizando el rendimiento.
I/O threads (Redis 6+):
Desde Redis 6, puede habilitarse procesamiento de entrada/salida en hilos paralelos, mejorando throughput en cargas intensivas de red.
Se activa con io-threads-do-reads yes.

⚙️ Modo Cluster y Replicación

Cluster Mode:
Permite distribuir los datos en múltiples nodos (sharding automático).
Las claves se asignan mediante hash slots (0–16383) repartidos entre nodos.
Redis Cluster ofrece:
- Escalabilidad horizontal.
- Failover automático.
- Alta disponibilidad.
Replicación:
- Cada nodo primario puede tener uno o más réplicas (read-only).
- Sincronización asíncrona mediante PSYNC.
- Comando: replicaof <host> <port> o configuración en redis.conf.
Failover automático:
En Cluster o Sentinel, si un master falla, una réplica es promovida automáticamente.
Esto garantiza continuidad sin intervención manual.

🧭 Sentinel - Alta Disponibilidad

High Availability con Sentinel:
Redis Sentinel supervisa instancias Redis y maneja:
- Monitoring: detección de fallos.
- Notification: alertas cuando un nodo no responde.
- Automatic failover: elección de nueva réplica principal.
- Configuration provider: clientes pueden consultar qué nodo es el actual master.
Ejemplo de configuración mínima:

sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000

🔐 Seguridad

Autenticación:
- Configurar requirepass <password> en redis.conf.
- Redis 6+ permite usuarios y ACLs (ACL SETUSER, ACL SAVE).
ACLs (Access Control Lists): Permiten asignar permisos granulares a usuarios específicos. Ejemplo:

ACL SETUSER api_user on >secretpass ~api:* +get +set

Cifrado: Redis soporta TLS/SSL nativo (tls-port 6380, tls-cert-file, tls-key-file). Ideal para entornos en nube o comunicaciones inter-nodo seguras.
Aislamiento de red: Siempre ejecutar Redis detrás de firewalls, proxies inversos o redes privadas (VPN, VPC).

🚀 Performance y Optimización

Evitar grandes keys o valores: Redis no fragmenta internamente, por lo que usar objetos grandes degrada el rendimiento.
Pipeline y batch: Enviar múltiples comandos en un solo round trip para reducir latencia:

const pipeline = client.multi();
pipeline.set("a", 1);
pipeline.incr("a");
const results = await pipeline.exec();

Eviction policies: Define cómo Redis maneja la memoria llena (maxmemory-policy):
- noeviction, allkeys-lru, volatile-lfu, etc.
- Ejemplo: maxmemory-policy volatile-lru
Evitar bloqueo con Lua Scripts: Permite ejecutar operaciones atómicas complejas:

EVAL "return redis.call('incr', KEYS[1])" 1 mycounter

📈 Observabilidad y Monitorización

Logs y métricas:
- INFO muestra estadísticas detalladas del servidor.
- MONITOR permite observar en tiempo real todos los comandos ejecutados.
- SLOWLOG get identifica operaciones lentas.
Integración con Prometheus / Grafana:
- Exportadores oficiales: redis_exporter.
- Métricas clave: latencia, memoria usada, hits/misses, clients connected.
Comando LATENCY DOCTOR: Analiza problemas de latencia y recomienda optimizaciones.

🌐 Redis Modules

RedisJSON: almacenamiento de documentos JSON.
RediSearch: búsqueda full-text e índices secundarios.
RedisGraph: consultas tipo grafo (Cypher).
RedisBloom: filtros probabilísticos (Bloom, Cuckoo, Top-K).
RedisTimeSeries: series temporales con agregaciones y compresión.

Cada módulo extiende Redis sin modificar su núcleo, manteniendo el mismo protocolo y API.

🧰 Integración con Entornos Modernos

Docker & Compose: Redis puede ejecutarse en contenedores fácilmente:

services:
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - ./data:/data

Kubernetes:
- Redis Operator simplifica despliegues con Sentinel, réplicas y PVCs.
- Escalado automático con HorizontalPodAutoscaler.
Cloud Services:
- Redis Enterprise (Redis Inc.)
- AWS ElastiCache
- Azure Cache for Redis
- Google Memorystore

🧠 Casos de Uso Avanzados

Pub/Sub: comunicación entre microservicios.
Rate Limiting: control de peticiones por IP o token.
Job Queues: usando listas o Streams (XADD, XREADGROUP).
Session Store: persistencia de sesiones en Node.js, Python, PHP.
Real-Time Analytics: contadores, leaderboard, y dashboards en vivo.
Event Sourcing: almacenar cambios como eventos inmutables en Streams.

🔍 Recursos Adicionales

Redis en Entornos de Producción

Redis
Redis - Avanzado y Arquitectura
Production Deployment
High Availability
Monitoring
Security
DevOps
Docker
Kubernetes

🏗️ Arquitectura de Producción

Diseño base:
Redis debe desplegarse con redundancia y persistencia activada.
El esquema más común:
- 1 master + múltiples réplicas.
- Sentinel o Cluster para failover.
- Monitorización constante (Prometheus/Grafana).
- Backups automáticos a disco o nube.
Topología recomendada:
- Entorno mínimo:
  - redis-master
  - redis-replica-1, redis-replica-2
  - redis-sentinel-1, redis-sentinel-2, redis-sentinel-3
- En producción se recomienda separar réplicas por zonas de disponibilidad (AZ).

⚙️ Configuración Recomendada

Archivo redis.conf:
- save 900 1 → Snapshot cada 15 min si al menos 1 key cambia.
- appendonly yes → Activar AOF.
- appendfsync everysec → Seguridad + rendimiento equilibrado.
- maxmemory <cantidad> → Limitar uso de RAM.
- maxmemory-policy volatile-lru → Evicta las menos usadas.
- protected-mode yes → Imprescindible en entornos abiertos.
- tcp-keepalive 60 → Detectar desconexiones de clientes.
- loglevel notice → Nivel equilibrado de logs.
Logs:
- Registrar en /var/log/redis/redis-server.log o redirigir a un sistema central (ELK, Loki).
- Usar syslog-enabled yes para integración con journald.

🧩 Despliegue con Docker Compose

version: "3.9"
services:
  redis:
    image: redis:7-alpine
    container_name: redis-master
    ports:
      - "6379:6379"
    volumes:
      - ./data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf
    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
    restart: unless-stopped

  redis-replica:
    image: redis:7-alpine
    depends_on:
      - redis
    command: ["redis-server", "--replicaof", "redis", "6379"]
    restart: unless-stopped

Escalar réplicas:

docker compose up --scale redis-replica=2 -d

☸️ Despliegue en Kubernetes

Operador oficial: Redis Operator gestiona pods, réplicas, backups y Sentinel automáticamente.
Ejemplo básico (StatefulSet + Service):

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis
spec:
  serviceName: redis
  replicas: 3
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
        - name: redis
          image: redis:7-alpine
          ports:
            - containerPort: 6379
          volumeMounts:
            - name: data
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi

🔒 Seguridad en Producción

Red:
- No exponer Redis directamente a internet (bind 127.0.0.1).
- Usar VPN o VPC privada.
- Filtrar tráfico con firewalls o iptables.
Autenticación y Roles:
- Activar requirepass y definir usuarios ACL (redis-cli ACL SETUSER).
- Rotar contraseñas periódicamente.
- Desactivar comandos peligrosos (FLUSHALL, CONFIG, SHUTDOWN) para usuarios limitados.
TLS:
- Activar cifrado con certificados:

tls-port 6380
tls-cert-file /etc/ssl/redis.crt
tls-key-file /etc/ssl/redis.key
tls-ca-cert-file /etc/ssl/ca.crt

Protección ante ataques comunes:
- Limitar conexiones con maxclients.
- Bloquear IPs sospechosas.
- Usar namespaces o prefijos de clave para evitar colisiones (app:user:123).

💾 Backups y Recuperación

Snapshots automáticos (RDB):
- Guardar cada cierto tiempo o en eventos específicos.
- Copiar el archivo dump.rdb periódicamente a almacenamiento externo (S3, GCS).
AOF:
- Permite restaurar el estado exacto antes de un fallo.
- Combinar con aof-rewrite-percentage y aof-rewrite-min-size para mantenimiento.
Backup híbrido:
- Activar ambos: save 900 1 y appendonly yes.
- Esto asegura recuperación rápida y mínima pérdida.
Recuperación manual:

cp dump.rdb /var/lib/redis/
chown redis:redis dump.rdb
systemctl restart redis

📊 Monitorización y Alertas

Comandos útiles:
- INFO memory → uso de RAM.
- CLIENT LIST → conexiones activas.
- MONITOR → actividad en tiempo real.
- SLOWLOG get → detectar operaciones lentas.
- LATENCY DOCTOR → diagnóstico de retrasos.
Prometheus Exporter:
- oliver006/redis_exporter
- Expone métricas en /metrics para Grafana.
- Métricas clave:
  - redis_memory_used_bytes
  - redis_connected_clients
  - redis_commands_processed_total
  - redis_keyspace_hits_ratio
Alertas recomendadas:
- Uso de memoria > 80%.
- Latencia > 100ms.
- Fallos de conexión.
- Tasa de misses en cache > 20%.

🔁 Escalado y Alta Disponibilidad

Escalado Vertical: Aumentar CPU/RAM en la instancia principal.
Escalado Horizontal:
- Redis Cluster o particionado manual de keys (hashing).
- Uso de réplicas solo lectura para distribución de carga.
- Uso de Proxy (p.ej. Twemproxy o Envoy) para balancear peticiones.
Sentinel: Mecanismo de failover automático. Detecta caída del master y promueve una réplica.

⚡ Estrategias de Rendimiento

Pipeline: agrupar comandos reduce RTT.
Sharding: distribuir claves grandes entre nodos.
Evitar claves enormes: usar TTL y expiraciones.
Redis Streams: mejor opción que listas para colas con persistencia.
Prefijos estructurados: facilitan limpieza y búsquedas (app:users:*).
Evitar hot keys: particionar o usar hash tags ({} en Cluster).

🧠 Buenas Prácticas de Operación

Mantener Redis actualizado a la última versión estable.
Automatizar despliegues (Ansible, Terraform, Helm).
Evitar usar Redis como base de datos primaria persistente.
Probar restauraciones de backup regularmente.
Supervisar el tamaño del AOF y reescribirlo periódicamente.
Documentar configuración, claves críticas y TTLs.
Limpiar datos huérfanos o expirados con scripts programados.

📚 Recursos Recomendados

Redis - Casos de Uso Reales y Patrones de Diseño

Redis
Redis - Avanzado y Arquitectura
Redis en Entornos de Producción
microservicios
Node.js
Python
Scalability Patterns
System Design

💡 Introducción

Redis no solo funciona como caché o base de datos en memoria:
es un componente estratégico en arquitecturas modernas, microservicios y sistemas distribuidos.
Sus estructuras de datos permiten implementar patrones comunes de comunicación, sincronización y almacenamiento temporal de forma eficiente.

⚡ Patrón: Cache Distribuida

Objetivo: reducir carga en bases de datos persistentes y mejorar latencia.
Claves: TTL, invalidación, consistencia eventual.

Ejemplo Node.js

import { createClient } from 'redis';
const redis = createClient();

await redis.connect();

const cacheKey = "user:42";
let user = await redis.get(cacheKey);

if (!user) {
  user = await db.query("SELECT * FROM users WHERE id=42");
  await redis.set(cacheKey, JSON.stringify(user), { EX: 60 }); // TTL 60s
}

console.log(JSON.parse(user));

Ejemplo Python

import redis
r = redis.Redis()

cache_key = "product:1001"
data = r.get(cache_key)
if not data:
    data = db.get_product(1001)
    r.setex(cache_key, 120, json.dumps(data))
print(json.loads(data))

Buenas prácticas

Definir TTLs cortos (30–300s) para coherencia.
Usar cache-aside pattern (solo cachea si no existe).
Invalidar manualmente tras escritura en DB.

📨 Patrón: Pub/Sub (Mensajería entre Microservicios)

Objetivo: comunicación reactiva entre componentes sin acoplamiento directo.
Ventaja: simple, baja latencia y sin intermediarios complejos como Kafka.

Ejemplo Node.js

import { createClient } from 'redis';

const publisher = createClient();
const subscriber = createClient();

await publisher.connect();
await subscriber.connect();

await subscriber.subscribe('notifications', (msg) => {
  console.log('Mensaje recibido:', msg);
});

await publisher.publish('notifications', JSON.stringify({ event: 'user_signed_up' }));

Ejemplo Python

import redis
import threading

r = redis.Redis()

def listener():
    pubsub = r.pubsub()
    pubsub.subscribe("logs")
    for message in pubsub.listen():
        print("Recibido:", message["data"])

threading.Thread(target=listener).start()
r.publish("logs", "Evento de sistema iniciado")

Usos comunes

Microservicios desacoplados (notificaciones, colas simples).
Broadcasting de eventos (websockets, dashboards).
Logging distribuido y alertas.

⏱️ Patrón: Rate Limiting

Objetivo: limitar peticiones por usuario o IP para prevenir abuso.
Redis se usa por sus operaciones atómicas (INCR, EXPIRE).

Ejemplo Node.js

const limitKey = `rate:${userId}`;
const count = await redis.incr(limitKey);

if (count === 1) await redis.expire(limitKey, 60); // Ventana de 60s
if (count > 10) throw new Error("Demasiadas peticiones");

console.log(`Intento ${count}/10`);

Ejemplo Python

import redis, time

r = redis.Redis()
key = f"rate:{user_id}"
count = r.incr(key)
if count == 1:
    r.expire(key, 60)
if count > 5:
    raise Exception("Rate limit excedido")

Extensión: Token Bucket

Implementación más avanzada basada en contadores y timestamps para suavizar ráfagas.

🧵 Patrón: Job Queue (Colas de Trabajo Asíncronas)

Objetivo: procesar tareas en background sin bloquear el flujo principal.
Redis permite implementarlas con listas (LPUSH/BRPOP) o Streams (XADD, XREADGROUP).

Ejemplo básico con Node.js

// productor
await redis.lPush("jobs", JSON.stringify({ type: "email", to: "user@example.com" }));

// consumidor
while (true) {
  const job = await redis.brPop("jobs", 0);
  const data = JSON.parse(job.element);
  console.log("Procesando tarea:", data);
}

Ejemplo avanzado con Streams

await redis.xAdd("job_stream", "*", { type: "resize", file: "image.jpg" });
const messages = await redis.xReadGroup("workers", "w1", [{ key: "job_stream", id: ">" }]);

Python + RQ (Redis Queue)

from redis import Redis
from rq import Queue
from tasks import send_email

r = Redis()
q = Queue(connection=r)
q.enqueue(send_email, "user@example.com")

🔑 Patrón: Gestión de Sesiones

Objetivo: almacenar sesiones de usuario compartidas entre servidores.
Redis es ideal por su baja latencia y soporte TTL.

Node.js con express-session

import session from 'express-session';
import connectRedis from 'connect-redis';
import { createClient } from 'redis';

const RedisStore = connectRedis(session);
const redisClient = createClient();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'secreto',
  resave: false,
  saveUninitialized: false,
  cookie: { secure: false, maxAge: 60000 }
}));

Python Flask-Session

from flask import Flask, session
from flask_session import Session
app = Flask(__name__)
app.config["SESSION_TYPE"] = "redis"
Session(app)

Ventajas

Persistencia entre reinicios del servidor.
Compatible con balanceo de carga.
Control automático de expiraciones.

📊 Patrón: Leaderboards y Rankings

Uso: juegos, métricas, puntuaciones, estadísticas.
Estructura: Sorted Sets (ZADD, ZRANGE).

Ejemplo Node.js

await redis.zAdd("scores", [{ score: 100, value: "player1" }]);
await redis.zAdd("scores", [{ score: 250, value: "player2" }]);

const top = await redis.zRevRange("scores", 0, 2, { WITHSCORES: true });
console.log(top);

Ejemplo Python

r.zadd("ranking", {"alice": 50, "bob": 70, "carol": 60})
top = r.zrevrange("ranking", 0, 2, withscores=True)
print(top)

Patrón extendido

Usar ZINCRBY para actualizaciones dinámicas.
TTL para tablas temporales.
Redis Streams para almacenar eventos históricos paralelos.

📅 Patrón: Colas de Retraso (Delayed Jobs)

Objetivo: ejecutar tareas diferidas (recordatorios, reintentos, expiraciones).
Redis no tiene scheduler interno, pero puede simularse con Sorted Sets.

Ejemplo Node.js

const now = Date.now();
await redis.zAdd("delayed", [{ score: now + 5000, value: "send_email" }]);

setInterval(async () => {
  const jobs = await redis.zRangeByScore("delayed", 0, Date.now());
  for (const job of jobs) {
    console.log("Ejecutando:", job);
    await redis.zRem("delayed", job);
  }
}, 1000);

🧠 Patrón: Distributed Lock (Bloqueos distribuidos)

Objetivo: evitar condiciones de carrera en sistemas distribuidos.
Implementado con el algoritmo Redlock.

Ejemplo con Redlock.js

import { createClient } from 'redis';
import Redlock from 'redlock';

const client = createClient();
await client.connect();

const redlock = new Redlock([client]);
const lock = await redlock.acquire(['locks:resource'], 2000);
console.log("Bloqueo adquirido");

await lock.release();

Conceptos

Los bloqueos se almacenan como claves con TTL.
Si el cliente muere, el bloqueo expira automáticamente.
Usado en sistemas con escritura concurrente o tareas únicas (cron jobs).

🧩 Integración en Arquitecturas de Microservicios

Patrones comunes:
- Command Bus → Pub/Sub entre servicios.
- Event Store → Streams como fuente de eventos.
- Job Queue centralizada → orquestación de tareas.
- Cache distribuida global → rendimiento compartido.
Ejemplo de pipeline real:
1. Microservicio API → guarda evento en XADD event_stream.
2. Servicio de Workers → XREADGROUP procesa tareas pendientes.
3. Redis almacena resultados temporales (SETEX) y estados (HSET).
4. Dashboard consulta resultados en tiempo real mediante Pub/Sub.

🧰 Herramientas y Librerías

Node.js: ioredis, bullmq, redis, redlock.
Python: redis-py, rq, aioredis, huey.
Dashboard: RedisInsight.
Testing: RedisMock, local Redis containers (redis:alpine).

Redis

Valkey

📘 Documentación y Alternativas

What is BullMQ BullMQ-

⚙️ Conceptos Fundamentales

🧩 Persistencia y Recuperación de Datos

🔒 Transacciones y Modo Multi

⚡️ Conjuntos, Rankings y Operaciones Avanzadas

🔄 Integración con Node.js

Ejemplo: conexión y set/get

🧰 Recursos y Cheatsheets

🎥 Videos y Aprendizaje Visual

💡 Casos de Uso Recomendados

🔧 Consejos de Configuración

Redis - Avanzado y Arquitectura

🧱 Arquitectura Interna

⚙️ Modo Cluster y Replicación

🧭 Sentinel - Alta Disponibilidad

🔐 Seguridad

🚀 Performance y Optimización

📈 Observabilidad y Monitorización

🌐 Redis Modules

🧰 Integración con Entornos Modernos

🧠 Casos de Uso Avanzados

🔍 Recursos Adicionales

Redis en Entornos de Producción

🏗️ Arquitectura de Producción

⚙️ Configuración Recomendada

🧩 Despliegue con Docker Compose

☸️ Despliegue en Kubernetes

🔒 Seguridad en Producción

💾 Backups y Recuperación

📊 Monitorización y Alertas

🔁 Escalado y Alta Disponibilidad

⚡ Estrategias de Rendimiento

🧠 Buenas Prácticas de Operación

📚 Recursos Recomendados

Redis - Casos de Uso Reales y Patrones de Diseño

💡 Introducción

⚡ Patrón: Cache Distribuida

Ejemplo Node.js

Ejemplo Python

Buenas prácticas

📨 Patrón: Pub/Sub (Mensajería entre Microservicios)

Ejemplo Node.js

Ejemplo Python

Usos comunes

⏱️ Patrón: Rate Limiting

Ejemplo Node.js

Ejemplo Python

Extensión: Token Bucket

🧵 Patrón: Job Queue (Colas de Trabajo Asíncronas)

Ejemplo básico con Node.js

Ejemplo avanzado con Streams

Python + RQ (Redis Queue)

🔑 Patrón: Gestión de Sesiones

Node.js con express-session

Python Flask-Session

Ventajas

📊 Patrón: Leaderboards y Rankings

Ejemplo Node.js

Ejemplo Python

Patrón extendido

📅 Patrón: Colas de Retraso (Delayed Jobs)

Ejemplo Node.js

🧠 Patrón: Distributed Lock (Bloqueos distribuidos)

Ejemplo con Redlock.js

Conceptos

🧩 Integración en Arquitecturas de Microservicios

🧰 Herramientas y Librerías

📚 Recursos