持久化

redis-cli> SAVE
OK

redis-cli> BGSAVE
Background saving started

redis-cli> INFO persistence
# Persistence
loading:0                     # 是否正在加载
rdb_bgsave_in_progress:0      # 是否正在 BGSAVE
rdb_last_bgsave_status:ok     # 上次 BGSAVE 结果
rdb_last_bgsave_time_sec:3    # 上次 BGSAVE 耗时（秒）
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:0

save 900 1     # 900 秒（15 分钟）内至少 1 个 key 被修改
save 300 10    # 300 秒（5 分钟）内至少 10 个 key 被修改
save 60 10000  # 60 秒内至少 10000 个 key 被修改

save ""   # 禁用自动 RDB 保存

# /etc/redis/redis.conf 或 redis.conf

# ── RDB 触发条件 ──
save 900 1                              # 15 分钟内至少 1 次修改
save 300 10                             # 5 分钟内至少 10 次修改
save 60 10000                           # 60 秒内至少 10000 次修改
save ""                                 # 设为空字符串禁用自动 RDB

# ── 文件名与路径 ──
dbfilename dump.rdb                     # RDB 文件名
dir ./                                  # RDB 文件存储目录（同时影响 AOF）

# ── 压缩与校验 ──
rdbcompression yes                      # 是否使用 LZF 算法压缩字符串
                                        #   yes: 节省磁盘 ~60%，但增加 CPU 开销
                                        #   no:  文件更大，但 CPU 开销更低

rdbchecksum yes                         # 是否在 RDB 文件末尾写入 CRC64 校验和
                                        #   用于检测文件是否损坏，写入和读取时均有开销

# ── 错误处理 ──
stop-writes-on-bgsave-error yes         # BGSAVE 失败时是否拒绝写入
                                        #   yes: 阻止写入，防止进程悄悄丢失持久化
                                        #   no:  继续接受写入（风险：数据无法持久化）

# ── AOF 总开关 ──
appendonly yes                          # 开启 AOF 持久化
                                        #   关闭时 (no): 只使用 RDB

# ── 文件名与目录 ──
appendfilename "appendonly.aof"         # AOF 文件名 (7.0+ 为 base file 名称)
appenddirname "appendonlydir"           # 7.0+ Multi-Part AOF 文件目录

# ── fsync 策略 ──
appendfsync everysec                    # 每秒 fsync 一次 (默认推荐)
                                        #   always: 每次写都 fsync
                                        #   no:     不主动 fsync

# ── Rewrite 相关 ──
no-appendfsync-on-rewrite yes           # Rewrite 期间不执行 fsync
                                        #   yes: 由 OS 缓冲处理
                                        #   no:  正常 fsync(可能阻塞)

auto-aof-rewrite-percentage 100         # 当前 AOF 文件相对上次 Rewrite 后增长的百分比
auto-aof-rewrite-min-size 64mb          # AOF 文件最小体积才触发 Rewrite

# ── 加载与恢复 ──
aof-load-truncated yes                  # 遇到尾部截断的 AOF 文件如何处理
                                        #   yes: 加载并警告
                                        #   no:  拒绝启动，需 redis-check-aof 修复

# ── 混合持久化 ──
aof-use-rdb-preamble yes                # 是否在 AOF Rewrite 时使用 RDB 格式做前置内容
                                        #   yes: 混合持久化（推荐 4.0+）
                                        #   no:  纯 AOF 格式

redis-cli> BGREWRITEAOF
Background append only file rewriting started

auto-aof-rewrite-percentage 100   # 当前 AOF 文件大小 / 上次 Rewrite 后大小 > 100%
                                   # 即当前大小是上次的 2 倍以上

auto-aof-rewrite-min-size 64mb    # AOF 文件必须大于 64MB 才触发

// 伪代码
long long growth = current_aof_size - last_rewrite_size;
long long percentage = (growth * 100) / last_rewrite_size;

if (current_aof_size >= auto_aof_rewrite_min_size &&
    percentage >= auto_aof_rewrite_percentage) {
    // 触发 BGREWRITEAOF
}

redis-check-aof appendonly.aof

redis-check-aof --fix appendonly.aof

aof-use-rdb-preamble yes    # 开启混合持久化 (Redis 4.0+ 默认 yes)

# crontab 示例：每小时执行 BGSAVE 并保留最近 24 份
0 * * * * redis-cli -h 127.0.0.1 -p 6379 BGSAVE
5 * * * * cp /var/lib/redis/dump.rdb /backup/redis/dump_$(date +\%Y\%m\%d\%H).rdb

# 保留最近 24 份，删除 24 小时前的
0 0 * * * find /backup/redis/ -name "dump_*.rdb" -mtime +1 -delete

# 每日备份到远程（scp / rsync / 对象存储）
0 6 * * * rsync -avz /var/lib/redis/dump.rdb backup-server:/backup/redis/

appendfsync everysec    # 首选，性能损失 < 5%，最多丢 1 秒

# 查看最近 fork 耗时
redis-cli> INFO stats | grep latest_fork_usec
latest_fork_usec:15234     # 15ms 内正常，> 1s 需关注

# 在生产环境的测试/备份节点上定期执行恢复演练
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof

# 在隔离环境中启动 Redis 验证数据完整性
redis-server --port 6380 --dbfilename test_restore.rdb &
redis-cli -p 6380 DBSIZE   # 验证数据量是否符合预期
redis-cli -p 6380 SHUTDOWN NOSAVE

#!/bin/bash
# redis-rdb-backup.sh: RDB 文件定时备份脚本

REDIS_CLI="redis-cli -h 127.0.0.1 -p 6379"
REDIS_DATA_DIR="/var/lib/redis"
BACKUP_DIR="/backup/redis/rdb"
RETENTION_DAYS=7
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# 确保备份目录存在
mkdir -p "${BACKUP_DIR}"

# 方案1: 触发 BGSAVE 后备份
echo "$(date): Triggering BGSAVE..."
${REDIS_CLI} BGSAVE

# 等待 BGSAVE 完成
while [ "$(${REDIS_CLI} INFO persistence | grep rdb_bgsave_in_progress | cut -d: -f2)" != "0" ]; do
    sleep 1
done

echo "$(date): BGSAVE completed. Copying file..."
cp "${REDIS_DATA_DIR}/dump.rdb" "${BACKUP_DIR}/dump_${TIMESTAMP}.rdb"

# 方案2: 直接复制当前 RDB（不触发新 BGSAVE，适合频繁备份）
# cp "${REDIS_DATA_DIR}/dump.rdb" "${BACKUP_DIR}/dump_${TIMESTAMP}.rdb"

# 压缩
gzip "${BACKUP_DIR}/dump_${TIMESTAMP}.rdb"

# 校验
redis-check-rdb "${BACKUP_DIR}/dump_${TIMESTAMP}.rdb.gz" 2>&1 | grep -q "Checksum OK"
if [ $? -eq 0 ]; then
    echo "$(date): Backup verified successfully: dump_${TIMESTAMP}.rdb.gz"
else
    echo "$(date): Backup verification FAILED!" >&2
    rm -f "${BACKUP_DIR}/dump_${TIMESTAMP}.rdb.gz"
    exit 1
fi

# 清理过期备份
find "${BACKUP_DIR}" -name "dump_*.rdb.gz" -mtime +${RETENTION_DAYS} -delete
echo "$(date): Cleaned up backups older than ${RETENTION_DAYS} days."
echo "$(date): Backup completed successfully."

#!/bin/bash
# redis-aof-backup.sh

BACKUP_DIR="/backup/redis/aof"
AOF_DIR="/var/lib/redis/appendonlydir"      # Redis 7.0+ 目录结构
AOF_FILE="/var/lib/redis/appendonly.aof"    # Redis < 7.0 单文件
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

mkdir -p "${BACKUP_DIR}"

# Redis 7.0+: 备份 Multi-Part AOF 目录
if [ -d "${AOF_DIR}" ]; then
    # 先触发 BGREWRITEAOF，让 AOF 文件进入"干净"状态
    redis-cli BGREWRITEAOF

    # 等待 Rewrite 完成
    while redis-cli INFO persistence | grep -q "aof_rewrite_in_progress:1"; do
        sleep 1
    done

    # 复制整个目录
    cp -r "${AOF_DIR}" "${BACKUP_DIR}/aof_${TIMESTAMP}"
    tar -czf "${BACKUP_DIR}/aof_${TIMESTAMP}.tar.gz" -C "${BACKUP_DIR}" "aof_${TIMESTAMP}"
    rm -rf "${BACKUP_DIR}/aof_${TIMESTAMP}"
else
    # 传统单文件模式
    redis-cli BGREWRITEAOF
    while redis-cli INFO persistence | grep -q "aof_rewrite_in_progress:1"; do
        sleep 1
    done
    cp "${AOF_FILE}" "${BACKUP_DIR}/appendonly_${TIMESTAMP}.aof"
    gzip "${BACKUP_DIR}/appendonly_${TIMESTAMP}.aof"
fi

echo "AOF backup completed: ${TIMESTAMP}"

#!/bin/bash
# redis-restore-drill.sh: 恢复演练脚本

RESTORE_DIR="/tmp/redis_restore_test"
RESTORE_PORT=16379
BACKUP_FILE="/backup/redis/rdb/dump_latest.rdb.gz"

# 1. 准备恢复目录
mkdir -p "${RESTORE_DIR}"
gunzip -c "${BACKUP_FILE}" > "${RESTORE_DIR}/dump.rdb"

# 2. 验证 RDB 文件完整性
redis-check-rdb "${RESTORE_DIR}/dump.rdb"
if [ $? -ne 0 ]; then
    echo "RDB file corrupted! Aborting."
    exit 1
fi

# 3. 启动测试 Redis 实例
echo "Starting test Redis instance on port ${RESTORE_PORT}..."
redis-server --port ${RESTORE_PORT} \
             --dir "${RESTORE_DIR}" \
             --dbfilename dump.rdb \
             --appendonly no \
             --daemonize yes \
             --logfile "${RESTORE_DIR}/redis-restore.log"

sleep 3

# 4. 验证数据
KEY_COUNT=$(redis-cli -p ${RESTORE_PORT} DBSIZE)
echo "Restored database size: ${KEY_COUNT} keys"

# 抽样验证关键数据
redis-cli -p ${RESTORE_PORT} EXISTS user:10001
redis-cli -p ${RESTORE_PORT} GET config:app_version

# 5. 清理
redis-cli -p ${RESTORE_PORT} SHUTDOWN NOSAVE
rm -rf "${RESTORE_DIR}"

echo "Restore drill completed successfully."

# 1. 停止 Redis
redis-cli SHUTDOWN SAVE

# 2. 将备份的 RDB 文件放置到 dir 配置的目录
cp /backup/redis/rdb/dump_20260711_030000.rdb /var/lib/redis/dump.rdb

# 3. 确保权限正确
chown redis:redis /var/lib/redis/dump.rdb
chmod 644 /var/lib/redis/dump.rdb

# 4. 启动 Redis
redis-server /etc/redis/redis.conf

# 1. 先验证 AOF 文件完整性
redis-check-aof /backup/redis/aof/appendonly.aof

# 2. 停止 Redis
redis-cli SHUTDOWN NOSAVE

# 3. 放置 AOF 文件
# Redis 7.0+ Multi-Part AOF:
cp -r /backup/redis/aof/appendonlydir /var/lib/redis/appendonlydir

# Redis < 7.0 单文件 AOF:
cp /backup/redis/aof/appendonly.aof /var/lib/redis/appendonly.aof

# 4. 确保 AOF 开启
# redis.conf:
#   appendonly yes
#   appendfilename "appendonly.aof"

# 5. 启动 Redis
redis-server /etc/redis/redis.conf

# ❌ 错误配置
save 1 1          # 每秒有修改就触发，灾难性

# ✅ 合理配置
save 900 1        # 15 分钟一次修改就保存
save 300 10       # 5 分钟 10 次修改
save 60 10000     # 1 分钟 10000 次

no-appendfsync-on-rewrite yes    # Rewrite 期间不主动 fsync

# ❌ 错误：min-size 过高
auto-aof-rewrite-min-size 10gb    # 10GB 才触发，可能永远达不到

# ✅ 建议
auto-aof-rewrite-min-size 64mb
auto-aof-rewrite-percentage 100

appendonly yes
aof-use-rdb-preamble yes
appendfsync everysec

# Redis 3.2 尝试加载混合持久化文件
# 错误: "Bad file format reading the append only file"

# ✅ 正确关闭方式
redis-cli SHUTDOWN SAVE     # 先做 BGSAVE 再关闭
redis-cli SHUTDOWN NOSAVE   # 不做 BGSAVE 直接关闭（如果开启了 AOF）

# ✅ 优雅停止
kill -SIGTERM <pid>         # 等同 SHUTDOWN NOSAVE