tar -cf - dir | gzip > dir.tar.gz          # 手动组合（tar 的 -z 就是自动做这个）
tar -cf - dir | zstd > dir.tar.zst         # 换个压缩算法，tar 完全不用改
tar -cf - dir | ssh host 'tar -xf -'       # 甚至可以不落盘直接传到另一台机器
tar -cf - dir | gpg -c > dir.tar.gpg       # 或者接加密

# 三种参数风格都能用（这是历史包袱的直接结果）
tar cvzf backup.tar.gz dir          # 老式：操作码不带横杠
tar -cvzf backup.tar.gz dir         # 短选项风格
tar --create --verbose --gzip --file=backup.tar.gz dir    # 长选项风格

# ⚠️ 老式风格里，f 后面必须紧跟文件名
tar czf backup.tar.gz dir           # ✅ f 在最后，紧跟文件名
tar cfz backup.tar.gz dir           # ❌ f 后面跟的是 z，把 "z" 当成了文件名
# 报错：tar: z: Cannot open: No such file or directory

# ── 打包 ──
tar -czvf backup.tar.gz /path/to/dir        # gzip 压缩（最通用）
tar -cJvf backup.tar.xz /path/to/dir        # xz（压缩比最高，慢）
tar --zstd -cvf backup.tar.zst dir          # zstd（推荐：快且压缩比接近 xz）
tar -cavf backup.tar.gz dir                 # -a 根据后缀自动选算法

# ✅ 用 -C 避免打包出多余的目录层级（很重要的习惯）
tar -czf app.tar.gz -C /opt/app .           # 归档内是 ./bin ./conf（干净）
tar -czf app.tar.gz /opt/app                # 归档内是 opt/app/bin（多两层）
tar -czf app.tar.gz -C /opt app             # 归档内是 app/bin（一层，也常用）

# ── 查看（解压前必做！）──
tar -tzvf backup.tar.gz                     # 列出内容与权限
tar -tzvf backup.tar.gz | head -20          # 只看前几个，确认目录结构
tar -tzvf backup.tar.gz | wc -l             # 数文件个数
# ⚠️ 不先看就解压的风险：归档里可能是散落的文件（没有顶层目录），
#    会把当前目录搞得一团糟（这叫 "tarbomb"）

# ── 解压 ──
tar -xzvf backup.tar.gz                     # 解到当前目录
tar -xzvf backup.tar.gz -C /target          # ✅ 解到指定目录（目录必须已存在）
tar -xzvf backup.tar.gz --strip-components=1  # 去掉最外面一层目录
#                       ^^^^^^^^^^^^^^^^^^^ GitHub 下载的 tarball 常用
tar -xzvf backup.tar.gz path/inside/file    # 只解压某一个文件
tar -xzvf backup.tar.gz --wildcards '*.conf'  # 只解压匹配的
tar -xzOf backup.tar.gz path/to/file        # 解压某文件到 stdout（不落盘查看）
tar -xzvf backup.tar.gz -k                  # 不覆盖已存在的文件

# 现代 tar 能自动识别压缩格式，解压时可以省掉 z/j/J
tar -xvf backup.tar.gz                      # ✅ 自动识别
tar -xvf backup.tar.xz
tar -xvf backup.tar.zst

# ── 排除 ──
tar -czf app.tar.gz --exclude='*.log' --exclude='node_modules' --exclude='.git' -C /opt/app .
tar -czf app.tar.gz -X exclude.txt -C /opt/app .
cat exclude.txt
# *.log
# node_modules
# .git
# ⚠️ --exclude 必须写在【要打包的路径之前】，否则可能不生效（GNU tar 的老版本）

# ── 追加与合并（只能对未压缩的 .tar）──
tar -rvf archive.tar newfile.txt            # 追加文件
tar -Avf all.tar part1.tar part2.tar        # 合并归档
# 压缩包要追加只能：解压 -> 追加 -> 重新压缩

# ── 权限与属主 ──
sudo tar -xzvpf backup.tar.gz -C /          # -p 保留权限（恢复系统备份时必须）
sudo tar -xzvf backup.tar.gz --numeric-owner -C /
#                            ^^^^^^^^^^^^^^^ 用 uid/gid 数字，避免跨机器时用户名映射错乱
tar -czf backup.tar.gz --numeric-owner dir  # 打包时也建议加

# ── 进度显示 ──
tar -czf backup.tar.gz --checkpoint=1000 --checkpoint-action=dot dir
tar -czf backup.tar.gz --totals dir         # 结束时报总量与速度
tar -cf - dir | pv -s $(du -sb dir | cut -f1) | gzip > backup.tar.gz
#               ^^ pv 提供进度条（需要安装）

# ── 跨机器传输（不落中间文件）──
tar -czf - /data | ssh user@host 'cat > /backup/data.tar.gz'
tar -cf - /data | ssh user@host 'tar -xf - -C /restore'      # 直接解到对端
ssh user@host 'tar -czf - /data' | tar -xzf - -C /local      # 从对端拉取
# 这个用法对内网大目录传输很实用（省掉打包落盘的时间和磁盘）

tar -czf backup.tar.gz /etc/nginx
# tar: Removing leading `/' from member names
#      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 这个警告是【好事】

# 如果保留绝对路径（-P），解压时会【无视你的当前目录】直接写到那个绝对位置
tar -czPf backup.tar.gz /etc/nginx          # -P 保留绝对路径
cd /tmp && tar -xzPf backup.tar.gz
# 结果：直接覆盖了 /etc/nginx，而不是解到 /tmp/etc/nginx  💀

# 更危险的是恶意归档
# 攻击者构造一个含 /etc/cron.d/backdoor 或 ../../../../etc/passwd 的归档，
# 你一解压就被覆盖了系统文件

# ✅ 所以默认行为（去掉开头的 /）是正确的，解压时会落在当前目录下
cd /tmp && tar -xzf backup.tar.gz
ls /tmp/etc/nginx                            # 解到了这里，安全

sudo tar -xzvpf backup.tar.gz -C /           # ✅ 用 -C / 指定解压根位置
#                              ^^^^ 明确、可控

# 解压前必看内容
tar -tzf unknown.tar.gz | head -20
tar -tzf unknown.tar.gz | grep -E '^/|\.\./'      # 检查有没有绝对路径或 ..
# 现代 GNU tar 默认会拒绝 ../ 穿越，但老版本和其他实现不一定

# 安全的解压姿势：解到一个空的临时目录
mkdir -p /tmp/extract && tar -xzf unknown.tar.gz -C /tmp/extract
ls /tmp/extract                              # 确认结构后再挪到目标位置

# ① 软链接：默认打包链接本身，不是目标内容
tar -czf backup.tar.gz dir                   # 归档里是软链接
tar -czhf backup.tar.gz dir                  # -h 跟随链接，打包实际内容（体积变大）
# 部署场景常需要 -h（把 current -> releases/v1.2.3 变成实体）

# ② 硬链接：tar 能正确识别并只存一份
tar -czf backup.tar.gz dir                   # 硬链接在归档里被标记，解压后仍是硬链接 ✅

# ③ 稀疏文件：不加 -S 会把空洞展开成真实的 0（体积暴涨）
tar -czSf vm.tar.gz disk.img                 # -S 高效处理稀疏文件

# ④ 时间戳：默认保留 mtime；想让 tar 包内容可复现（reproducible build）
tar --sort=name --mtime='2026-01-01 00:00:00' --owner=0 --group=0 --numeric-owner \
    -czf reproducible.tar.gz dir
#   ^^^^^^^^^^^ 固定顺序 + 固定时间戳 + 固定属主 = 内容相同则 tar 包字节相同

# ⑤ 文件名编码：GBK 文件名的归档在 UTF-8 系统上会乱码
tar -czf backup.tar.gz dir                   # tar 不做编码转换，原样存字节
convmv -f gbk -t utf8 -r --notest dir/       # 打包前先转换文件名编码

# ⑥ 大文件与 ARG_MAX：文件太多时命令行会超长
tar -czf backup.tar.gz $(find . -name '*.log')      # ❌ 可能 Argument list too long
find . -name '*.log' -print0 | tar -czf backup.tar.gz --null -T -    # ✅
#                                                    ^^^^^^ 从 stdin 读文件列表

# ⑦ 校验归档完整性
gzip -t backup.tar.gz                        # 测试 gzip 流是否完好
tar -tzf backup.tar.gz > /dev/null && echo OK   # 能完整列出说明没坏
sha256sum backup.tar.gz > backup.tar.gz.sha256   # ✅ 备份时同时存校验和
sha256sum -c backup.tar.gz.sha256               # 恢复前先校验

# 用 -g（--listed-incremental）记录状态快照
# 全量（level 0）
sudo tar -czf full.tar.gz -g /var/backups/snapshot.snar -C /data .

# 增量（level 1）：只打包自上次以来变化的文件
sudo tar -czf inc1.tar.gz -g /var/backups/snapshot.snar -C /data .
#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 同一个 snar 文件会被更新

# 恢复：必须【按顺序】解压全量 + 所有增量
sudo tar -xzf full.tar.gz -g /dev/null -C /restore
sudo tar -xzf inc1.tar.gz -g /dev/null -C /restore
#                          ^^^^^^^^^^^ 恢复时用 /dev/null（增量恢复要求）

# ⚠️ 三个问题让它在实践中不太好用：
# ① snar 文件丢了就无法继续增量
# ② 恢复必须按顺序，任何一个增量包损坏就断链
# ③ 删除的文件需要正确处理（tar 会记录，但容易出错）
# ✅ 生产上推荐用专门的备份工具（restic/borg/rsync --link-dest，见第 6 章）

# ── gzip ──
gzip file                       # 压缩（【删除原文件】，变成 file.gz）
gzip -k file                    # k = keep，保留原文件
gzip -c file > file.gz          # 或者用 -c 输出到 stdout
gzip -d file.gz                 # 解压（等价 gunzip）
gzip -1 file                    # 最快（压缩比最低）
gzip -9 file                    # 最慢（压缩比最高），默认是 -6
gzip -t file.gz                 # 测试完整性
gzip -l file.gz                 # 查看压缩率
gzip -r dir                     # 递归压缩目录里【每个文件】（不是打包！）
pigz -p 8 file                  # 多线程 gzip（8 线程）

# ── zstd（推荐）──
zstd file                       # 压缩（默认保留原文件，与 gzip 相反！）
zstd --rm file                  # 压缩后删除原文件
zstd -d file.zst                # 解压
zstd -19 file                   # 最高压缩比（1~19，默认 3）
zstd --ultra -22 file           # 超高（需要更多内存）
zstd -T0 file                   # 用所有 CPU 核心
zstd -1 file                    # 最快
zstd --long=27 file             # 长距离匹配（大文件效果好）
zstd --adapt file               # 自适应压缩级别（管道场景，根据 IO 速度调整）
zstd -c file | ...              # 输出到 stdout

# ── xz ──
xz file                         # 压缩（删除原文件）
xz -k file                      # 保留原文件
xz -d file.xz                   # 解压（等价 unxz）
xz -9e file                     # 极限压缩（e = extreme）
xz -T0 file                     # 多线程
xz -T4 -9 file                  # 4 线程 + 高压缩
xz --memlimit=2G -d file.xz     # 限制解压内存（解压高压缩比文件可能需要很多内存）

# ── bzip2 ──
bzip2 file / bunzip2 file.bz2
pbzip2 -p8 file                 # 多线程版

# ── lz4 ──
lz4 file                        # 极快
lz4 -9 file                     # 高压缩（仍然很快）
lz4 -d file.lz4

# ── 查看压缩文件（不解压）──
zcat / zless / zgrep / zdiff    # gzip
bzcat / bzless / bzgrep         # bzip2
xzcat / xzless / xzgrep         # xz
zstdcat / zstdgrep              # zstd

# 单线程 xz 压缩 10GB 可能要一小时，多线程能快 8 倍
tar -cf - /data | xz -T0 > data.tar.xz            # xz 内置多线程
tar -cf - /data | zstd -T0 -19 > data.tar.zst     # zstd 内置多线程
tar -cf - /data | pigz -p8 > data.tar.gz          # gzip 靠 pigz

# tar 直接指定压缩程序
tar -cf data.tar.gz -I 'pigz -p8' /data
tar -cf data.tar.zst -I 'zstd -T0 -19' /data
tar -cf data.tar.xz -I 'xz -T0 -9' /data
#                   ^^ -I / --use-compress-program 指定外部压缩命令

# 也可以直接设置环境变量
export GZIP='-9'                # 老式方式（已废弃，会有警告）
export ZSTD_CLEVEL=19
export ZSTD_NBTHREADS=0

zip -r archive.zip dir                    # -r 递归（不加只会打包目录本身）
zip -r archive.zip dir -x '*.log' '*/node_modules/*'      # -x 排除
zip -9 -r archive.zip dir                 # 最高压缩
zip -e archive.zip file                   # 加密（提示输入密码）
zip -s 100m -r big.zip dir                # 分卷（每卷 100MB）
zip -j archive.zip dir/*                  # j = junk paths，不保留目录结构
zip -u archive.zip newfile                # 更新已有归档

unzip archive.zip                         # 解压
unzip -l archive.zip                      # 列出内容（解压前必看）
unzip -d /target archive.zip              # 解到指定目录
unzip -o archive.zip                      # 覆盖已有文件（不提示）
unzip -n archive.zip                      # 不覆盖
unzip archive.zip 'path/*'                # 只解压匹配的
unzip -p archive.zip file > out           # 解压到 stdout
unzip -t archive.zip                      # 测试完整性

# ① 中文文件名乱码（Windows 用 GBK，Linux 用 UTF-8）
unzip archive.zip
# 文件名变成 ��ĵ�.txt

unzip -O GBK archive.zip                  # ✅ Debian/Ubuntu 的 unzip 支持 -O
unzip -O CP936 archive.zip                # 同上（CP936 = GBK）
# 不支持 -O 时用 7z 或 Python
7z x archive.zip                          # 7z 通常能正确处理
python3 -c "
import zipfile, sys, os
z = zipfile.ZipFile(sys.argv[1])
for n in z.namelist():
    fixed = n.encode('cp437').decode('gbk')
    print(fixed)
    z.extract(n)
    if n != fixed: os.rename(n, fixed)
" archive.zip

# ② zip 的加密不安全
zip -e archive.zip file                   # 传统 ZipCrypto，早已被破解
# ✅ 需要加密用 GPG 或 age
tar -czf - dir | gpg -c > backup.tar.gz.gpg          # 对称加密
tar -czf - dir | age -r <公钥> > backup.tar.gz.age   # 现代方案
7z a -p -mhe=on archive.7z dir            # 7z 的 AES-256（-mhe 连文件名一起加密）

# 一个直观的对比
cp -a /data/ /backup/                  # 每次都全量复制 10GB
rsync -a /data/ /backup/               # 第一次全量，之后只传变化的部分（可能只有几 MB）

rsync -a /src  /dst/          # -> /dst/src/...        把 src 这个【目录本身】放进 dst
rsync -a /src/ /dst/          # -> /dst/...            把 src 的【内容】放进 dst
#           ^ 就差这一个斜杠

# 实际演示
mkdir -p /tmp/a/sub && touch /tmp/a/f1 /tmp/a/sub/f2 && mkdir -p /tmp/b

rsync -a /tmp/a /tmp/b/ && find /tmp/b
# /tmp/b
# /tmp/b/a               <- 多了一层 a
# /tmp/b/a/f1
# /tmp/b/a/sub/f2

rm -rf /tmp/b/* 
rsync -a /tmp/a/ /tmp/b/ && find /tmp/b
# /tmp/b
# /tmp/b/f1              <- 直接是内容
# /tmp/b/sub/f2

# 目标路径的斜杠【无关紧要】（rsync 总把它当目录）
rsync -a /tmp/a/ /tmp/b       # 与 /tmp/b/ 等效

# 你想同步内容，但漏了源的斜杠
rsync -a --delete /data /backup/
# 结果：数据被放进 /backup/data/，而 /backup/ 下【原有的其他内容全被删了】
#      （因为 --delete 认为「源里只有 data 这一个条目」）

# ── 情况一：源路径写错或不存在（最常见）──
rsync -a --delete /dat/ /backup/          # 源目录名打错了（少了 a）
# rsync: change_dir "/dat" failed: No such file or directory
# ✅ 好消息：源【完全不存在】时 rsync 会报错退出，不会删

# ── 情况二：源目录存在但是空的（真正的杀手）──
# 场景：/data 是数据盘的挂载点，但盘没挂上，/data 是个空目录
mountpoint -q /data || echo "盘没挂上！"
rsync -a --delete /data/ /backup/
# 💀 源是空的 -> rsync 认为「所有文件都该删除」-> /backup 被清空

# ── 情况三：变量为空 ──
SRC=""                                     # 变量赋值失败
rsync -a --delete "$SRC/" /backup/         # 展开成 rsync -a --delete / /backup/
#                                             把整个根目录同步过去…

# ── 情况四：斜杠错位（见 5.2）──
rsync -a --delete /data /backup/           # /backup 下除了 data/ 之外的都被删

# ① --dry-run 演练（必做）
rsync -a --delete --dry-run /data/ /backup/ | head -50
rsync -avn --delete /data/ /backup/         # -n 是 --dry-run 的简写
#      ^^^ 一定要先看它打算删什么

# ② --max-delete 限制删除数量（最实用的兜底）
rsync -a --delete --max-delete=100 /data/ /backup/
# 超过 100 个删除操作就中止并报错，避免灾难性清空

# ③ 校验源不为空 + 是挂载点
[[ -n "$(ls -A /data)" ]] || { echo "源目录为空，中止"; exit 1; }
mountpoint -q /data || { echo "数据盘未挂载，中止"; exit 1; }

# ④ 用 --backup 保留被删除/覆盖的文件
rsync -a --delete --backup --backup-dir=/backup/.trash/$(date +%F) /data/ /backup/current/
#                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 被删的文件挪到回收站而不是真删

rsync -a src/ dst/
#      ^^ archive = -rlptgoD
#         │││││││
#         ││││││└─ D = --devices --specials  设备文件与特殊文件（需 root）
#         │││││└── o = --owner       保留属主（需 root）
#         ││││└─── g = --group       保留属组
#         │││└──── t = --times       保留 mtime  ← 【最关键】没有它每次都会重传！
#         ││└───── p = --perms       保留权限
#         │└────── l = --links       软链接照抄成软链接
#         └─────── r = --recursive   递归

rsync -aHAX src/ dst/
#       ^^^
#       │││
#       ││└─ X = --xattrs      扩展属性（SELinux 标签、user.* 属性）
#       │└── A = --acls        ACL（10 篇第 6 章）
#       └─── H = --hard-links  【保留硬链接关系】
#            不加 H 时，同一 inode 的两个名字会被复制成两份独立数据！
#            备份用了硬链接快照的目录时，不加 -H 会导致体积暴涨

# 完整的"一模一样"备份
rsync -aHAX --numeric-ids /data/ /backup/
#           ^^^^^^^^^^^^^ 跨机器时用 uid/gid 数字，避免用户名映射错乱

# ── 本地备份 ──
rsync -aH --info=progress2 /data/ /backup/
rsync -aH --delete --max-delete=100 -n /data/ /backup/     # 先演练
rsync -aH --delete --max-delete=100 /data/ /backup/        # 确认后执行

# ── 跨机传输 ──
rsync -avz /app/ user@host:/app/                    # 推（-z 跨网络值得开）
rsync -avz user@host:/app/ /app/                    # 拉
rsync -avz -e 'ssh -p 2222 -i ~/.ssh/deploy' /app/ user@host:/app/
rsync -avz --rsync-path='sudo rsync' /app/ user@host:/opt/app/   # 对端需要 sudo

# ── 限速与断点（大文件/生产环境必备）──
rsync -aP --bwlimit=50M /big/ host:/big/            # 限速 50MB/s + 断点续传
rsync -aP --partial-dir=.rsync-partial /big/ host:/big/

# ── 只同步特定文件 ──
rsync -av --include='*/' --include='*.go' --exclude='*' src/ dst/
#          ^^^^^^^^^^^^^ 必须先包含所有目录，否则 rsync 不会进入子目录
rsync -av --exclude-from=.rsyncignore src/ dst/
find . -name '*.log' -print0 | rsync -av --from0 --files-from=- . /backup/

# ── 排查「为什么这个文件被重传了」──
rsync -ain --itemize-changes /data/ /backup/ | head
# >f.st...... path/to/file
#  ││││││││││
#  ││└┴┴┴┴┴┴┴ 哪些属性不同：s=size t=time p=perms o=owner g=group a=acl x=xattr
#  │└──────── 文件类型：f=文件 d=目录 L=软链接
#  └───────── 操作：> 接收 < 发送 c 创建 h 硬链接 . 无变化

# ── 当「带进度的 mv」用 ──
rsync -aH --info=progress2 --remove-source-files /old/ /new/
find /old -type d -empty -delete                     # 源目录需要自己清理

# ── 校验已有备份的完整性 ──
rsync -avnc /data/ /backup/                          # -c 按内容校验，-n 只报告
#         ^^ 有输出说明内容不一致（能发现静默数据损坏）

#!/bin/bash
set -euo pipefail
SRC=/data
DST=/backup
TODAY=$(date +%F)
LATEST="$DST/latest"

# 安全检查
mountpoint -q "$SRC" || { echo "源未挂载"; exit 1; }
[[ -n "$(ls -A "$SRC")" ]] || { echo "源为空"; exit 1; }

rsync -aHAX --delete --max-delete=1000 \
      --link-dest="$LATEST" \
      "$SRC/" "$DST/$TODAY/"
#     ^^^^^^^^^^^^^^^^^^^^^ 与上一次备份中【未变化】的文件建硬链接

ln -sfn "$DST/$TODAY" "$LATEST"          # 更新 latest 指针（06 篇讲的原子切换）

du -sh /backup/2026-08-10 /backup/2026-08-11 /backup/2026-08-12
# 100G    /backup/2026-08-10
# 100G    /backup/2026-08-11        <- 每个都"看起来"是完整的 100G
# 100G    /backup/2026-08-12

du -sh /backup/                     # 但总占用远小于 300G
# 104G    /backup/                  <- 未变化的文件是硬链接，只占一份

# 每个快照都是【完整可用】的目录树，恢复时直接 cp 就行，不需要"重放增量"
cp -a /backup/2026-08-10/some/file /data/some/file

# 一个务实的落地方案
# ① 本地：rsync --link-dest 每日快照（快速恢复单个文件）
# ② 异地：restic/borg 加密备份到对象存储（防机房级故障）
# ③ 定期验证：每月做一次真实恢复演练

# ── restic（推荐：Go 写的，单二进制，支持 S3/GCS/本地/SFTP）──
export RESTIC_REPOSITORY=s3:s3.amazonaws.com/mybucket/backup
export RESTIC_PASSWORD_FILE=/root/.restic-pass
restic init                              # 初始化仓库
restic backup /data --exclude-file=/etc/restic-excludes
restic snapshots                         # 列出所有快照
restic ls latest                         # 浏览快照内容
restic restore latest --target /restore  # 恢复
restic restore latest --include /data/important.txt --target /tmp   # 恢复单个文件
restic check --read-data                 # ✅ 验证仓库完整性（定期做）
restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune
#             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 保留策略 + 清理

# 特点：块级去重（改一行的 10GB 文件只增量存变化的块）、
#      默认加密、支持并发、快照不可变

# ── borg（类似，本地/SSH 场景性能更好）──
borg init --encryption=repokey /backup/repo
borg create /backup/repo::{now:%Y-%m-%d} /data
borg list /backup/repo
borg extract /backup/repo::2026-08-12
borg prune --keep-daily=7 --keep-weekly=4 /backup/repo
borg check /backup/repo

# 「没验证过的备份等于没有备份」—— 这是运维界的老话
# 三个层次的验证：

# ① 完整性校验（能检测介质损坏）
sha256sum -c backup.tar.gz.sha256
restic check --read-data
tar -tzf backup.tar.gz > /dev/null && echo "归档结构完好"

# ② 抽样恢复（能检测备份内容错误）
mkdir /tmp/verify
tar -xzf backup.tar.gz -C /tmp/verify path/to/known/file
diff /tmp/verify/path/to/known/file /data/path/to/known/file

# ③ 完整恢复演练（唯一能真正证明备份可用的方式）
# 定期（如每季度）在一台干净机器上做完整恢复，并验证服务能正常启动
# 记录 RTO（恢复需要多久）和 RPO（会丢多少数据）

# 常见的「备份失效」原因
# - 备份脚本静默失败了几个月（没有监控告警）
# - 磁盘满了导致备份被截断
# - 加密密钥丢了（备份在，但打不开）
# - 备份了数据库文件但没做一致性快照（恢复出来是损坏的）
# - 保留策略配错，需要的那个时间点已经被清理了

# ✅ 备份脚本必须有成功/失败通知
#!/bin/bash
set -euo pipefail
trap 'curl -fsS "https://hc-ping.com/xxx/fail"' ERR
#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 失败时通知（healthchecks.io 之类）

restic backup /data
restic check
curl -fsS "https://hc-ping.com/xxx"       # 成功时打卡
# 这样「脚本静默失败了三个月」就不会发生 —— 没打卡就会告警

# 记忆口诀：c 创建 / x 解开 / t 查看，f 指定文件名，v 显示过程
tar -czvf out.tar.gz -C /src .        # 打包（zstd 用 --zstd，xz 用 -J）
tar -tzvf out.tar.gz                  # 【先查看】
tar -xzvf out.tar.gz -C /dst          # 解包
tar -xzvf out.tar.gz --strip-components=1 -C /dst    # 去掉最外层目录
tar -xzOf out.tar.gz path/to/f        # 只把某文件输出到 stdout
tar -czf - dir | ssh host 'tar -xzf - -C /dst'       # 跨机传输
tar -cf out.tar.zst -I 'zstd -T0 -19' dir            # 指定外部压缩程序（多线程）

# ── 记住三件事 ──
# ① 源末尾的 / = "里面的内容"
# ② --delete 之前必须 --dry-run
# ③ -a 不含 -H -A -X

rsync -aH --info=progress2 /src/ /dst/               # 本地备份
rsync -avz -e 'ssh -p 2222' /src/ host:/dst/         # 跨机
rsync -avn --delete /src/ /dst/                      # 【演练】删除操作
rsync -aH --delete --max-delete=100 /src/ /dst/      # 带安全带的镜像同步
rsync -aP --bwlimit=50M /big/ host:/big/             # 限速 + 断点
rsync -aHAX --link-dest=/backup/latest /src/ /backup/$(date +%F)/   # 增量快照
rsync -ain --itemize-changes /src/ /dst/             # 排查为什么重传
rsync -avnc /src/ /dst/                              # 按内容校验备份是否一致

# ── scp（简单文件传输，已被 rsync/sftp 取代）──
scp file host:/path/                  # 单文件
scp -r dir host:/path/                # 递归
scp -P 2222 -i ~/.ssh/key file host:/path/
scp -C file host:/path/               # 压缩传输
scp -l 8000 file host:/path/          # 限速（单位 Kbit/s）
# ⚠️ OpenSSH 9.0+ 默认改用 SFTP 协议，某些老式通配符行为变了
# ✅ 大目录/需要断点续传时一律用 rsync

# ── sftp（交互式）──
sftp host
# get / put / ls / cd / lls / lcd / bye
sftp -b batch.txt host                # 批处理模式

# ── 其他传输工具 ──
rclone sync /data remote:bucket/      # 同步到 S3/GCS/OneDrive 等 40+ 云存储
croc send file                        # 点对点传输（自动打洞，适合临时分享）
magic-wormhole                        # 类似

# ── split：分割大文件 ──
split -b 2G big.tar.gz part_          # 按大小分割成 part_aa part_ab...
split -n 4 big.tar.gz part_           # 分成 4 份
split -l 100000 huge.log part_        # 按行数分割
cat part_* > restored.tar.gz          # 合并
# 用途：绕过单文件大小限制（FAT32 的 4GB、某些网盘）

# ── dd：块级复制 ──
dd if=/dev/sda of=disk.img bs=4M status=progress          # 整盘镜像
dd if=disk.img of=/dev/sdb bs=4M status=progress          # 写回
dd if=/dev/zero of=/swapfile bs=1M count=4096             # 造文件
# ⚠️ dd 的 if/of 写反会直接销毁数据，执行前反复确认
# ✅ 整盘克隆更推荐 ddrescue（能跳过坏块并记录进度）
sudo ddrescue /dev/sda /dev/sdb rescue.log

rsync -avn --delete /data/ /backup/            # ① --dry-run 必做
rsync -a --delete --max-delete=100 ...         # ② 删除超过 100 个就中止（最实用）
mountpoint -q /data && [[ -n "$(ls -A /data)" ]] || exit 1   # ③ 校验源
rsync -a --delete --backup --backup-dir=/backup/.trash/$(date +%F) ...  # ④ 回收站

rsync -aHAX --delete --link-dest=/backup/latest /data/ /backup/$(date +%F)/
ln -sfn /backup/$(date +%F) /backup/latest