--- title: "Cómo instalar y configurar Redis en Ubuntu 24.04" description: "Instala Redis en Ubuntu 24.04, protégelo con contraseña y usuarios ACL, limita su memoria, elige la persistencia adecuada y automatiza copias del archivo RDB." category: "Gestión de Bases de Datos" language: es source: https://cubepath.com/es/docs/gestión-de-bases-de-datos/instalacion-y-configuracion-de-redis updated: 2026-09-25 --- # 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: ```bash sudo apt update sudo apt install redis-server ``` El servicio arranca solo y queda habilitado en el arranque. Compruébalo: ```bash sudo systemctl status redis-server ``` ```output ● 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: ```bash redis-cli ping ``` ```output 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: ```bash sudo grep -i overcommit /var/log/redis/redis-server.log ``` ```output 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: ```bash echo 'vm.overcommit_memory = 1' | sudo tee /etc/sysctl.d/60-redis.conf sudo sysctl --system ``` Verifica el valor y reinicia Redis: ```bash sysctl vm.overcommit_memory sudo systemctl restart redis-server ``` ```output 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: ```bash openssl rand -base64 32 ``` Abre la configuración: ```bash sudo nano /etc/redis/redis.conf ``` Busca la línea `# requirepass foobared`, descoméntala y pon tu contraseña: ```ini 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: ```bash 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: ```bash redis-cli ping ``` ```output (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: ```bash redis-cli ``` ```text 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: ```ini user miapp on >otra_contraseña_larga ~miapp:* &* +@all -@dangerous ``` Cada parte significa: | Regla | Efecto | |-------|--------| | `on` | El usuario está activo | | `>otra_contraseña_larga` | Contraseña del usuario | | `~miapp:*` | Solo puede acceder a claves que empiecen por `miapp:` | | `&*` | Puede usar cualquier canal Pub/Sub | | `+@all -@dangerous` | Todos los comandos salvo la categoría peligrosa | Reinicia y prueba el usuario: ```bash sudo systemctl restart redis-server redis-cli --user miapp --askpass ``` ```text 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: ```text redis://miapp:otra_contraseña_larga@127.0.0.1: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: ```ini maxmemory 2gb maxmemory-policy allkeys-lru ``` Elige la política según el uso: | Uso | Política recomendada | |-----|----------------------| | Caché pura (todo puede regenerarse) | `allkeys-lru` | | Caché mezclada con datos sin caducidad | `volatile-lru` (solo expulsa claves con TTL) | | Datos que no se pueden perder (colas, sesiones) | `noeviction` (las escrituras fallan al llenarse) | Reinicia y verifica los valores: ```bash sudo systemctl restart redis-server REDISCLI_AUTH='tu_contraseña_larga' redis-cli CONFIG GET maxmemory* ``` ```output 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`: ```ini 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: ```bash sudo systemctl restart redis-server REDISCLI_AUTH='tu_contraseña_larga' redis-cli INFO persistence | grep -E 'aof_enabled|rdb_last_bgsave_status' ``` ```output 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`: ```ini bind 127.0.0.1 -::1 your_private_ip ``` Reinicia y abre el puerto solo para la IP del servidor de aplicación: ```bash sudo systemctl restart redis-server sudo ufw allow from app_server_ip to any port 6379 proto tcp sudo ss -tlnp | grep 6379 ``` ```output 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: ```bash 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: ```bash sudo nano /usr/local/bin/redis-backup ``` ```bash #!/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: ```bash 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 ``` ```output 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.