Cómo instalar y configurar Redis en Ubuntu 24.04

Redis es un almacén de datos en memoria que se usa como caché, gestor de sesiones, cola de trabajos o contador en tiempo real, con tiempos de respuesta por debajo del milisegundo. En este tutorial instalarás Redis desde los repositorios de Ubuntu 24.04, lo protegerás con contraseña y un usuario ACL para tu aplicación, limitarás la memoria que puede usar, configurarás la persistencia en disco y programarás copias de seguridad.

Requisitos previos

Para seguir esta guía necesitas:

• Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
• Un usuario no root con privilegios sudo.
• RAM suficiente para tus datos más un margen: Redis guarda todo el conjunto de datos en memoria y, al guardar en disco, puede necesitar memoria adicional temporal.
• UFW activo con el acceso SSH permitido.

Paso 1: Instalar Redis

Ubuntu 24.04 incluye Redis 7.0 en sus repositorios, una versión estable y con parches de seguridad de Ubuntu. Instálalo:

sudo apt update
sudo apt install redis-server

El servicio arranca solo y queda habilitado en el arranque. Compruébalo:

sudo systemctl status redis-server

● redis-server.service - Advanced key-value store
     Loaded: loaded (/usr/lib/systemd/system/redis-server.service; enabled; preset: enabled)
     Active: active (running) since ...

Prueba la conexión con el cliente de línea de comandos:

redis-cli ping

PONG

Toda la configuración está en /etc/redis/redis.conf y el log en /var/log/redis/redis-server.log.

Nota

si necesitas funciones de Redis 8, Redis publica un repositorio APT oficial en packages.redis.io. Los pasos de configuración de esta guía son los mismos, pero revisa las notas de versión antes de actualizar un servidor en producción.

Paso 2: Ajustar el kernel para Redis

Redis crea una copia del proceso (fork) para escribir los snapshots en disco. Con la configuración por defecto de Linux, ese fork puede fallar si hay poca memoria libre, y Redis lo avisa en el log. Comprueba si aparece el aviso:

sudo grep -i overcommit /var/log/redis/redis-server.log

WARNING Memory overcommit must be enabled! Without it, a background save or replication may fail under low memory condition.

Activa vm.overcommit_memory de forma persistente:

echo 'vm.overcommit_memory = 1' | sudo tee /etc/sysctl.d/60-redis.conf
sudo sysctl --system

Verifica el valor y reinicia Redis:

sysctl vm.overcommit_memory
sudo systemctl restart redis-server

vm.overcommit_memory = 1

Paso 3: Establecer una contraseña

Por defecto, Redis acepta comandos de cualquier cliente local sin autenticación. Genera una contraseña larga y aleatoria:

openssl rand -base64 32

Abre la configuración:

sudo nano /etc/redis/redis.conf

Busca la línea # requirepass foobared, descoméntala y pon tu contraseña:

requirepass tu_contraseña_larga

requirepass asigna esa contraseña al usuario default, que es el que usan los clientes cuando no indican usuario. Como el archivo va a contener secretos, comprueba que solo lo pueden leer redis y root:

sudo chmod 640 /etc/redis/redis.conf
sudo chown redis:redis /etc/redis/redis.conf
sudo systemctl restart redis-server

Comprueba que ahora se exige autenticación:

redis-cli ping

(error) NOAUTH Authentication required.

Para usar redis-cli sin escribir la contraseña en la línea de comandos (quedaría en el historial y en ps), pásala con la variable REDISCLI_AUTH o autentícate dentro del cliente:

redis-cli

127.0.0.1:6379> AUTH tu_contraseña_larga
OK
127.0.0.1:6379> PING
PONG

Paso 4: Crear un usuario ACL para la aplicación

Con las ACL puedes dar a cada aplicación su propio usuario, limitado a ciertos prefijos de claves y sin acceso a comandos peligrosos como FLUSHALL, CONFIG o KEYS. En /etc/redis/redis.conf, añade al final:

user miapp on >otra_contraseña_larga ~miapp:* &* +@all -@dangerous

Cada parte significa:

Reinicia y prueba el usuario:

sudo systemctl restart redis-server
redis-cli --user miapp --askpass

Please input password: ********************
127.0.0.1:6379> SET miapp:saludo hola
OK
127.0.0.1:6379> SET otra:clave x
(error) NOPERM No permissions to access a key
127.0.0.1:6379> FLUSHALL
(error) NOPERM User miapp has no permissions to run the 'flushall' command

Configura tu aplicación con el usuario miapp y su contraseña. La mayoría de clientes aceptan una URL de este estilo:

redis://miapp:otra_contraseñ[email protected]:6379/0

Paso 5: Limitar la memoria y elegir la política de expulsión

Sin límite, Redis crece hasta que el sistema se queda sin memoria y el kernel lo mata. Fija maxmemory dejando margen para el sistema operativo y para el fork de los snapshots. Como referencia, en un servidor de 4 GB dedicado a Redis, 2 GB es un valor prudente.

En /etc/redis/redis.conf, busca y ajusta:

maxmemory 2gb
maxmemory-policy allkeys-lru

Elige la política según el uso:

Reinicia y verifica los valores:

sudo systemctl restart redis-server
REDISCLI_AUTH='tu_contraseña_larga' redis-cli CONFIG GET maxmemory*

1) "maxmemory"
2) "2147483648"
3) "maxmemory-policy"
4) "allkeys-lru"
...

Paso 6: Configurar la persistencia

Redis ofrece dos mecanismos para no perder los datos al reiniciar:

• RDB: snapshots periódicos del conjunto de datos en /var/lib/redis/dump.rdb. Está activo por defecto. Compacto y rápido de restaurar, pero puedes perder los últimos minutos de escrituras.
• AOF: registra cada escritura en un log. Con appendfsync everysec pierdes como máximo un segundo de datos, a cambio de más escritura en disco.

Si Redis es solo una caché, basta con RDB (o incluso desactivar la persistencia con save ""). Si guardas colas o sesiones, activa también AOF. En /etc/redis/redis.conf:

save 3600 1 300 100 60 10000
appendonly yes
appendfsync everysec

La línea save significa: guardar si en 3600 segundos cambió al menos 1 clave, en 300 segundos al menos 100, o en 60 segundos al menos 10000.

Reinicia y comprueba el estado de la persistencia:

sudo systemctl restart redis-server
REDISCLI_AUTH='tu_contraseña_larga' redis-cli INFO persistence | grep -E 'aof_enabled|rdb_last_bgsave_status'

rdb_last_bgsave_status:ok
aof_enabled:1

Paso 7: Acceso remoto (solo si lo necesitas)

Por defecto Redis solo escucha en 127.0.0.1 y ::1, y tiene activo protected-mode. Si tu aplicación está en el mismo servidor, deja esto como está.

Si la aplicación corre en otro servidor, lo ideal es usar una red privada entre ambos. Añade la IP privada del servidor de Redis a la directiva bind de /etc/redis/redis.conf:

bind 127.0.0.1 -::1 your_private_ip

Reinicia y abre el puerto solo para la IP del servidor de aplicación:

sudo systemctl restart redis-server
sudo ufw allow from app_server_ip to any port 6379 proto tcp
sudo ss -tlnp | grep 6379

LISTEN 0  511  your_private_ip:6379  0.0.0.0:*  users:(("redis-server",pid=5120,fd=8))
LISTEN 0  511       127.0.0.1:6379  0.0.0.0:*  users:(("redis-server",pid=5120,fd=6))

Advertencia

Redis transmite los datos y las contraseñas en texto plano. Nunca lo expongas en una IP pública sin filtrar por firewall, y si el tráfico sale de una red privada, configura TLS o un túnel.

Paso 8: Copias de seguridad del archivo RDB

La forma más sencilla de copiar Redis es pedirle un snapshot con redis-cli --rdb, que descarga un RDB consistente sin detener el servidor. Crea un archivo con la contraseña legible solo por root:

sudo install -m 0700 -d /var/backups/redis
echo 'tu_contraseña_larga' | sudo tee /etc/redis-backup.pass > /dev/null
sudo chmod 600 /etc/redis-backup.pass

Crea el script:

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

#!/usr/bin/env bash
set -euo pipefail

BACKUP_DIR="/var/backups/redis"
RETENTION_DAYS=7
STAMP="$(date +%F_%H%M)"

REDISCLI_AUTH="$(cat /etc/redis-backup.pass)" redis-cli --rdb "${BACKUP_DIR}/dump_${STAMP}.rdb"
gzip "${BACKUP_DIR}/dump_${STAMP}.rdb"

find "${BACKUP_DIR}" -name 'dump_*.rdb.gz' -mtime +"${RETENTION_DAYS}" -delete

Hazlo ejecutable, pruébalo y prográmalo cada día a las 03:30:

sudo chmod 750 /usr/local/bin/redis-backup
sudo /usr/local/bin/redis-backup
sudo ls -lh /var/backups/redis
echo '30 3 * * * root /usr/local/bin/redis-backup' | sudo tee /etc/cron.d/redis-backup

sending REPLCONF capa eof
SYNC sent to master, writing 1234 bytes to '/var/backups/redis/dump_2026-09-25_0330.rdb'
Transfer finished with success.

Para restaurar: detén Redis, descomprime la copia como /var/lib/redis/dump.rdb con propietario redis:redis y vuelve a arrancar. Si tienes AOF activado, Redis carga el AOF en lugar del RDB, así que desactiva appendonly durante la restauración y vuelve a activarlo con CONFIG SET appendonly yes una vez cargados los datos.

Solución de problemas

MISCONF Redis is configured to save RDB snapshots, but it's currently unable to persist to disk. El último guardado falló, normalmente por falta de espacio o de memoria para el fork. Revisa df -h /var/lib/redis, el log en /var/log/redis/redis-server.log y que aplicaste el paso 2.

OOM command not allowed when used memory > 'maxmemory'. Has llegado al límite con la política noeviction. Sube maxmemory, pon TTL a las claves o cambia de política.

Redis no arranca tras editar la configuración. Ejecuta journalctl -u redis-server -n 50; suele indicar la directiva y la línea con el error, por ejemplo una regla ACL mal escrita.

Conclusión

Tienes Redis instalado en Ubuntu 24.04 con autenticación, un usuario ACL limitado para tu aplicación, un tope de memoria con su política de expulsión, persistencia adaptada al uso y copias diarias. Como siguientes pasos, puedes supervisar la latencia con redis-cli --latency y INFO stats, añadir una réplica con replicaof para tener una copia en caliente, o usar Redis Sentinel si necesitas conmutación automática.