Tutoriales de VPS
Redis 8 en un VPS: ACL, persistencia y recuperación probada
Despliega Redis 8 con cuentas ACL separadas, acceso privado y AOF/RDB. Comprueba permisos, exporta copias externas y prueba recuperación sin tocar producción.

Que Redis responda PONG no demuestra que una aplicación no pueda borrar todo, perder una cola por falta de memoria o fallar al recuperar datos tras reiniciar. Comprueba esos comportamientos antes de conectar producción.
La guía despliega una instancia Redis 8 con Compose, usuarios ACL separados, SSH, AOF/RDB y restauración independiente. Sirve para webs pequeñas, API y herramientas internas. No configura Sentinel, Cluster, alta disponibilidad ni pérdida cero. Los recursos son referencias, no mediciones de concurrencia.
| Uso | Al llenarse la memoria | Decisión |
|---|---|---|
| Caché reconstruible desde otra base | Considerar allkeys-lru o allkeys-lfu | Instancia propia y gestión de misses |
| Colas o sesiones importantes | Normalmente noeviction, con fallo explícito de escritura | Persistencia, alertas y reintentos |
| Ambos mezclados | Una política difícilmente sirve a los dos | Separar instancias y memoria |
El ejemplo usa noeviction: evita expulsión por memoria llena, no TTL, borrados o toda pérdida por fallo. Gestiona errores de escritura y cambia a política de caché solo si todos los datos afectados son descartables. Consulta eviction.
Evalúa 2 vCPU, 2 GB RAM y 30 GB SSD para carga ligera; con aplicación compartida conviene 4 GB o más. El ejemplo da 256 MB a maxmemory y límite de contenedor de 1 GB, dejando margen para proceso, guardado y host.
maxmemory no limita RAM total. RDB y reescritura AOF generan copy-on-write, especialmente con muchas escrituras. Mide picos, disco, copias y distancia de aplicación. Consulta operación.
Comandos para Ubuntu 24.04, Bash root autorizado y Docker rootful convencional con Compose. Consulta instalación Docker.
Los ejemplos originales fijan redis:8.6.6. El 16 de noviembre de 2026, la lista oficial ofrece 8.6.8 en la serie 8.6. Cambia todas las referencias 8.6.6 por tag/digest soportado y verificado 8.6.8, incluidas consultas UID/GID, y revisa su entrypoint. No lo confundas con migrar ciegamente de serie ni abras datos antiguos sin probar compatibilidad.
docker version
docker compose version
ss -lntp 'sport = :6379'
install -d -m 700 /opt/redis8
cd /opt/redis8
install -d -m 700 secrets backups
install -d -m 755 config
install -d -m 750 data
docker pull redis:8.6.6
redis_uid=$(docker run --rm --entrypoint id redis:8.6.6 -u redis)
redis_gid=$(docker run --rm --entrypoint id redis:8.6.6 -g redis)
chown "$redis_uid:$redis_gid" data
docker image inspect redis:8.6.6 --format '{{json .RepoDigests}}'
Comprueba 6379 libre y registra digest/UID/GID reales. No uses chmod 777 para arreglar permisos.
admin administra, app usa comandos limitados sobre app:, y health solo ejecuta PING. Inicializa una vez:
cd /opt/redis8
umask 077
for account in admin app health; do
openssl rand -hex 32 > "secrets/${account}_password"
done
admin_hash=$(printf '%s' "$(cat secrets/admin_password)" | sha256sum | cut -d ' ' -f 1)
app_hash=$(printf '%s' "$(cat secrets/app_password)" | sha256sum | cut -d ' ' -f 1)
health_hash=$(printf '%s' "$(cat secrets/health_password)" | sha256sum | cut -d ' ' -f 1)
{
printf 'user default off\n'
printf 'user admin on #%s ~* &* +@all\n' "$admin_hash"
printf 'user app on #%s ~app:* -@all +ping +hello +select +get +set +del +unlink +exists +expire +pexpire +ttl +pttl +client|setname +client|setinfo\n' "$app_hash"
printf 'user health on #%s -@all +ping\n' "$health_hash"
} > config/users.acl
chmod 644 config/users.acl
chmod 600 secrets/admin_password secrets/app_password
chmod 444 secrets/health_password
unset admin_hash app_hash health_hash
ACL contiene SHA-256 de contraseñas aleatorias fuertes. Los originales quedan en secrets protegido; solo se monta la contraseña de healthcheck. Protege también hashes como material de autenticación. Consulta ACL.
El rol de aplicación sirve para strings sencillos. BullMQ, Celery o WordPress pueden necesitar Lua, listas, hashes, pub/sub y otros comandos. Concede requisitos documentados uno a uno, sin usar administrador. Los números de base no aíslan tenants con seguridad.
Crea /opt/redis8/config/redis.conf:
bind 0.0.0.0
port 6379
protected-mode yes
daemonize no
logfile ""
aclfile /usr/local/etc/redis/users.acl
dir /data
dbfilename dump.rdb
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
appendonly yes
appenddirname appendonlydir
appendfsync everysec
maxmemory 256mb
maxmemory-policy noeviction
bind 0.0.0.0 define escucha dentro del contenedor; publicación Docker define exposición del host. Combina usuario predeterminado desactivado, ACL y puerto privado, sin depender solo de protected-mode.
Crea /opt/redis8/compose.yaml:
name: redis8
services:
redis:
image: redis:8.6.6
restart: unless-stopped
stop_grace_period: 1m
environment:
SKIP_FIX_PERMS: "1"
command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
ports:
- "127.0.0.1:6379:6379"
volumes:
- ./config:/usr/local/etc/redis:ro
- ./data:/data
secrets:
- redis_health_password
mem_limit: 1g
healthcheck:
test:
- CMD-SHELL
- 'REDISCLI_AUTH=$$(cat /run/secrets/redis_health_password) redis-cli --user health -e PING | grep -qx PONG'
interval: 15s
timeout: 5s
retries: 5
start_period: 30s
logging:
driver: json-file
options:
max-size: "10m"
max-file: "3"
secrets:
redis_health_password:
file: ./secrets/health_password
SKIP_FIX_PERMS evita modificar configuración de lectura tras ajustar propietario de datos. El servidor aún reduce privilegios; no activa SKIP_DROP_PRIVS. Consulta entrypoint original y revisa el de la versión elegida. Permite lectura de configuración a Redis:
cd /opt/redis8
chmod 644 config/redis.conf
docker compose config --quiet
docker compose up -d
docker compose ps
docker compose logs --tail=100 redis
No abras 6379 en cloud. Usa Engine soportado desde 28.0.0, considerando excepción antigua de capa 2 en publicación de puertos. Solo aplicaciones confiables deben compartir red.
Prueba sin credenciales:
docker compose exec -T redis redis-cli PING
Espera NOAUTH, no PONG. Con aplicación, crea marcador sin TTL:
export REDISCLI_AUTH="$(cat secrets/app_password)"
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user app -e SET app:restore-probe redis8-backup-check
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user app -e GET app:restore-probe
unset REDISCLI_AUTH
ACL DRYRUN comprueba autorización sin ejecutar comandos:
export REDISCLI_AUTH="$(cat secrets/admin_password)"
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user admin ACL DRYRUN app SET app:test value
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user admin ACL DRYRUN app SET other:test value
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user admin ACL DRYRUN app FLUSHALL
unset REDISCLI_AUTH
Resultados: permitido, key fuera del ámbito y comando prohibido. En la red Compose conecta a redis:6379 como app, con secreto admitido por la aplicación. 127.0.0.1 dentro de ella apunta a sí misma.
Para Redis Insight o CLI remoto, crea el túnel en tu ordenador:
ssh -N -T -o ExitOnForwardFailure=yes \
-o ServerAliveInterval=30 -o ServerAliveCountMax=3 \
-L 127.0.0.1:16379:127.0.0.1:6379 deploy@VPS_IP
Verifica huella y conecta a 127.0.0.1:16379. Redis no configura TLS aquí; SSH cifra el trayecto remoto. No marques TLS Redis contra este puerto local sin TLS. Conexiones permanentes entre hosts necesitan red controlada y TLS Redis correcto.
La interfaz de administración puede necesitar permisos que app no tiene. No entregues credenciales administrativas al navegador o usuarios de aplicación. Para NOAUTH, WRONGPASS o rechazo, consulta conexiones.
RDB es snapshot; AOF reproduce escrituras. appendfsync everysec puede perder alrededor de un segundo en fallos comunes, sin ser límite universal. Redis 7+ usa AOF multipartes y manifest; copiar solo appendonly.aof no basta.
Conserva RDB en /data y todo appendonlydir. Con ambos activos, Redis prefiere AOF al iniciar: sustituir dump.rdb no demuestra restauración. Consulta persistencia.
Exporta RDB con redis-cli --rdb, valida y solo después renombra .partial. El protocolo de replicación puede disparar guardado en segundo plano; evita horas pico. Guarda como /opt/redis8/backup.sh:
#!/usr/bin/env bash
set -euo pipefail
umask 077
cd /opt/redis8
backup_name="redis-$(date -u +%Y%m%dT%H%M%SZ).rdb"
test ! -e "backups/$backup_name"
test ! -e "backups/${backup_name}.partial"
redis_image=$(docker compose images -q redis)
test -n "$redis_image"
export REDISCLI_AUTH="$(cat secrets/admin_password)"
trap 'unset REDISCLI_AUTH' EXIT
docker compose exec -T -e REDISCLI_AUTH redis \
redis-cli --user admin --rdb "/tmp/${backup_name}.partial"
docker compose cp "redis:/tmp/${backup_name}.partial" \
"backups/${backup_name}.partial"
chmod 600 "backups/${backup_name}.partial"
docker run --rm --network none \
-v "$PWD/backups:/backup:ro" --entrypoint redis-check-rdb \
"$redis_image" "/backup/${backup_name}.partial"
mv "backups/${backup_name}.partial" "backups/$backup_name"
sha256sum "backups/$backup_name" > "backups/${backup_name}.sha256"
docker compose exec -T redis rm "/tmp/${backup_name}.partial"
printf 'Backup ready: %s\n' "backups/$backup_name"
Consulta CLI y backups para --rdb. Exporta toda la instancia, no una base lógica. Protege credenciales y archivo; revisa .partial fallidos, sin subirlos como completos.
Tras probar manualmente:
chmod 700 /opt/redis8/backup.sh
/opt/redis8/backup.sh
30 3 * * * /bin/bash /opt/redis8/backup.sh >> /opt/redis8/backups/backup.log 2>&1
Cron ejecuta a las 03:30 del servidor. Vigila última copia válida y rota logs. Envía RDB, hashes, configuración, ACL y digest cifrados fuera del VPS; guarda contraseñas aparte. RDB no incluye configuración/ACL externos. Copia diaria puede perder casi un día tras perder el host.
En otra sesión Bash bajo /opt/redis8, selecciona copia real. Crea directorio independiente, sin puertos:
cd /opt/redis8
backup_file='backups/redis-YYYYMMDDTHHMMSSZ.rdb'
sha256sum -c "${backup_file}.sha256"
redis_image=$(docker compose images -q redis)
test -n "$redis_image"
redis_uid=$(docker run --rm --entrypoint id "$redis_image" -u redis)
redis_gid=$(docker run --rm --entrypoint id "$redis_image" -g redis)
restore_dir=$(mktemp -d /opt/redis8/restore.XXXXXX)
install -m 640 "$backup_file" "$restore_dir/dump.rdb"
chown "$redis_uid:$redis_gid" "$restore_dir" "$restore_dir/dump.rdb"
chmod 750 "$restore_dir"
docker run -d --name redis8-restore --network none --memory 1g \
-e SKIP_FIX_PERMS=1 -v "$restore_dir:/data" \
"$redis_image" redis-server --bind 127.0.0.1 \
--dir /data --dbfilename dump.rdb --appendonly no --save ""
docker logs --tail=50 redis8-restore
Usa nombre redis8-restore libre. Espera carga correcta:
docker exec redis8-restore redis-cli -e PING
docker exec redis8-restore redis-cli -e DBSIZE
docker exec redis8-restore redis-cli -e GET app:restore-probe
docker exec redis8-restore redis-cli INFO keyspace
El marcador debe ser redis8-backup-check. Comprueba keys, tipos y valores en cada base; claves expiradas pueden desaparecer con el tiempo. Colas requieren comprobar duplicados e idempotencia, no solo cantidad.
La prueba no tiene autenticación y queda en --network none; no la publiques. docker stop redis8-restore libera memoria conservando directorio.
Para recuperar servicio real, restaura ACL/red y detén escrituras. Carga RDB con AOF desactivado, valida, ejecuta CONFIG SET appendonly yes, espera reescritura correcta y guarda appendonly yes en configuración. No supongas que un RDB prevalece sobre AOF vacío o antiguo. Completa pruebas de aplicación antes de cambiar tráfico.
cd /opt/redis8
export REDISCLI_AUTH="$(cat secrets/admin_password)"
docker compose exec -T -e REDISCLI_AUTH redis redis-cli --user admin INFO memory
docker compose exec -T -e REDISCLI_AUTH redis redis-cli --user admin INFO persistence
docker compose exec -T -e REDISCLI_AUTH redis redis-cli --user admin INFO stats
docker compose exec -T -e REDISCLI_AUTH redis redis-cli --user admin ACL LOG 10
unset REDISCLI_AUTH
docker stats --no-stream
df -h
Vigila used_memory_rss, evicted_keys, rdb_last_bgsave_status, aof_last_write_status y aof_last_bgrewrite_status; consulta INFO. Healthy solo confirma autenticación y PING, no persistencia ni escritura útil.
Con MISCONF, revisa disco/permisos/guardados; no ocultes errores desactivando stop-writes-on-bgsave-error. Fallos de fork requieren memoria disponible y vm.overcommit_memory del host; evalúa otros servicios antes de cambiar kernel.
Antes de actualizar, conserva digest, prueba copias/restauración y versión nueva. Para volver, usa imagen anterior y backup previo en otra instancia: formatos nuevos quizá sean incompatibles. Consulta Compose productivo.
No transfieras variables de otra imagen a la oficial redis. Aquí se usa aclfile y se verifica rechazo de PING sin credenciales. Una variable no prueba protección.
ACL usa hashes. Conserva sesión administrativa/copia, añade nuevo hash, ejecuta ACL LOAD y prueba conexión nueva. Cambia clientes, retira hash anterior y carga otra vez. Configuración montada de lectura no usa ACL SAVE para escribir. Consulta ACL LOAD.
No equivale a RSS ni límite de contenedor. Buffers, asignador y persistencia añaden coste. Mide picos, keys grandes y conexiones antes de ampliar.
No: borrados llegan al AOF y perder el host elimina archivos locales. Snapshots históricos, copias independientes y restauración cumplen funciones distintas.
Depende del modelo y objetivos de recuperación. AOF solo no lo demuestra; una instancia no garantiza disponibilidad ni pérdida cero. Verifica autenticación, permisos y recuperación; después mide maxmemory, frecuencia de copias y separación de instancias.