Instalación y Configuración de Redis: Guía Completa de Base de Datos en Memoria

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é, intermediario de mensajes y motor de streaming. Desde su introducción en 2009, Redis se ha convertido en una de las bases de datos NoSQL y soluciones de caché más populares, reconocida por su rendimiento excepcional, simplicidad y versatilidad.

A diferencia de las bases de datos tradicionales basadas en disco, Redis almacena datos principalmente en memoria, permitiendo tiempos de respuesta submilisegundo y soportando millones de solicitudes por segundo. Esto lo hace ideal para casos de uso que requieren acceso a datos ultrarrápido, incluyendo caché, gestión de sesiones, análisis en tiempo real, colas de mensajes y tablas de clasificación.

Redis soporta varias estructuras de datos incluyendo cadenas, hashes, listas, conjuntos, conjuntos ordenados, mapas de bits, hyperloglogs, índices geoespaciales y streams, proporcionando a los desarrolladores herramientas poderosas para resolver problemas complejos de manera eficiente.

Esta guía completa cubre la instalación de Redis, configuración, endurecimiento de seguridad, optimización de rendimiento, opciones de persistencia y mejores prácticas para entornos de producción en varias distribuciones de Linux.

¿Por Qué Elegir Redis?

Redis sobresale en varias áreas clave:

Rendimiento:

Almacenamiento en memoria para latencia de microsegundos
Arquitectura de hilo único eliminando cambios de contexto
Soporta millones de operaciones por segundo
Pipelining para operaciones por lotes
Estructuras de datos optimizadas

Versatilidad:

Múltiples estructuras de datos (cadenas, listas, conjuntos, hashes, conjuntos ordenados)
Mensajería Pub/Sub para comunicación en tiempo real
Scripting Lua para operaciones complejas
Operaciones geoespaciales
Streams para event sourcing

Fiabilidad:

Opciones de persistencia (snapshots RDB, logs AOF)
Replicación para alta disponibilidad
Sentinel para conmutación por error automática
Clustering para escalado horizontal
Transacciones con MULTI/EXEC

Experiencia del Desarrollador:

Comandos simples e intuitivos
Soporte rico de bibliotecas cliente (Python, Node.js, Java, PHP, etc.)
Documentación extensa
Comunidad activa

Organizaciones importantes que usan Redis incluyen Twitter, GitHub, Stack Overflow, Airbnb y Uber.

Requisitos Previos

Antes de instalar Redis, asegúrate de que tu sistema cumple con estos requisitos:

Requisitos del Sistema

Requisitos Mínimos:

Servidor Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, Rocky Linux 8+)
Acceso root o sudo
1GB RAM mínimo
5GB de espacio en disco disponible
Arquitectura de 64 bits recomendada

Recomendado para Producción:

4+ núcleos de CPU
16GB+ RAM (dependiendo del tamaño de datos)
Almacenamiento SSD
Servidor dedicado para Redis
Espacio swap suficiente configurado

Verificación de Requisitos Previos

# Verificar arquitectura del sistema
uname -m

# Verificar memoria disponible
free -h

# Verificar espacio en disco
df -h

# Verificar versión del kernel Linux
uname -r

# Deshabilitar transparent huge pages (recomendado)
cat /sys/kernel/mm/transparent_hugepage/enabled

Instalación

Instalación de Redis en Ubuntu/Debian

Redis está disponible en repositorios predeterminados:

# Actualizar índice de paquetes
sudo apt update

# Instalar servidor Redis
sudo apt install redis-server -y

# Verificar instalación
redis-server --version

# Verificar estado del servicio
sudo systemctl status redis-server

# Habilitar Redis para iniciar en el arranque
sudo systemctl enable redis-server

Instalar última versión estable desde repositorio oficial de Redis:

# Agregar repositorio de Redis
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

# Actualizar e instalar
sudo apt update
sudo apt install redis -y

Instalación de Redis en CentOS/Rocky Linux

Para distribuciones basadas en Red Hat:

# Actualizar paquetes del sistema
sudo dnf update -y

# Instalar repositorio EPEL
sudo dnf install epel-release -y

# Instalar Redis
sudo dnf install redis -y

# Iniciar Redis
sudo systemctl start redis

# Habilitar Redis para iniciar en el arranque
sudo systemctl enable redis

# Verificar instalación
redis-server --version

# Verificar estado del servicio
sudo systemctl status redis

Instalar desde repositorio Remi para última versión:

# Instalar repositorio Remi
sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm -y

# Habilitar módulo Redis 7
sudo dnf module enable redis:remi-7.2 -y

# Instalar Redis
sudo dnf install redis -y

# Iniciar y habilitar servicio
sudo systemctl start redis
sudo systemctl enable redis

Instalación desde el Código Fuente

Para la versión más reciente absoluta o compilación personalizada:

# Instalar dependencias de compilación
# Ubuntu/Debian
sudo apt install build-essential tcl -y

# CentOS/Rocky
sudo dnf groupinstall 'Development Tools' -y
sudo dnf install tcl -y

# Descargar último Redis
cd /tmp
wget https://download.redis.io/redis-stable.tar.gz

# Extraer archivo
tar -xzvf redis-stable.tar.gz
cd redis-stable

# Compilar Redis
make

# Ejecutar pruebas (opcional pero recomendado)
make test

# Instalar Redis
sudo make install

# Crear usuario Redis
sudo useradd -r -s /bin/false redis

# Crear directorios
sudo mkdir -p /etc/redis
sudo mkdir -p /var/lib/redis
sudo mkdir -p /var/log/redis

# Copiar archivo de configuración
sudo cp redis.conf /etc/redis/redis.conf

# Establecer permisos
sudo chown -R redis:redis /var/lib/redis
sudo chown -R redis:redis /var/log/redis
sudo chown redis:redis /etc/redis/redis.conf

Crear archivo de servicio systemd:

sudo nano /etc/systemd/system/redis.service

Agregar contenido:

[Unit]
Description=Redis In-Memory Data Store
After=network.target

[Service]
Type=notify
User=redis
Group=redis
ExecStart=/usr/local/bin/redis-server /etc/redis/redis.conf
ExecStop=/usr/local/bin/redis-cli shutdown
Restart=always
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

Iniciar y habilitar servicio:

sudo systemctl daemon-reload
sudo systemctl start redis
sudo systemctl enable redis
sudo systemctl status redis

Verificación de la Instalación

Confirmar que Redis está funcionando correctamente:

# Verificar versión de Redis
redis-server --version
redis-cli --version

# Verificar estado del servicio
sudo systemctl status redis
# o
sudo systemctl status redis-server

# Verificar puertos en escucha (predeterminado: 6379)
sudo ss -tulpn | grep 6379
sudo netstat -tulpn | grep 6379

# Probar conexión de Redis
redis-cli ping
# Debe devolver: PONG

# Obtener información de Redis
redis-cli info

# Probar operaciones básicas
redis-cli set testkey "Hello Redis"
redis-cli get testkey
redis-cli del testkey

Estructura de Directorios

Comprender las ubicaciones de archivos de Redis:

Configuración:

Ubuntu/Debian: /etc/redis/redis.conf
CentOS/Rocky: /etc/redis.conf o /etc/redis/redis.conf

Datos:

/var/lib/redis/ - Directorio de datos

Logs:

/var/log/redis/redis-server.log - Archivo de log

Binarios:

/usr/bin/redis-server - Servidor Redis
/usr/bin/redis-cli - Cliente de línea de comandos Redis
/usr/bin/redis-sentinel - Redis Sentinel

Configuración Inicial

Comprender redis.conf

El archivo de configuración principal controla todo el comportamiento de Redis:

# Editar archivo de configuración
# Ubuntu/Debian
sudo nano /etc/redis/redis.conf

# CentOS/Rocky
sudo nano /etc/redis.conf

Secciones clave de configuración:

# Configuración de red
bind 127.0.0.1 ::1
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300

# Configuración general
daemonize yes
supervised systemd
pidfile /var/run/redis/redis-server.pid
loglevel notice
logfile /var/log/redis/redis-server.log
databases 16

# Snapshotting (persistencia RDB)
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /var/lib/redis

# Replicación
# replica-read-only yes

# Seguridad
# requirepass your_password

# Gestión de memoria
maxmemory 256mb
maxmemory-policy allkeys-lru

# Append Only File (persistencia AOF)
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

Configuración de Red

Por defecto, Redis solo escucha en localhost. Para producción:

# Escuchar solo en localhost (más seguro)
bind 127.0.0.1 ::1

# Escuchar en interfaz específica
bind 192.168.1.100

# Escuchar en todas las interfaces (usar con precaución)
bind 0.0.0.0

# Cambiar puerto predeterminado (opcional)
port 6379

# Habilitar modo protegido (recomendado)
protected-mode yes

Reiniciar Redis después de cambios:

sudo systemctl restart redis
# o
sudo systemctl restart redis-server

# Verificar configuración
redis-cli config get bind
redis-cli config get port

Configuración de Autenticación

Siempre usar autenticación por contraseña en producción:

Editar redis.conf:

# Establecer contraseña fuerte
requirepass your_very_strong_password_here

# Para Redis 6+, usar ACLs para control más granular
# Crear usuario ACL
# user default on >your_password ~* &* +@all

Reiniciar Redis:

sudo systemctl restart redis

Conectar con autenticación:

# Método 1: Autenticar después de conexión
redis-cli
AUTH your_password

# Método 2: Autenticar durante conexión
redis-cli -a your_password

# Método 3: Usar comando AUTH
redis-cli
127.0.0.1:6379> AUTH your_password
OK
127.0.0.1:6379> ping
PONG

Configuración ACL de Redis 6+

Redis 6 introdujo Listas de Control de Acceso para permisos detallados:

# Conectar a Redis
redis-cli -a your_password

# Crear usuario de solo lectura
ACL SETUSER readonly on >readonly_password ~* +@read -@write -@dangerous

# Crear usuario de lectura-escritura para claves específicas
ACL SETUSER appuser on >app_password ~app:* +@all

# Crear usuario administrador
ACL SETUSER admin on >admin_password ~* &* +@all

# Listar todos los usuarios
ACL LIST

# Mostrar usuario actual
ACL WHOAMI

# Guardar configuración ACL
ACL SAVE

# Ver permisos de usuario
ACL GETUSER username

Configurar ACL en redis.conf:

# Habilitar archivo de configuración ACL
aclfile /etc/redis/users.acl

Crear archivo users.acl:

sudo nano /etc/redis/users.acl

Agregar usuarios:

user default on >default_password ~* &* +@all
user readonly on >readonly_pass ~* +@read -@write -@dangerous
user appuser on >app_pass ~app:* +@all

Habilitar Acceso Remoto

Para permitir conexiones remotas:

# Editar redis.conf
# Comentar o modificar directiva bind
bind 0.0.0.0

# O vincular a IPs específicas
bind 127.0.0.1 192.168.1.100

# Asegurar que el modo protegido esté activado
protected-mode yes

# Requerir contraseña
requirepass your_strong_password

Configurar firewall:

# UFW (Ubuntu/Debian)
sudo ufw allow from 192.168.1.0/24 to any port 6379

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

Endurecimiento de Seguridad

Configuración del Firewall

Restringir acceso a Redis a fuentes confiables:

# Reglas UFW
# Permitir desde IP específica
sudo ufw allow from 192.168.1.50 to any port 6379

# Permitir desde subred
sudo ufw allow from 192.168.1.0/24 to any port 6379

# Verificar reglas
sudo ufw status numbered

# Reglas firewalld
# Permitir desde IP específica
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.50" port protocol="tcp" port="6379" accept'

# Permitir desde subred
sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="6379" accept'

# Recargar firewall
sudo firewall-cmd --reload

Deshabilitar Comandos Peligrosos

Renombrar o deshabilitar comandos peligrosos en redis.conf:

# Renombrar comandos peligrosos
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command KEYS ""
rename-command CONFIG "CONFIG_b89a7f6c3d"
rename-command DEBUG ""
rename-command SHUTDOWN "SHUTDOWN_d73h4g8k2l"

# O renombrar a nombres oscuros
rename-command FLUSHDB "FLUSH_a8f3k2n9p5"
rename-command CONFIG "CONFIG_z9x4c7v2b1"

Cifrado SSL/TLS

Redis 6+ soporta TLS nativo:

Generar certificados:

# Crear directorio
sudo mkdir -p /etc/redis/ssl
cd /etc/redis/ssl

# Generar clave y certificado de CA
sudo openssl genrsa -out ca-key.pem 4096
sudo openssl req -new -x509 -days 3650 -key ca-key.pem -out ca-cert.pem

# Generar clave y certificado de servidor
sudo openssl genrsa -out redis-server-key.pem 4096
sudo openssl req -new -key redis-server-key.pem -out redis-server.csr
sudo openssl x509 -req -days 3650 -in redis-server.csr -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out redis-server-cert.pem

# Generar clave y certificado de cliente
sudo openssl genrsa -out redis-client-key.pem 4096
sudo openssl req -new -key redis-client-key.pem -out redis-client.csr
sudo openssl x509 -req -days 3650 -in redis-client.csr -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out redis-client-cert.pem

# Establecer permisos
sudo chown redis:redis /etc/redis/ssl/*
sudo chmod 600 /etc/redis/ssl/*.pem

Configurar TLS en redis.conf:

# Configuración TLS/SSL
port 0
tls-port 6379
tls-cert-file /etc/redis/ssl/redis-server-cert.pem
tls-key-file /etc/redis/ssl/redis-server-key.pem
tls-ca-cert-file /etc/redis/ssl/ca-cert.pem
tls-auth-clients yes
tls-protocols "TLSv1.2 TLSv1.3"
tls-ciphers DEFAULT:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK
tls-prefer-server-ciphers yes

Reiniciar Redis y conectar con TLS:

sudo systemctl restart redis

# Conectar con TLS
redis-cli --tls \
    --cert /etc/redis/ssl/redis-client-cert.pem \
    --key /etc/redis/ssl/redis-client-key.pem \
    --cacert /etc/redis/ssl/ca-cert.pem \
    -a your_password

Ejecutar Redis como Usuario No Root

Asegurar que Redis se ejecute como usuario dedicado:

# Verificar usuario Redis
ps aux | grep redis

# Verificar configuración del servicio
sudo systemctl cat redis | grep User

# Asegurar propiedad correcta
sudo chown -R redis:redis /var/lib/redis
sudo chown -R redis:redis /var/log/redis
sudo chown redis:redis /etc/redis/redis.conf

Configuración de Seguridad del Kernel

Optimizar parámetros del kernel para Redis:

sudo nano /etc/sysctl.conf

Agregar:

# Configuraciones recomendadas de Redis
vm.overcommit_memory = 1
net.core.somaxconn = 65535

# Deshabilitar transparent huge pages
echo never > /sys/kernel/mm/transparent_hugepage/enabled

Aplicar cambios:

sudo sysctl -p

# Hacer cambio de THP permanente
sudo nano /etc/rc.local

Agregar:

#!/bin/bash
echo never > /sys/kernel/mm/transparent_hugepage/enabled
exit 0

Hacer ejecutable:

sudo chmod +x /etc/rc.local

Optimización de Rendimiento

Configuración de Memoria

Configurar límites de memoria y políticas:

# Establecer memoria máxima (recomendado)
maxmemory 2gb

# Política de expulsión cuando se alcanza maxmemory
# allkeys-lru: Expulsar cualquier clave usando LRU
# volatile-lru: Expulsar claves con expire establecido usando LRU
# allkeys-lfu: Expulsar cualquier clave usando LFU (Redis 4.0+)
# volatile-lfu: Expulsar claves con expire establecido usando LFU
# volatile-ttl: Expulsar claves con expire establecido, TTL más corto primero
# noeviction: Devolver errores cuando se alcanza el límite de memoria
maxmemory-policy allkeys-lru

# Tamaño de muestra para algoritmos LRU/LFU
maxmemory-samples 5

Selección de política de memoria:

allkeys-lru: Caso de uso general de caché
volatile-lru: Caché mixta y persistencia
allkeys-lfu: Expulsión basada en frecuencia (Redis 4.0+)
volatile-ttl: Datos sensibles al tiempo
noeviction: Cuando la pérdida de datos es inaceptable

Monitorear uso de memoria:

# Obtener estadísticas de memoria
redis-cli info memory

# Verificar memoria usada
redis-cli info memory | grep used_memory_human

# Verificar fragmentación de memoria
redis-cli info memory | grep mem_fragmentation_ratio

# Obtener uso de memoria de clave específica
redis-cli --bigkeys

# Uso de memoria por patrón de clave
redis-cli --memkeys --memkeys-samples 1000

Configuración de Persistencia

Redis ofrece dos opciones de persistencia:

RDB (Redis Database Backup):

# Guardar si al menos 1 clave cambió en 900 segundos
save 900 1

# Guardar si al menos 10 claves cambiaron en 300 segundos
save 300 10

# Guardar si al menos 10000 claves cambiaron en 60 segundos
save 60 10000

# Habilitar compresión
rdbcompression yes

# Habilitar checksum
rdbchecksum yes

# Nombre de archivo
dbfilename dump.rdb

# Directorio
dir /var/lib/redis

# Detener escrituras en error de guardado
stop-writes-on-bgsave-error yes

AOF (Append Only File):

# Habilitar AOF
appendonly yes

# Nombre de archivo AOF
appendfilename "appendonly.aof"

# Estrategia de sincronización
# always: Sincronizar después de cada escritura (más lento, más seguro)
# everysec: Sincronizar cada segundo (buen compromiso)
# no: Dejar que el SO decida cuándo sincronizar (más rápido, menos seguro)
appendfsync everysec

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

# Cargar AOF truncado
aof-load-truncated yes

# Habilitar formato híbrido RDB-AOF (Redis 4.0+)
aof-use-rdb-preamble yes

Recomendaciones de persistencia:

Caché de alto rendimiento: Deshabilitar ambos (appendonly no, sin directivas save)
Seguridad de datos crítica: Habilitar AOF con everysec
Enfoque equilibrado: Snapshots RDB + AOF
Durabilidad máxima: AOF con always (impacto en rendimiento)

Operaciones manuales de persistencia:

# Desencadenar snapshot RDB
redis-cli BGSAVE

# Verificar tiempo del último guardado
redis-cli LASTSAVE

# Desencadenar reescritura AOF
redis-cli BGREWRITEAOF

# Obtener información de persistencia
redis-cli info persistence

Optimización de Conexión

# Número máximo de conexiones de cliente
maxclients 10000

# Backlog TCP
tcp-backlog 511

# Cerrar conexiones inactivas después de N segundos (0 = deshabilitar)
timeout 300

# TCP keepalive
tcp-keepalive 300

# Habilitar conexión rápida
tcp-fastopen 3

Configuración de Slow Log

Monitorear consultas lentas:

# Umbral de tiempo de ejecución en microsegundos
slowlog-log-slower-than 10000

# Máximo de entradas en slow log
slowlog-max-len 128

Ver consultas lentas:

# Obtener entradas de slow log
redis-cli SLOWLOG GET 10

# Obtener longitud de slow log
redis-cli SLOWLOG LEN

# Restablecer slow log
redis-cli SLOWLOG RESET

Pipelining y Operaciones por Lotes

Usar pipelining para mejor rendimiento:

# Sin pipelining (múltiples viajes de ida y vuelta)
redis-cli set key1 value1
redis-cli set key2 value2
redis-cli set key3 value3

# Con pipelining (viaje de ida y vuelta único)
(echo "set key1 value1"; echo "set key2 value2"; echo "set key3 value3") | redis-cli --pipe

# Usando redis-cli con múltiples comandos
redis-cli <<EOF
set key1 value1
set key2 value2
set key3 value3
EOF

Monitoreo de Rendimiento

Métricas clave para monitorear:

# Información completa del servidor
redis-cli info

# Secciones específicas
redis-cli info server
redis-cli info clients
redis-cli info memory
redis-cli info persistence
redis-cli info stats
redis-cli info replication
redis-cli info cpu
redis-cli info keyspace

# Estadísticas en tiempo real
redis-cli --stat

# Monitorear todos los comandos en tiempo real
redis-cli monitor

# Verificar clientes conectados
redis-cli client list

# Monitoreo de latencia
redis-cli --latency
redis-cli --latency-history
redis-cli --latency-dist

# Prueba de latencia intrínseca
redis-cli --intrinsic-latency 100

Estrategias de Respaldo

Snapshots RDB

Respaldo manual:

# Desencadenar guardado en segundo plano
redis-cli BGSAVE

# Esperar a que el guardado se complete
redis-cli LASTSAVE

# Copiar archivo RDB
sudo cp /var/lib/redis/dump.rdb /backup/redis_backup_$(date +%Y%m%d).rdb

# Comprimir respaldo
sudo gzip /backup/redis_backup_$(date +%Y%m%d).rdb

Respaldo AOF

# Copiar archivo AOF
sudo cp /var/lib/redis/appendonly.aof /backup/redis_aof_$(date +%Y%m%d).aof

# Comprimir respaldo
sudo gzip /backup/redis_aof_$(date +%Y%m%d).aof

Script de Respaldo Automatizado

sudo nano /usr/local/bin/redis-backup.sh

Agregar contenido:

#!/bin/bash

# Configuración
BACKUP_DIR="/backups/redis"
REDIS_DATA_DIR="/var/lib/redis"
RETENTION_DAYS=7
DATE=$(date +%Y%m%d_%H%M%S)
LOG_FILE="$BACKUP_DIR/backup.log"

# Crear directorio de respaldo
mkdir -p $BACKUP_DIR

# Función para registrar mensajes
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

log_message "Starting Redis backup"

# Desencadenar BGSAVE
redis-cli BGSAVE
sleep 2

# Esperar a que el guardado se complete
while [ "$(redis-cli LASTSAVE)" == "$(redis-cli LASTSAVE)" ]; do
    sleep 1
done

# Copiar archivo RDB
if [ -f "$REDIS_DATA_DIR/dump.rdb" ]; then
    cp $REDIS_DATA_DIR/dump.rdb $BACKUP_DIR/dump_$DATE.rdb
    gzip $BACKUP_DIR/dump_$DATE.rdb
    log_message "RDB backup completed: dump_$DATE.rdb.gz"
fi

# Copiar archivo AOF si existe
if [ -f "$REDIS_DATA_DIR/appendonly.aof" ]; then
    cp $REDIS_DATA_DIR/appendonly.aof $BACKUP_DIR/appendonly_$DATE.aof
    gzip $BACKUP_DIR/appendonly_$DATE.aof
    log_message "AOF backup completed: appendonly_$DATE.aof.gz"
fi

# Eliminar respaldos antiguos
find $BACKUP_DIR -name "dump_*.rdb.gz" -mtime +$RETENTION_DAYS -delete
find $BACKUP_DIR -name "appendonly_*.aof.gz" -mtime +$RETENTION_DAYS -delete
log_message "Removed backups older than $RETENTION_DAYS days"

# Calcular tamaño de respaldo
TOTAL_SIZE=$(du -sh $BACKUP_DIR | cut -f1)
log_message "Total backup directory size: $TOTAL_SIZE"

log_message "Backup process completed"

Hacer ejecutable y programar:

sudo chmod +x /usr/local/bin/redis-backup.sh

# Probar script
sudo /usr/local/bin/redis-backup.sh

# Programar con cron (diariamente a las 2 AM)
sudo crontab -e

# Agregar línea:
0 2 * * * /usr/local/bin/redis-backup.sh

Restauración desde Respaldo

# Detener Redis
sudo systemctl stop redis

# Restaurar archivo RDB
sudo gunzip /backup/dump_20260111.rdb.gz
sudo cp /backup/dump_20260111.rdb /var/lib/redis/dump.rdb

# O restaurar archivo AOF
sudo gunzip /backup/appendonly_20260111.aof.gz
sudo cp /backup/appendonly_20260111.aof /var/lib/redis/appendonly.aof

# Establecer propiedad
sudo chown redis:redis /var/lib/redis/dump.rdb
sudo chown redis:redis /var/lib/redis/appendonly.aof

# Iniciar Redis
sudo systemctl start redis

# Verificar datos
redis-cli keys "*"

Solución de Problemas

Problemas de Conexión

# Verificar si Redis está ejecutándose
sudo systemctl status redis

# Verificar puertos en escucha
sudo ss -tulpn | grep 6379

# Verificar logs
sudo tail -f /var/log/redis/redis-server.log

# Probar conexión
redis-cli ping

# Probar con autenticación
redis-cli -a your_password ping

# Verificar configuración
redis-cli config get bind
redis-cli config get port
redis-cli config get requirepass

Problemas de Memoria

# Verificar uso de memoria
redis-cli info memory

# Verificar política de memoria
redis-cli config get maxmemory-policy

# Encontrar claves grandes
redis-cli --bigkeys

# Verificar fragmentación de memoria
redis-cli info memory | grep fragmentation

# Si la fragmentación es alta, reiniciar Redis
sudo systemctl restart redis

Problemas de Rendimiento

# Verificar consultas lentas
redis-cli SLOWLOG GET 10

# Monitorear comandos
redis-cli monitor

# Verificar latencia
redis-cli --latency

# Verificar clientes conectados
redis-cli client list

# Encontrar comandos costosos
redis-cli --stat

# Verificar tasa de aciertos
redis-cli info stats | grep keyspace

Problemas de Persistencia

# Verificar estado de persistencia
redis-cli info persistence

# Verificar estado del último guardado
redis-cli LASTSAVE

# Desencadenar guardado manualmente
redis-cli BGSAVE

# Verificar estado de AOF
redis-cli config get appendonly

# Reescribir AOF manualmente
redis-cli BGREWRITEAOF

# Verificar logs para errores
sudo tail -f /var/log/redis/redis-server.log

Conclusión

Redis proporciona rendimiento y versatilidad excepcionales como almacén de datos en memoria. Esta guía ha cubierto instalación, configuración, seguridad, optimización y prácticas de mantenimiento esenciales para despliegues en producción.

Puntos Clave

Seguridad: Siempre usar autenticación y restringir acceso de red
Gestión de Memoria: Configurar políticas de expulsión apropiadas
Persistencia: Elegir RDB, AOF, o ambos según requisitos
Monitoreo: Rastrear uso de memoria, consultas lentas y métricas de rendimiento
Respaldos: Implementar estrategias de respaldo automatizadas

Resumen de Mejores Prácticas

Habilitar autenticación con contraseñas fuertes
Usar ACLs de Redis 6+ para control de acceso granular
Configurar maxmemory y políticas de expulsión
Elegir estrategia de persistencia apropiada
Deshabilitar comandos peligrosos en producción
Monitorear uso de memoria y fragmentación
Implementar respaldos automatizados regulares
Usar SSL/TLS para conexiones remotas
Optimizar parámetros del kernel
Mantener Redis actualizado con parches de seguridad

Recursos Adicionales

La simplicidad y el rendimiento de Redis lo hacen una herramienta esencial en arquitecturas de aplicaciones modernas. Domina estos fundamentos para construir sistemas rápidos y confiables.

Instalación y Configuración de Redis: Guía Completa de Base de Datos en Memoria

Instalación y Configuración de Redis: Guía Completa de Base de Datos en Memoria

Introducción

¿Por Qué Elegir Redis?

Requisitos Previos

Requisitos del Sistema

Verificación de Requisitos Previos

Instalación

Instalación de Redis en Ubuntu/Debian

Instalación de Redis en CentOS/Rocky Linux

Instalación desde el Código Fuente

Verificación de la Instalación

Estructura de Directorios

Configuración Inicial

Comprender redis.conf

Configuración de Red

Configuración de Autenticación

Configuración ACL de Redis 6+

Habilitar Acceso Remoto

Endurecimiento de Seguridad

Configuración del Firewall

Deshabilitar Comandos Peligrosos

Cifrado SSL/TLS

Ejecutar Redis como Usuario No Root

Configuración de Seguridad del Kernel

Optimización de Rendimiento

Configuración de Memoria

Configuración de Persistencia

Optimización de Conexión

Configuración de Slow Log

Pipelining y Operaciones por Lotes

Monitoreo de Rendimiento

Estrategias de Respaldo

Snapshots RDB

Respaldo AOF

Script de Respaldo Automatizado

Restauración desde Respaldo

Solución de Problemas

Problemas de Conexión

Problemas de Memoria

Problemas de Rendimiento

Problemas de Persistencia

Conclusión

Puntos Clave

Resumen de Mejores Prácticas

Recursos Adicionales

Latest Video

Get $20 Free Credit