Tutoriais de VPS
Redis 8 na VPS: ACL, persistência e recuperação testada
Implante Redis 8 com contas ACL separadas, acesso privado e AOF/RDB. Confira permissões, exporte backups externos e teste recuperação sem tocar produção.

Responder PONG não comprova que uma aplicação não possa apagar tudo, perder filas por falta de memória ou falhar ao carregar dados depois de reiniciar. Confira esses comportamentos antes de conectar produção.
Este guia implanta uma instância Redis 8 com Compose, usuários ACL separados, SSH, AOF/RDB e restauração independente. Atende sites pequenos, APIs e ferramentas internas. Não configura Sentinel, Cluster, alta disponibilidade ou perda zero. Recursos são referências, não medições de concorrência.
| Uso | Quando a memória enche | Decisão |
|---|---|---|
| Cache reconstruível de outro banco | Considerar allkeys-lru ou allkeys-lfu | Instância própria e tratamento de misses |
| Filas ou sessões importantes | Normalmente noeviction, com falha explícita de escrita | Persistência, alertas e retentativas |
| Ambos juntos | Uma política dificilmente atende aos dois | Separar instâncias e memória |
O exemplo usa noeviction: evita remoção por memória cheia, não TTL, exclusões ou toda perda por falha. Trate erros de escrita e adote política de cache somente se todos os dados afetados puderem ser descartados. Veja eviction.
Avalie 2 vCPU, 2 GB RAM e 30 GB SSD para carga leve; com aplicação compartilhada, prefira 4 GB ou mais. O exemplo dá 256 MB a maxmemory e limite de contêiner de 1 GB, deixando margem para processo, salvamento e host.
maxmemory não limita RAM total. RDB e reescrita AOF geram copy-on-write, especialmente com muitas escritas. Meça picos, disco, backups e distância da aplicação. Consulte operação.
Comandos para Ubuntu 24.04, Bash root autorizado e Docker rootful convencional com Compose. Veja instalação Docker.
Os exemplos originais fixam redis:8.6.6. Em 16 de novembro de 2026, a lista oficial oferece 8.6.8 na série 8.6. Troque todas as referências 8.6.6 por tag/digest suportado e verificado 8.6.8, inclusive consultas UID/GID, e revise o entrypoint. Não confunda com migrar cegamente de série nem abra dados antigos sem testar compatibilidade.
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}}'
Confira 6379 livre e registre digest/UID/GID reais. Não use chmod 777 para resolver permissões.
admin administra, app usa comandos limitados sobre app:, e health só executa PING. Inicialize uma 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 contém SHA-256 de senhas aleatórias fortes. Os originais ficam em secrets protegido; só se monta a senha do healthcheck. Proteja hashes como material de autenticação. Veja ACL.
O papel da aplicação atende strings simples. BullMQ, Celery ou WordPress podem exigir Lua, listas, hashes, pub/sub e outros comandos. Conceda requisitos documentados individualmente, sem usar administrador. Números de banco não isolam tenants com segurança.
Crie /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 escuta no contêiner; publicação Docker define exposição do host. Combine usuário padrão desativado, ACL e porta privada, sem depender só de protected-mode.
Crie /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 configuração somente leitura depois de ajustar proprietário dos dados. O servidor ainda reduz privilégios; não ativa SKIP_DROP_PRIVS. Veja entrypoint original e confira o da versão escolhida. Permita leitura da configuração ao 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
Não abra 6379 nas regras cloud. Use Engine suportado desde 28.0.0, considerando exceção antiga de camada 2 em publicação de portas. Só aplicações confiáveis devem compartilhar rede.
Teste sem credenciais:
docker compose exec -T redis redis-cli PING
Espere NOAUTH, não PONG. Com aplicação, crie marcador sem 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 verifica autorização sem executar 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 fora do escopo e comando proibido. Na rede Compose, conecte a redis:6379 como app, com segredo suportado pela aplicação. 127.0.0.1 dentro dela aponta para ela mesma.
Para Redis Insight ou CLI remoto, crie túnel no computador:
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
Confira impressão digital e conecte a 127.0.0.1:16379. Redis não configura TLS aqui; SSH criptografa o trecho remoto. Não marque TLS Redis para essa porta local sem TLS. Conexões permanentes entre hosts precisam de rede controlada e TLS Redis correto.
A interface administrativa pode exigir permissões que app não possui. Não entregue credenciais administrativas ao navegador ou usuários da aplicação. Para NOAUTH, WRONGPASS ou recusa, veja conexões.
RDB é snapshot; AOF reproduz escritas. appendfsync everysec pode perder cerca de um segundo em falhas comuns, sem ser limite universal. Redis 7+ usa AOF multipartes e manifest; copiar apenas appendonly.aof não basta.
Preserve RDB em /data e todo appendonlydir. Com ambos ativos, Redis prefere AOF ao iniciar: substituir dump.rdb não comprova recuperação. Veja persistência.
Exporte RDB com redis-cli --rdb, valide e só então renomeie .partial. O protocolo de replicação pode disparar salvamento em segundo plano; evite picos. Salve 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"
Consulte CLI e backups para --rdb. Exporta toda a instância, não um banco lógico. Proteja credenciais e arquivo; examine .partial com falha, sem enviá-los como completos.
Depois do teste manual:
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 executa às 03:30 no fuso do servidor. Monitore último backup válido e faça rotação dos logs. Envie RDB, hashes, configuração, ACL e digest criptografados para fora da VPS; guarde senhas separadamente. RDB não inclui configuração/ACL externos. Backup diário pode perder quase um dia após perda do host.
Em outra sessão Bash sob /opt/redis8, escolha backup real. Crie diretório independente, sem portas:
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
Use nome redis8-restore livre. Aguarde carregamento correto:
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
O marcador deve ser redis8-backup-check. Confira keys, tipos e valores em cada banco; chaves expiradas podem desaparecer com o tempo. Filas exigem verificar duplicados e idempotência, não só quantidade.
O teste não tem autenticação e fica em --network none; não o publique. docker stop redis8-restore libera memória mantendo diretório.
Para recuperar serviço real, restaure ACL/rede e pare escritas. Carregue RDB com AOF desativado, valide, execute CONFIG SET appendonly yes, aguarde reescrita correta e salve appendonly yes na configuração. Não suponha que RDB prevaleça sobre AOF vazio ou antigo. Complete testes da aplicação antes de mudar tráfego.
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
Observe used_memory_rss, evicted_keys, rdb_last_bgsave_status, aof_last_write_status e aof_last_bgrewrite_status; veja INFO. Healthy só confirma autenticação e PING, não persistência nem escrita útil.
Com MISCONF, confira disco/permissões/salvamentos; não esconda erros desativando stop-writes-on-bgsave-error. Falhas de fork exigem memória disponível e vm.overcommit_memory do host; avalie outros serviços antes de mudar kernel.
Antes de atualizar, preserve digest, teste backups/restauração e versão nova. Para voltar, use imagem antiga e backup anterior em outra instância: formatos novos podem ser incompatíveis. Veja Compose produtivo.
Não transfira variáveis de outra imagem para a oficial redis. Aqui se usa aclfile e se testa recusa de PING sem credenciais. Uma variável não comprova proteção.
ACL usa hashes. Preserve sessão administrativa/backup, adicione hash novo, execute ACL LOAD e teste conexão nova. Troque clientes, remova hash anterior e carregue novamente. Configuração somente leitura não usa ACL SAVE para escrever. Veja ACL LOAD.
Não equivale a RSS nem limite do contêiner. Buffers, alocador e persistência acrescentam custo. Meça picos, keys grandes e conexões antes de ampliar.
Não: exclusões chegam ao AOF e perder o host elimina arquivos locais. Snapshots históricos, cópias independentes e restauração cumprem funções diferentes.
Depende do modelo e dos objetivos de recuperação. AOF sozinho não comprova adequação; uma instância não garante disponibilidade nem perda zero. Valide autenticação, permissões e recuperação; depois meça maxmemory, frequência de backups e separação de instâncias.