Redis: configurar persistência com AOF e RDB

# redis.conf — configuração de RDB:

# Ativar snapshots (salvar se N mudanças em X segundos):
save 3600 1      # salvar após 1 mudança em 1 hora
save 300 100     # salvar após 100 mudanças em 5 minutos
save 60 10000    # salvar após 10.000 mudanças em 1 minuto

# Desativar RDB completamente (se usando apenas AOF):
# save ""

# Arquivo de snapshot:
dbfilename dump.rdb
dir /var/lib/redis      # onde salvar o arquivo

# Compressão do RDB (economiza disco):
rdbcompression yes
rdbchecksum yes         # verificação de integridade no carregamento

# Comportamento em caso de falha no snapshot:
stop-writes-on-bgsave-error yes  # parar de aceitar writes se snapshot falhar
                                  # (garante que você saiba do problema)

# Verificar quando foi o último snapshot:
redis-cli LASTSAVE          # timestamp Unix do último RDB
redis-cli DEBUG SLEEP 0     # forçar snapshot manualmente: BGSAVE
redis-cli BGSAVE

# redis.conf — configuração de AOF:

# Ativar AOF:
appendonly yes
appendfilename "appendonly.aof"

# Política de fsync (equilíbrio durabilidade/performance):
# always:   fsync após cada operação — mais seguro, mais lento (~5k ops/s)
# everysec: fsync a cada segundo — boa performance, perda máxima de 1s de dados (RECOMENDADO)
# no:       nunca faz fsync — SO decide quando escrever (risco de perda maior)
appendfsync everysec

# Reescrita automática do AOF (compactar o arquivo):
no-appendfsync-on-rewrite no   # não pausar fsync durante reescrita
auto-aof-rewrite-percentage 100  # reescrever quando AOF dobra de tamanho
auto-aof-rewrite-min-size 64mb  # tamanho mínimo para acionar reescrita

# Truncamento de AOF corrompido na inicialização:
aof-use-rdb-preamble yes  # usar RDB como base + AOF incremental (mais rápido para reload)

# Verificar integridade do AOF:
redis-check-aof --fix /var/lib/redis/appendonly.aof

# Forçar reescrita do AOF manualmente:
redis-cli BGREWRITEAOF

# redis.conf — configuração de produção (RDB + AOF):

# RDB para snapshots rápidos (base para recovery):
save 3600 1
save 300 100
dbfilename dump.rdb
dir /var/lib/redis
rdbcompression yes

# AOF para durabilidade:
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes   # formato híbrido: RDB base + AOF delta

# Memória máxima e política de evição:
maxmemory 1gb              # limitar uso de memória
maxmemory-policy allkeys-lru  # remover chaves menos usadas quando cheio
                              # noeviction: não remover (útil para dados persistentes)

# Para dados que NÃO devem ser evictados (ex: sessões críticas):
# maxmemory-policy noeviction

# Verificar uso atual:
redis-cli INFO memory | grep -E "used_memory_human|maxmemory_human|mem_fragmentation_ratio"
redis-cli INFO persistence | grep -E "rdb_|aof_"

# Saída esperada:
# used_memory_human: 256.00M
# maxmemory_human: 1024.00M
# aof_enabled: 1
# rdb_last_bgsave_status: ok
# aof_last_write_status: ok

# docker-compose.yml — Redis com persistência:
services:
  redis:
    image: redis:7-alpine
    restart: always
    command: >
      redis-server
      --appendonly yes
      --appendfsync everysec
      --save 3600 1
      --save 300 100
      --maxmemory 512mb
      --maxmemory-policy allkeys-lru
      --requirepass ${REDIS_PASSWORD}
    ports:
      - "127.0.0.1:6379:6379"
    volumes:
      - redis_data:/data  # o diretório /data é onde o Redis salva os arquivos
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3

volumes:
  redis_data:  # volume persistente — sobrevive ao docker compose down

# IMPORTANTE: sem o volume, reiniciar o container apaga todos os dados
# Mesmo com appendonly yes — os arquivos ficam no container, não no host

# Verificar que os arquivos estão no volume:
docker compose exec redis ls /data
# appendonly.aof  dump.rdb

#!/bin/bash
# Backup do Redis — copiar RDB e AOF para S3:

REDIS_DIR="/var/lib/redis"  # ou volume Docker: /var/lib/docker/volumes/redis_data/_data
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# Forçar snapshot antes do backup:
redis-cli -a "$REDIS_PASSWORD" BGSAVE
sleep 2  # aguardar conclusão

# Copiar arquivos para S3:
aws s3 cp "$REDIS_DIR/dump.rdb" "s3://meus-backups/redis/dump_$TIMESTAMP.rdb"
aws s3 cp "$REDIS_DIR/appendonly.aof" "s3://meus-backups/redis/aof_$TIMESTAMP.aof" 2>/dev/null || true

echo "Backup Redis concluído: $TIMESTAMP"

# Restaurar Redis de um backup:
# 1. Parar o Redis:
sudo systemctl stop redis
# 2. Copiar o arquivo de backup:
aws s3 cp "s3://meus-backups/redis/dump_TIMESTAMP.rdb" "$REDIS_DIR/dump.rdb"
aws s3 cp "s3://meus-backups/redis/aof_TIMESTAMP.aof" "$REDIS_DIR/appendonly.aof"
sudo chown redis:redis "$REDIS_DIR"/*.rdb "$REDIS_DIR"/*.aof
# 3. Iniciar o Redis:
sudo systemctl start redis
# 4. Verificar que os dados foram restaurados:
redis-cli -a "$REDIS_PASSWORD" DBSIZE  # número de chaves