# Docker 管理的 volume 默认位置
/var/lib/docker/volumes//_data/

# 查看所有 volume
docker volume ls

# 查看 volume 详情
docker volume inspect 

# 假设有备份文件 backup-data.tar.gz

# 1. 重新创建 volume
docker volume create mydata

# 2. 启动临时容器恢复数据
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  ubuntu \
  tar xzf /backup/backup-data.tar.gz -C /data

# 3. 验证数据
docker run --rm -v mydata:/data ubuntu ls -la /data

# 检查 volume 是否还存在
docker volume ls | grep mydata

# 查看 volume 中的数据
docker run --rm -v mydata:/data ubuntu ls -la /data

# 重建容器并挂载原 volume
docker run -d \
  --name myapp \
  -v mydata:/app/data \
  myapp:latest

# 源主机：导出 volume
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  ubuntu \
  tar czf /backup/mydata-backup.tar.gz /data/

# 传输备份文件到目标主机
scp mydata-backup.tar.gz target-host:/tmp/

# 目标主机：导入 volume
docker volume create mydata
docker run --rm \
  -v mydata:/data \
  -v /tmp:/backup \
  ubuntu \
  tar xzf /backup/mydata-backup.tar.gz -C /data

#!/bin/bash
# backup_volumes.sh

BACKUP_DIR="/backup/volumes"
DATE=$(date +%Y%m%d)

# 备份所有 volume
for volume in $(docker volume ls -q); do
  echo "Backing up $volume..."
  docker run --rm \
    -v $volume:/data \
    -v $BACKUP_DIR:/backup \
    ubuntu \
    tar czf /backup/${volume}_${DATE}.tar.gz /data/
done

# 每天凌晨 2 点备份
0 2 * * * /opt/scripts/backup_volumes.sh

#!/bin/bash
# backup_and_rotate.sh

BACKUP_DIR="/backup/volumes"
RETENTION_DAYS=30

# 备份
docker run --rm \
  -v myapp-data:/data \
  -v $BACKUP_DIR:/backup \
  ubuntu \
  tar czf /backup/mydata_$(date +%Y%m%d_%H%M%S).tar.gz /data/

# 清理过期备份
find $BACKUP_DIR -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete

# 备份
docker exec mysql-container \
  mysqldump -u root -p$PASSWORD --all-databases > backup.sql

# 恢复
docker exec -i mysql-container \
  mysql -u root -p$PASSWORD < backup.sql

# 或者使用 volume 方式
docker run --rm \
  -v mysql_data:/var/lib/mysql \
  -v $(pwd):/backup \
  ubuntu \
  tar xzf /backup/mysql_backup.tar.gz -C /

# 备份
docker exec pg-container pg_dumpall -U postgres > backup.sql

# 恢复
cat backup.sql | docker exec -i pg-container psql -U postgres

# 安装 restic 并配置 s3 后端
docker run --rm \
  -v mydata:/data \
  -e RESTIC_REPOSITORY=s3:s3.amazonaws.com/bucket-name \
  -e RESTIC_PASSWORD=secret \
  restic/restic backup /data

# 如果数据运行在 Kubernetes 中
velero backup create myapp-backup --include-namespaces myapp
velero restore create --from-backup myapp-backup

# 1. 确认 volume 是否存在
docker volume ls

# 2. 确认备份文件完整性
tar tzf backup.tar.gz | head

# 3. 恢复数据
# (执行恢复命令)

# 4. 验证数据完整性
docker run --rm -v restored-volume:/data ubuntu \
  find /data -type f | wc -l

# 5. 挂载到新容器测试
docker run -d -v restored-volume:/app/data myapp

# 创建一个容器并挂载命名卷
docker run -d --name test-app \
  -v my-data:/app/data \
  alpine sleep 360

# 删除容器（不使用 -v）
docker rm test-app

# 卷仍然存在
docker volume ls
# DRIVER    VOLUME NAME
# local     my-data

# 创建命名卷
docker volume create prod-data

# 容器使用命名卷
docker run -d --name db -v prod-data:/var/lib/mysql mysql:8.0

# 删除容器，命名卷保留
docker rm db
docker volume ls | grep prod-data
# local     prod-data    ← 还在

# 使用匿名卷（未指定名称）
docker run -d --name temp -v /data nginx

# 删除容器并删除匿名卷
docker rm -v temp
# 匿名卷一起被删除

# 但是命名卷不受影响
docker run -d --name db -v my-named-data:/data alpine
docker rm -v db
docker volume ls | grep my-named-data
# local     my-named-data    ← 命名卷仍然保留

# 停止容器
docker stop db

# 卷仍然可用
docker volume ls | grep prod-data

# 新容器可以立即使用旧卷
docker run -d --name db-v2 -v prod-data:/var/lib/mysql mysql:8.0
# 数据完全保留！

# docker-compose.yml
services:
  db:
    image: mysql:8.0
    volumes:
      - named-data:/var/lib/mysql
      - /data/logs  # 匿名卷

volumes:
  named-data:

# 停止并删除容器和网络，但保留卷
docker compose down
# 命名卷 named-data 保留
# 匿名卷 /data/logs 被删除

# 再次启动时，命名卷数据还在
docker compose up -d

# 删除所有：容器、网络、命名卷、匿名卷
docker compose down -v

# 推荐：使用命名卷
docker run -d -v app-data:/data myapp

# 不推荐：使用匿名卷（容易丢失）
docker run -d -v /data myapp

# 升级 MySQL 版本时保留数据
# 1. 停止旧容器（保留卷）
docker stop mysql-old

# 2. 启动新容器使用同一卷
docker run -d --name mysql-new \
  -v mysql-data:/var/lib/mysql \
  mysql:8.0

# 3. 确认数据正常后删除旧容器
docker rm mysql-old

# 升级脚本版本
```bash
#!/bin/bash
# upgrade-container.sh
CONTAINER_NAME=$1
IMAGE=$2
VOLUMES=$(docker inspect $CONTAINER_NAME --format='{{range .Mounts}}{{.Name}}:{{.Destination}} {{end}}')
NETWORKS=$(docker inspect $CONTAINER_NAME --format='{{range $net, $v := .NetworkSettings.Networks}}{{$net}} {{end}}')

# 停止并删除旧容器（不删除卷）
docker stop $CONTAINER_NAME
docker rm $CONTAINER_NAME

# 启动新容器使用同一卷
docker run -d --name ${CONTAINER_NAME}-new \
  $(for vol in $VOLUMES; do echo "-v $vol"; done) \
  $(for net in $NETWORKS; do echo "--network $net"; done) \
  $IMAGE

# --rm 标志
docker run --rm -v /app/data alpine ...
# 容器退出后自动删除，但匿名卷会保留（除非创建时就 标记为 cleanup）

# 命名卷不受 --rm 影响
docker run --rm -v named-data:/app/data alpine ...
# 退出后容器删除，卷保留

# 默认不清理卷
docker system prune
# Volumes 不会被删除

# 显式要求清理卷
docker system prune --volumes
# 所有未使用的卷（包括匿名卷和未被容器引用的命名卷）都会被删除

# 查看哪些容器在使用某个卷
docker ps -a --filter volume=my-data

# 查找 orphan 卷（未与任何容器关联）
docker volume ls --filter dangling=true

# 检查特定 Volume 的引用关系
docker volume inspect my-data | grep -A 5 "CreatedAt"

# 创建 NFS 数据卷
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100,rw,nfsvers=4 \
  --opt device=:/exports/data \
  nfs-share

# 使用 NFS 卷
docker run -d --name web \
  -v nfs-share:/var/www/html \
  nginx

docker run -d --name web \
  --mount type=volume,source=nfs-share,target=/var/www/html \
  --mount type=bind,source=/host/path,target=/data \
  nginx

docker run -d --name app \
  --mount type=bind,source=/mnt/nfs/static,target=/app/static \
  nginx

# 或者直接在容器内 mount
docker run --privileged alpine \
  sh -c "mount -t nfs 192.168.1.100:/exports/data /mnt && ls /mnt"

docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100 \
  --opt device=:/path/on/nfs/server \
  vol-name

# 生产环境 NFS 卷配置
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.200,nfsvers=4.1,rw,hard,intr,timeo=600,retrans=5 \
  --opt device=:/mnt/production/data \
  prod-nfs

# docker-compose.yml
services:
  web:
    image: nginx
    volumes:
      - nfs-static:/usr/share/nginx/html

volumes:
  nfs-static:
    driver: local
    driver_opts:
      type: nfs
      o: addr=192.168.1.100,nfsvers=4,rw
      device: ":/exports/static"

# Ubuntu/Debian
apt-get update && apt-get install -y nfs-kernel-server

# CentOS/RHEL
yum install -y nfs-utils

# /etc/exports
/exports/data     192.168.1.0/24(rw,sync,no_subtree_check,no_root_squash)
/exports/static   192.168.0.0/22(ro,sync,no_subtree_check)

# 使配置生效
exportfs -a

# 查看当前导出
showmount -e localhost

# Ubuntu/Debian
apt-get install -y nfs-common

# CentOS/RHEL
yum install -y nfs-utils

docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100,rsize=1048576,wsize=1048576,noatime,nodiratime \
  --opt device=:/exports/data \
  perf-nfs

# 使用专用的存储网络，避免与其他流量共享
# 考虑使用更快的网络（10GbE 或更高）

# MTU 调整
# NFS over Jumbo Frames（9000 MTU）
docker volume create \
  --opt o=addr=192.168.1.100,mountproto=tcp,rsize=1048576 \
  ...

# 检查 NFS 服务器是否可达
ping 192.168.1.100

# 检查 NFS 导出是否可用
showmount -e 192.168.1.100

# 手动挂载测试
mount -t nfs 192.168.1.100:/exports/data /mnt/test

# 容器内 UID 映射问题
# 确保 NFS 导出目录的权限与容器内 UID 匹配
chown -R 999:999 /exports/data  # PostgreSQL 常用 UID=999

# 或使用 squash 选项
# /etc/exports 配置
/exports/data 192.168.1.0/24(rw,sync,all_squash,anonuid=999,anongid=999)

# 检查 NFS 延迟
nfsstat -s

# 监控 NFS 操作
nfswatch -h 192.168.1.100

# 备份：将 Volume 打包到宿主机
docker run --rm -v :/data -v :/backup alpine \
  tar czf /backup/.tar.gz -C /data .

# 恢复：将备份包解压到 Volume
docker run --rm -v :/data -v :/backup alpine \
  tar xzf /backup/.tar.gz -C /data

# 创建一个测试数据卷并写入数据
docker volume create myapp-data
docker run --rm -v myapp-data:/data alpine sh -c "echo 'Hello Docker' > /data/test.txt"

# 备份 myapp-data 到当前目录
docker run --rm \
  -v myapp-data:/source \
  -v $(pwd):/backup \
  alpine \
  tar czf /backup/myapp-data-20240101.tar.gz -C /source .

#!/bin/bash
# backup-all-volumes.sh

BACKUP_DIR="/backups/volumes"
mkdir -p $BACKUP_DIR

for vol in $(docker volume ls -q); do
  echo "Backing up volume: $vol"
  docker run --rm \
    -v $vol:/data \
    -v $BACKUP_DIR:/backup \
    alpine \
    tar czf /backup/${vol}-$(date +%Y%m%d).tar.gz -C /data .
done

echo "All volumes backed up to $BACKUP_DIR"

docker run --rm \
  -v myapp-data:/source \
  -v $(pwd)/incremental:/target \
  alpine \
  sh -c "apk add --no-cache rsync && rsync -av --delete /source/ /target/"

# 备份到 S3 兼容存储
docker run --rm \
  -v myapp-data:/data \
  -e AWS_ACCESS_KEY_ID=xxx \
  -e AWS_SECRET_ACCESS_KEY=xxx \
  amazon/aws-cli \
  s3 sync /data s3://my-backup-bucket/volumes/myapp-data/

# 1. 如果 Volume 不存在则创建
docker volume create myapp-data

# 2. 恢复到 Volume
docker run --rm \
  -v myapp-data:/target \
  -v $(pwd):/backup \
  alpine \
  tar xzf /backup/myapp-data-20240101.tar.gz -C /target

# 3. 验证恢复结果
docker run --rm -v myapp-data:/data alpine cat /data/test.txt
# 输出：Hello Docker

# 创建目标 Volume
docker volume create staging-data

# 恢复备份数据
docker run --rm \
  -v staging-data:/target \
  -v $(pwd):/backup \
  alpine \
  tar xzf /backup/myapp-data-20240101.tar.gz -C /target

# 恢复备份文件中的特定子目录
docker run --rm \
  -v myapp-data:/target \
  -v $(pwd):/backup \
  alpine \
  tar xzf /backup/myapp-data-20240101.tar.gz \
    -C /target \
    --wildcards 'subdir/*'

# /etc/cron.d/docker-volume-backup
0 2 * * * root /usr/local/bin/backup-volumes.sh

# 备份脚本内容
# backup-volumes.sh
#!/bin/bash
BACKUP_DIR=/backups/volumes
RETENTION_DAYS=30
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR

# 备份指定 Volume
for vol in prod-db prod-redis prod-config; do
  docker run --rm \
    -v $vol:/data \
    -v $BACKUP_DIR:/backup \
    alpine \
    tar czf /backup/${vol}-${DATE}.tar.gz -C /data .
done

# 删除过期备份
find $BACKUP_DIR -name "*.tar.gz" -mtime +$RETENTION_DAYS -delete

docker run -d --name volume-backup \
  -v prod-data:/backup/data:ro \
  -v /backups:/backup \
  -e BACKUP_RETENTION=7 \
  offen/docker-volume-backup:v2

# 一致性备份需要使用 mysqldump
docker exec mysql-container mysqldump --all-databases --single-transaction \
  > /backups/mysql/mysql-$(date +%Y%m%d).sql

# 使用 pg_dump 保证一致性
docker exec postgres-container pg_dump -U postgres -Fc mydb \
  > /backups/postgres/mydb-$(date +%Y%m%d).dump

# 应用支持优雅停止写入
docker exec app-container kill -USR1 1  # 应用停止写入
docker run --rm -v app-data:/data -v $(pwd):/backup alpine tar czf ...
docker exec app-container kill -USR2 1  # 恢复写入

# 创建一个数据卷容器（没有运行任何服务）
docker create -v /shared-data --name data-container busybox /bin/true

# 创建并保持运行
docker run -d -v /shared-data --name data-container busybox sleep infinity

# 容器 B 共享数据卷容器的数据
docker run -d --name app1 --volumes-from data-container nginx

docker run -d --name app2 --volumes-from data-container alpine tail -f /dev/null

# data-container 是源
docker run -d --volumes-from data-container --name level1 nginx
docker run -d --volumes-from level1 --name level2 nginx
# level2 也能访问 data-container 的数据

数据卷容器（data-container）
  └── /shared-data (Volume: abc123)
        ├── app1 (/shared-data)
        ├── app2 (/shared-data)
        └── app3 (/shared-data)

# 数据卷容器存放配置文件
docker create -v /etc/nginx/conf.d --name config-container busybox

# 写入配置（通过辅助容器）
docker run --rm --volumes-from config-container alpine sh -c "
  echo 'server { listen 80; }' > /etc/nginx/conf.d/default.conf
"

# 多个 Nginx 容器使用同一套配置
docker run -d --volumes-from config-container --name nginx1 nginx
docker run -d --volumes-from config-container --name nginx2 nginx

# 应用容器写数据到共享卷
docker run -d -v /app/logs --name app-server myapp

# Logstash 容器读取日志
docker run -d --volumes-from app-server \
  -v logstash.conf:/etc/logstash/conf.d/logstash.conf \
  logstash

# 备份数据卷容器的数据
docker run --rm --volumes-from data-container \
  -v $(pwd):/backup alpine \
  tar czf /backup/data-backup.tar.gz /shared-data

# 还原
docker run --rm --volumes-from data-container \
  -v $(pwd):/backup alpine \
  tar xzf /backup/data-backup.tar.gz -C /shared-data

# 先初始化数据库脚本到一个共用卷
docker create -v /docker-entrypoint-initdb.d --name init-scripts busybox

# 拷贝初始化 SQL
docker cp init.sql init-scripts:/docker-entrypoint-initdb.d/

# 多个 MySQL 实例使用同一份初始化脚本
docker run -d --volumes-from init-scripts -e MYSQL_ROOT_PASSWORD=root mysql:8.0
docker run -d --volumes-from init-scripts -e MYSQL_ROOT_PASSWORD=root mysql:8.0

# 命令结构
docker volume <子命令> [参数]

# 常用子命令
docker volume create     # 创建卷
docker volume ls         # 列出卷
docker volume inspect    # 查看卷详情
docker volume rm         # 删除卷
docker volume prune      # 清理未使用的卷

# 创建最简单的卷
docker volume create mydata

# 创建带标签的卷
docker volume create \
  --label environment=production \
  --label app=myapp \
  mydata

# 创建指定驱动的卷
docker volume create \
  --driver local \
  --opt type=none \
  --opt device=/mnt/external_drive \
  --opt o=bind \
  external-volume

# 创建 NFS 卷
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100,rw,nfsvers=4 \
  --opt device=:/export/data \
  nfs-data

# 运行容器时自动创建匿名卷
docker run -d -v /var/lib/mysql mysql:8
# Docker 自动生成一个随机卷名

# 运行容器时自动创建命名卷
docker run -d -v mydata:/data alpine
# 如果 mydata 不存在，Docker 自动创建

# 基础挂载
docker run -d --name app -v mydata:/app/data myapp

# 只读挂载
docker run -d --name app -v mydata:/app/data:ro myapp

# --mount 语法（更明确，推荐）
docker run -d --name app \
  --mount type=volume,source=mydata,target=/app/data,readonly \
  myapp

# 指定挂载的子路径
docker run -d --name app \
  -v mydata:/app/data:ro \
  myapp

# 创建共享卷
docker volume create shared-data

# 所有容器挂载同一个卷
docker run -d --name writer1 -v shared-data:/data alpine watch -n 1 'echo $$ >> /data/pids.txt'
docker run -d --name writer2 -v shared-data:/data alpine watch -n 1 'date >> /data/dates.txt'
docker run -d --name reader -v shared-data:/data alpine tail -f /data/*

# 列出所有卷
docker volume ls

# 过滤
docker volume ls --filter "label=environment=production"
docker volume ls --filter "dangling=true"
docker volume ls --filter "name=mydata"

# 格式化输出
docker volume ls --format "table {{.Name}}\t{{.Driver}}\t{{.Mountpoint}}"

# 查看详情
docker volume inspect mydata
# 输出包含：
# - Name: 卷名
# - Driver: 驱动类型
# - Mountpoint: 宿主机实际路径
# - Labels: 标签
# - Scope: 作用域（local/global）
# - Options: 驱动选项

# 查看磁盘使用
docker system df
docker system df -v  # 包含每个卷的详细信息

# 方法一：挂载卷 + tar（推荐）
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  alpine \
  tar czf /backup/mydata-$(date +%Y%m%d).tar.gz -C /data .

# 创建备份卷
docker volume create mydata-backup

# 复制数据
docker run --rm \
  -v mydata:/source \
  -v mydata-backup:/target \
  alpine \
  sh -c "cp -a /source/. /target/"

# 使用 rsync（需要容器内有 rsync）
docker run --rm \
  -v mydata:/source \
  -v mydata-backup:/target \
  alpine \
  sh -c "apk add rsync && rsync -avh /source/ /target/"

# 从 tar 文件恢复
docker run --rm \
  -v mydata:/target \
  -v $(pwd):/backup \
  alpine \
  tar xzf /backup/mydata-20240101.tar.gz -C /target/

# 源机器：导出
docker run --rm \
  -v mydata:/data \
  alpine \
  tar czf - -C /data . | \
  ssh user@target-host "cat > /tmp/mydata.tar.gz"

# 或者：
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  alpine \
  tar czf /backup/mydata.tar.gz -C /data .

scp mydata.tar.gz user@target-host:/tmp/

# 目标机器：导入
ssh target-host
docker volume create mydata
docker run --rm \
  -v mydata:/data \
  -v /tmp:/backup \
  alpine \
  tar xzf /backup/mydata.tar.gz -C /data

# 删除一个卷
docker volume rm mydata

# 批量删除
docker volume rm vol1 vol2 vol3

# 删除所有未使用的卷（慎用）
docker volume prune

# 删除所有未使用的卷（不提示）
docker volume prune -f

# 删除未使用且超过 24 小时的卷
docker volume prune --filter "until=24h"

# 只删除指定标签的未使用卷
docker volume prune --filter "label!=keep"

# 好的实践：使用标签管理
docker volume create \
  --label project=myapp \
  --label environment=production \
  --label backup=scheduled \
  myapp-data

# 定期清理脚本
#!/bin/bash
# cleanup-volumes.sh
echo "=== 清理未使用的卷 ==="
docker volume prune -f

echo "=== 备份关键卷 ==="
for vol in myapp-data myapp-db app-logs; do
  docker run --rm \
    -v $vol:/source \
    -v $(pwd)/backup:/backup \
    alpine \
    tar czf /backup/$vol-$(date +%Y%m%d).tar.gz -C /source .
done

# docker-compose.yml
version: '3.8'
services:
  db:
    image: postgres:15
    volumes:
      - pgdata:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql:ro

  app:
    image: myapp:latest
    volumes:
      - app-data:/app/data
      - app-logs:/var/log/myapp

volumes:
  pgdata:           # 创建命名卷
  app-data:
  app-logs:
    driver: local
    driver_opts:
      type: none
      device: /mnt/ssd/logs
      o: bind

# 查看卷内容
docker run --rm -it -v mydata:/data alpine ls -la /data

# 复制文件到卷
docker run --rm -v mydata:/data alpine sh -c \
  'echo "config data" > /data/config.json'

# 查看卷的实际存储路径
docker volume inspect mydata --format '{{.Mountpoint}}'

# 默认存储路径
ls -la /var/lib/docker/volumes/

# 典型输出
drwx-----x  4 root root   4096 Jan 15 10:00 mydata
drwx-----x  4 root root   4096 Jan 15 10:01 app-logs
drwx-----x  4 root root   4096 Jan 15 10:02 pgdata
...

# 每个卷是一个目录
# 目录名 = 卷名
# 实际数据在 _data 子目录中

# 查看具体卷的目录结构
ls -la /var/lib/docker/volumes/mydata/
# total 20
# drwx-----x  3 root root 4096 Jan 15 10:00 .
# drwx--x--x 12 root root 4096 Jan 15 10:00 ..
# drwxr-xr-x  2 root root 4096 Jan 15 10:00 _data   ← 实际数据

# 查看数据卷挂载点
docker volume inspect mydata
# [
#   {
#     "CreatedAt": "2024-01-15T10:00:00+08:00",
#     "Driver": "local",
#     "Labels": {},
#     "Mountpoint": "/var/lib/docker/volumes/mydata/_data", ← 实际路径
#     "Name": "mydata",
#     "Options": {},
#     "Scope": "local"
#   }
# ]

# 这会移动 Docker 的所有数据（包括镜像、容器、卷）
# 不仅是数据卷

# 1. 停止 Docker
systemctl stop docker

# 2. 移动现有数据
mv /var/lib/docker /data/docker

# 3. 创建软链接（最简单的方式）
ln -s /data/docker /var/lib/docker

# 4. 或者修改 daemon.json
# /etc/docker/daemon.json
{
  "data-root": "/data/docker"
}

# 5. 启动 Docker
systemctl start docker

# 验证
docker info | grep "Docker Root Dir"
# Docker Root Dir: /data/docker

# 如果只想移动卷数据
systemctl stop docker

# 移动卷目录
mv /var/lib/docker/volumes /data/docker-volumes

# 创建软链接
ln -s /data/docker-volumes /var/lib/docker/volumes

# 或者指向另一个磁盘
ln -s /mnt/ssd/volumes /var/lib/docker/volumes

systemctl start docker

# 创建卷时指定存储位置
docker volume create \
  --driver local \
  --opt type=none \
  --opt device=/mnt/external_drive/myapp-data \
  --opt o=bind \
  custom-location-volume

# 验证
docker volume inspect custom-location-volume
# "Mountpoint": "/var/lib/docker/volumes/custom-location-volume/_data"
# 实际数据在 /mnt/external_drive/myapp-data

# 查看所有卷占用的空间
du -sh /var/lib/docker/volumes/*/

# 更友好的方式
sudo docker system df -v | grep -A 10 "Volumes"

# 按大小排序
du -sh /var/lib/docker/volumes/*/ | sort -hr

# 查看 Docker 数据目录总体占用
docker system df
# TYPE                TOTAL    ACTIVE   SIZE       RECLAIMABLE
# Images              15       8        3.245GB    1.2GB (37%)
# Containers          12       5        512.3MB    0B
# Local Volumes       8        5        1.8GB      856.3MB
# Build Cache         23       0        125MB      125MB

# 方式 1：直接备份卷目录
tar czf /backup/docker-volumes-$(date +%Y%m%d).tar.gz /var/lib/docker/volumes/

# 方式 2：只备份特定卷
tar czf /backup/pgdata-$(date +%Y%m%d).tar.gz /var/lib/docker/volumes/pgdata/

# 方式 3：使用卷备份模式（推荐）
docker run --rm \
  -v pgdata:/source \
  -v /backup:/backup \
  alpine \
  tar czf /backup/pgdata-$(date +%Y%m%d).tar.gz -C /source .

# Docker 版本不同，存储驱动可能不同
docker info | grep "Storage Driver"
# Storage Driver: overlay2

# 不同存储驱动对卷的影响
# overlay2：卷在 /var/lib/docker/volumes/ 下
# devicemapper：卷可能在不同位置
# btrfs/zfs：利用文件系统快照能力

# 数据卷目录的默认权限
ls -la /var/lib/docker/volumes/
# drwx--x--x  4 root root ...

# 普通用户无法直接访问
# 需要通过 docker volume 命令操作

# 如果确实需要手动操作，用 sudo
sudo ls /var/lib/docker/volumes/mydata/_data

# 方案一：迁移到新磁盘（推荐）
# 1. 停止 Docker
systemctl stop docker

# 2. 迁移
mv /var/lib/docker /mnt/new-disk/docker
ln -s /mnt/new-disk/docker /var/lib/docker

# 3. 启动 Docker
systemctl start docker

# 方案二：创建卷时指定其他位置
docker volume create \
  --opt device=/mnt/new-disk/volumes/myvol \
  --opt type=none --opt o=bind \
  myvol

docker volume inspect <卷名> --format '{{.Mountpoint}}'
# 或
docker volume inspect <卷名> | jq -r '.[0].Mountpoint'

# 1. 将数据卷放在单独的分区或磁盘上
#    避免与系统分区争用 IO

# 2. 监控卷磁盘使用
#    定期检查 du -sh /var/lib/docker/volumes/*/

# 3. 使用命名卷而非匿名卷
#    便于管理和识别

# 4. 生产环境考虑使用专门的存储
#    NFS、SAN、云存储等通过 Volume Driver 集成

# 5. 备份策略
#    卷数据 + 元数据（volume inspect 输出）一起备份

Volume 六大优势
├── 1. Docker 完全管理
├── 2. 权限自动处理
├── 3. 可移植性
├── 4. 备份恢复方便
├── 5. 多容器共享
├── 6. 驱动扩展（NFS、加密等）

# Volume 有完整的生命周期管理
docker volume create mydata     # 创建
docker volume ls               # 列出
docker volume inspect mydata   # 查看详情
docker volume rm mydata        # 删除
docker volume prune            # 清理未使用的卷

# Bind Mount 无任何 Docker 管理命令
# 需要手动管理宿主机上的文件

# Volume 不需要关心 UID/GID 映射
# Docker 自动处理容器内外的权限

# 示例：MySQL 数据库
docker volume create mysql-data
docker run -d \
  -v mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  mysql:8

# MySQL 容器内的 mysql 用户（UID 999）写入数据
# Volume 自动处理了权限，不需要手动 chown

# 如果用 Bind Mount：
docker run -d \
  -v /home/user/mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  mysql:8
# 可能遇到权限问题，需要手动 chown 999:999 /home/user/mysql-data

# 这是 Volume 和 Bind Mount 的重大差异

# Volume 行为：空卷 → 自动复制镜像内容
docker volume create nginx-html
docker run -v nginx-html:/usr/share/nginx/html nginx
# 空的 Volume 会自动把镜像中 /usr/share/nginx/html 的内容复制过来

# Bind Mount 行为：空目录 → 覆盖镜像内容
docker run -v /tmp/empty-html:/usr/share/nginx/html nginx
# /usr/share/nginx/html 被空目录覆盖！Nginx 没有默认页面可提供！

# Volume 不依赖宿主机目录结构
# 在 Linux、macOS、Windows 上行为一致

# Volume 可以配合 Volume Driver 使用
# 比如 NFS、Cloud 存储驱动

# 创建 NFS 数据卷
docker volume create \
  --driver local \
  --opt type=nfs \
  --opt o=addr=192.168.1.100,rw,nfsvers=4 \
  --opt device=:/share/mydata \
  nfs-volume

# docker-compose 中使用
volumes:
  shared-data:
    driver: nfs
    driver_opts:
      type: nfs
      o: "addr=192.168.1.100,rw,nfsvers=4"
      device: ":/share/mydata"

# 备份 Volume
docker run --rm \
  -v mydata:/source \
  -v $(pwd):/backup \
  alpine \
  tar czf /backup/mydata-backup.tar.gz -C /source .

# 恢复 Volume
docker run --rm \
  -v mydata:/target \
  -v $(pwd):/backup \
  alpine \
  tar xzf /backup/mydata-backup.tar.gz -C /target

# 或者使用 Volume 容器（老方式）
docker create -v mydata:/data --name datacontainer alpine
docker cp ./backup.tar.gz datacontainer:/data/

# 多个容器可以安全地共享同一个 Volume
docker volume create shared-data

# 生产者
docker run -d --name producer \
  -v shared-data:/data \
  alpine watch -n 5 'date >> /data/timestamps.txt'

# 消费者
docker run -d --name consumer \
  -v shared-data:/data \
  alpine tail -f /data/timestamps.txt

# 第三个容器也可以加入
docker run -d --name worker \
  -v shared-data:/data \
  alpine sh -c 'while true; do cat /data/timestamps.txt; sleep 10; done'

# Volume 支持多种存储后端
# 内置驱动：local（默认）
# 第三方驱动：
# - REX-Ray（多种存储阵列）
# - Portworx（分布式存储）
# - Cloudstor（云存储）
# - NetApp、EMC 等企业存储

# 例如使用 SSHFS 驱动
docker plugin install vieux/sshfs
docker volume create \
  --driver vieux/sshfs \
  -o sshcmd=user@host:/remote/path \
  -o password=secret \
  ssh-volume

# 可以在容器运行时操作 Volume
docker run -d --name app -v app-data:/data alpine sleep 3600

# 不需要停止容器即可备份
docker run --rm -v app-data:/source -v $(pwd):/backup alpine \
  tar czf /backup/app-data-backup.tar.gz -C /source .

# 或查看 Volume 使用情况
docker system df
# TYPE                TOTAL   ACTIVE  SIZE    RECLAIMABLE
# Volumes             5       3       1.2GB   800MB

# Native Linux 上 Volume 和 Bind Mount 性能差异极小
# Volume 存储在 /var/lib/docker/volumes/，底层使用同一文件系统

# 但在 macOS/Windows 上差异显著
# Bind Mount（osxfs）：性能较差，大量文件操作延迟明显
# Volume（Linux VM 内部存储）：接近原生性能

# macOS 开发环境推荐
docker run -v my-npm-cache:/root/.npm node:18 npm install  # ✅ 快
docker run -v $(pwd):/app node:18 npm install              # ❌ 慢

# 虽然有这么多优势，但 Bind Mount 在某些场景仍不可替代：

# 1. 开发热重载
docker run -v $(pwd):/app -e NODE_ENV=dev node:18 npm run dev

# 2. 配置注入
docker run -v /etc/myapp/config.yaml:/app/config.yaml:ro myapp

# 3. Socket 共享
docker run -v /var/run/docker.sock:/var/run/docker.sock docker

# 4. 日志采集
docker run -v /var/log/host:/var/log/host:ro log-collector

docker system df
docker system df -v  # 详细信息

# 1. 列出所有自定义网络
docker network ls --filter "driver=bridge" --filter "scope=local"

# 2. 导出网络详情为 JSON
for net in $(docker network ls --filter "scope=local" -q); do
  docker network inspect $net > "network-$(date +%Y%m%d)-$net.json"
done

# 3. 恢复时重新创建
# 从备份文件中读取配置
docker network create \
  --driver bridge \
  --subnet 10.0.0.0/16 \
  --gateway 10.0.0.1 \
  --ip-range 10.0.1.0/24 \
  mynet

# 1. 导出 Docker 相关的 iptables 规则
iptables-save | grep -E "DOCKER|docker0" > docker-iptables-backup.rules

# 2. 导出 NAT 表
iptables-save -t nat > docker-nat-backup.rules

# 3. 恢复
iptables-restore < docker-iptables-backup.rules
iptables-restore -t nat < docker-nat-backup.rules

# Docker daemon 的网络全局配置
# /etc/docker/daemon.json
{
  "bip": "172.17.0.1/16",
  "default-address-pools": [
    {"base": "172.20.0.0/16", "size": 24},
    {"base": "172.21.0.0/16", "size": 24}
  ],
  "iptables": true,
  "ip-forward": true,
  "ip-masq": true,
  "mtu": 1450,
  "dns": ["8.8.8.8", "114.114.114.114"]
}

# 备份
cp /etc/docker/daemon.json /backup/docker-daemon.json

# Docker 网络命名空间通常不需要单独备份
# 因为它们随容器创建和删除而管理
# 但某些特殊场景需要

# 查看网络命名空间
ls -la /var/run/docker/netns/

# 导出命名空间状态（较少使用）
ip netns list

#!/bin/bash
# backup-docker-network.sh

BACKUP_DIR="/backup/docker-network-$(date +%Y%m%d%H%M%S)"
mkdir -p $BACKUP_DIR

echo "=== 备份 Docker 网络配置 ==="

# 1. 备份所有网络定义
echo "1. 备份网络定义..."
docker network ls -q 2>/dev/null | while read net_id; do
  net_name=$(docker network inspect --format='{{.Name}}' $net_id)
  docker network inspect $net_id > "$BACKUP_DIR/network-$net_name.json"
  echo "   - 已备份网络: $net_name"
done

# 2. 备份 iptables 规则
echo "2. 备份 iptables 规则..."
iptables-save > "$BACKUP_DIR/iptables-backup.rules"
iptables-save -t nat > "$BACKUP_DIR/iptables-nat-backup.rules"

# 3. 备份 daemon.json
echo "3. 备份 Docker daemon 配置..."
[ -f /etc/docker/daemon.json ] && \
  cp /etc/docker/daemon.json "$BACKUP_DIR/daemon.json" || \
  echo "   - daemon.json 不存在"

# 4. 备份网络状态
echo "4. 生成网络状态摘要..."
echo "=== 网络列表 ===" >> "$BACKUP_DIR/network-summary.txt"
docker network ls >> "$BACKUP_DIR/network-summary.txt"
echo "" >> "$BACKUP_DIR/network-summary.txt"
echo "=== 容器网络映射 ===" >> "$BACKUP_DIR/network-summary.txt"
docker ps -q 2>/dev/null | while read cid; do
  name=$(docker inspect --format='{{.Name}}' $cid | cut -c2-)
  nets=$(docker inspect --format='{{range $k,$v := .NetworkSettings.Networks}}{{$k}} {{end}}' $cid)
  echo "$name: $nets" >> "$BACKUP_DIR/network-summary.txt"
done

echo "=== 备份完成: $BACKUP_DIR ==="

#!/bin/bash
# restore-docker-network.sh

BACKUP_DIR=$1
if [ -z "$BACKUP_DIR" ]; then
  echo "Usage: $0 "
  exit 1
fi

echo "=== 恢复 Docker 网络配置 ==="

# 1. 恢复 daemon.json
echo "1. 恢复 daemon.json..."
if [ -f "$BACKUP_DIR/daemon.json" ]; then
  cp "$BACKUP_DIR/daemon.json" /etc/docker/daemon.json
  echo "   - 已恢复，需要重启 Docker"
fi

# 2. 恢复网络定义
echo "2. 恢复自定义网络..."
for backup in $BACKUP_DIR/network-*.json; do
  [ ! -f "$backup" ] && continue
  net_name=$(basename "$backup" | sed 's/network-\(.*\)\.json/\1/')
  driver=$(jq -r '.[0].Driver' "$backup")
  subnet=$(jq -r '.[0].IPAM.Config[0].Subnet // ""' "$backup")
  gateway=$(jq -r '.[0].IPAM.Config[0].Gateway // ""' "$backup")

  if [ -n "$subnet" ]; then
    docker network create \
      --driver $driver \
      --subnet $subnet \
      --gateway $gateway \
      "$net_name" 2>/dev/null && \
      echo "   - 已恢复网络: $net_name" || \
      echo "   - 跳过已有网络: $net_name"
  else
    docker network create --driver $driver "$net_name" 2>/dev/null && \
      echo "   - 已恢复网络: $net_name"
  fi
done

# 3. 恢复 iptables 规则
echo "3. 恢复 iptables 规则..."
iptables-restore < "$BACKUP_DIR/iptables-backup.rules" 2>/dev/null
iptables-restore -t nat < "$BACKUP_DIR/iptables-nat-backup.rules" 2>/dev/null
echo "   - iptables 规则已恢复"

echo "=== 恢复完成 ==="

# 1. 默认网络（bridge、host、none）是 Docker 自动创建的
# 不需要备份，也无法删除

# 2. 容器网络连接关系需要手动重建
docker network connect mynet container-a

# 3. iptables 规则在 Docker 重启后会自动重建
# 备份主要是为了灾难恢复或迁移

# 4. Overlay 网络配置存在 Swarm 的持久化存储中
# 备份需要额外处理（备份 Swarm 状态）

# 5. 修改 daemon.json 后必须重启 Docker
systemctl restart docker

# 将网络配置迁移到另一台宿主机

# 1. 备份源机器
./backup-docker-network.sh
scp -r /backup/docker-network-* new-host:/backup/

# 2. 在新机器上恢复（先安装 Docker）
./restore-docker-network.sh /backup/docker-network-xxxxxxxx/

# 3. 创建容器并连接网络
docker run -d --name web --network mynet nginx
docker run -d --name db --network mynet postgres

# 网络元数据存储在
ls -la /var/lib/docker/network/files/
# 包含每个网络的定义文件

-- 与业务方确认以下问题：
-- 1. 丢失多久的数据可以接受？（RPO）
-- 2. 恢复要多快？（RTO）
-- 3. 哪些表/库最重要？
-- 4. 是否要跨地域容灾？

-- 数据量
SELECT 
  ROUND(SUM(data_length + index_length) / 1024 / 1024 / 1024, 2) AS size_gb
FROM information_schema.tables;

-- 写入量
SHOW GLOBAL STATUS LIKE 'Com_insert%';
SHOW GLOBAL STATUS LIKE 'Com_update%';

-- 数据变更频率
SHOW BINARY LOGS;  -- 看 Binlog 生成速度

# 典型方案：全量 + 增量 + Binlog
# 全量备份：物理备份（xtrabackup）
# 增量备份：xtrabackup 增量
# 实时备份：Binlog 同步

# 1. 全量备份：每天凌晨 2:00（xtrabackup）
# 2. 增量备份：每 6 小时
# 3. 实时 Binlog：同步到备份服务器
# 4. 异地备份：每天同步到异地对象存储

# cron 配置
0 2 * * 0  /usr/bin/xtrabackup --backup --target-dir=/backup/full/\$(date +\%Y\%m\%d)    # 周日全量
0 2 * * 1-6  /usr/bin/xtrabackup --backup --target-dir=/backup/inc/\$(date +\%Y\%m\%d) --incremental-basedir=/backup/full/\$(date +\%Y\%m\%d -d 'last sunday')  # 其他天增量
* * * * *  /usr/bin/mysqlbinlog --raw --read-from-remote-server --host=localhost mysql-bin.* > /backup/binlog/  # Binlog 实时同步

故障 → 恢复最近的全量备份
     → 合并最近的增量备份
     → 重放 Binlog 到故障发生前的最后一条事务

# 1. 全量备份：每天（mysqldump + gzip）
# 2. Binlog 保留 3 天

# cron 配置
0 3 * * * mysqldump --single-transaction --all-databases | gzip > /backup/full_\$(date +\%Y\%m\%d).sql.gz
0 0 * * * mysql -e "PURGE BINARY LOGS BEFORE DATE_SUB(NOW(), INTERVAL 3 DAY)"

# 1. 全量备份：每周 1 次（xtrabackup + 压缩）
# 2. 增量备份：每天
# 3. 不需要 Binlog（RPO 要求不高）

0 2 * * 0 /usr/bin/xtrabackup --backup --compress --parallel=4 --target-dir=/backup/full/\$(date +\%Y\%m\%d)
0 2 * * 1-6 /usr/bin/xtrabackup --backup --incremental-basedir=/backup/full/\$(date +\%Y\%m\%d -d 'last sunday') --target-dir=/backup/inc/\$(date +\%Y\%m\%d)

3 份副本：至少保留 3 份备份
2 种介质：备份存储在至少 2 种不同介质上（如本地磁盘 + 对象存储）
1 份异地：至少 1 份备份存储在异地

# 本地副本 1（SSD 磁盘）
/backup/local/

# 本地副本 2（另一块磁盘或 NAS）
/backup/nas/

# 异地副本（对象存储）
aws s3 sync /backup/ s3://my-db-backup/

# 或者从备份服务器自动同步
rsync -avz /backup/ backup_server:/backup/

# backup_config.yaml
database:
  host: localhost
  port: 3306

backup:
  base_dir: /backup/mysql
  full_backup_day: sunday
  full_backup_time: "02:00"
  incremental_backup: true
  incremental_interval_hours: 6

retention:
  full_backup_keep: 30  # 保留 30 天全量
  incremental_keep: 14  # 保留 14 天增量
  binlog_keep_days: 7

remote:
  enabled: true
  type: s3  # oss, s3, scp
  bucket: my-db-backup
  region: cn-north-1

verify:
  quick_check: true  # 备份后自动 L1 验证
  full_verify_interval_days: 30  # 每月 L3 验证

#!/bin/bash
# backup_monitor.sh

# 1. 检查备份是否按时完成
LAST_FULL=$(ls -la /backup/full/* 2>/dev/null | tail -1 | awk '{print $6, $7}')
if [ -z "$LAST_FULL" ]; then
  echo "❌ 最近 24 小时内没有全量备份"
  exit 2
fi

# 2. 检查备份大小是否异常
BACKUP_SIZE=$(du -sch /backup/full/ 2>/dev/null | grep total | awk '{print $1}')
echo "当前备份大小：$BACKUP_SIZE"

# 3. 检查最近 Binlog 是否同步成功
LATEST_BINLOG=$(ls -t /backup/binlog/ 2>/dev/null | head -1)
if [ -z "$LATEST_BINLOG" ]; then
  echo "❌ Binlog 同步失败"
  exit 2
fi

# 4. 检查磁盘空间
DISK_USAGE=$(df -h /backup | tail -1 | awk '{print $5}' | sed 's/%//')
if [ $DISK_USAGE -gt 85 ]; then
  echo "⚠️ 备份磁盘使用率：$DISK_USAGE%"
fi

echo "✅ 备份监控检查通过"

100GB  数据库：全量备份 ≈ 30-60 分钟
1TB    数据库：全量备份 ≈ 5-10 小时
10TB   数据库：全量备份 ≈ 2-3 天

# xtrabackup 支持并行复制
xtrabackup --backup \
  --target-dir=/backup/full \
  --parallel=4          # 4 个并发线程复制数据文件

# mysqlpump（MySQL 5.7+）支持并行导出
mysqlpump \
  --parallel-schemas=4:mydb \
  --default-parallelism=4 \
  --output=/backup/mydb_pump.sql

# xtrabackup 内置压缩
xtrabackup --backup \
  --compress \
  --compress-threads=4 \
  --target-dir=/backup/compressed

# mysqldump + 管道压缩
mysqldump --single-transaction mydb | gzip > /backup/mydb.sql.gz

# 使用更快的压缩算法
mysqldump --single-transaction mydb | zstd -c > /backup/mydb.sql.zst

# 全量备份（周日）
xtrabackup --backup --target-dir=/backup/full_sun

# 每日增量
xtrabackup --backup \
  --incremental-basedir=/backup/full_sun \
  --target-dir=/backup/inc_mon

# 增量备份通常比全量小 90-99%

# 边备份边传输，避免中间文件
xtrabackup --backup --stream=xbstream | \
  pigz -c | \
  ssh remote_srv "cat > /backup/db_$(date +%Y%m%d).xbstream.gz"

# pigz 是 gzip 的并行版本

# mysqldump 忽略大日志表
mysqldump --ignore-table=mydb.audit_log mydb > /backup/mydb.sql

# xtrabackup 排除特定表
xtrabackup --backup --tables-exclude='mydb\.audit_log|mydb\.temp_data'

# xtrabackup 并行 Prepare（MySQL 8.0 支持）
xtrabackup --prepare \
  --target-dir=/backup/full \
  --use-memory=4G \
  --parallel=4

# 恢复时关闭 Binlog 和双写
# 修改恢复实例的 my.cnf
skip-log-bin
innodb_doublewrite = 0  # 恢复完成后需要改回

# 恢复过程增大 Buffer Pool
# 恢复实例设置
innodb_buffer_pool_size = 32G  # 尽量分配大内存

# 恢复时的配置
innodb_io_capacity = 10000     # 允许更多 IO
innodb_io_capacity_max = 20000
innodb_flush_log_at_trx_commit = 2  # 减少 fsync
sync_binlog = 0                 # 如果开启 Binlog
innodb_log_file_size = 4G       # 大 Redo Log

-- 分割 SQL 文件后并行导入
# 分割 SQL 文件
csplit -z -f /tmp/table_ /backup/mydb.sql '/^DROP TABLE IF EXISTS/' '{*}'

# 并行导入
for f in /tmp/table_*; do
  mysql mydb < $f &
done
wait

# 使用 NVMe SSD 或 RAID 10
# 恢复时用 tmpfs 加速
# 注意：tmpfs 重启后数据丢失，恢复完成需立即同步

# 准备一台高性能恢复机器
# CPU：更多核心
# 内存：更大 Buffer Pool
# 磁盘：NVMe SSD
# 网络：万兆网卡（传输备份）

生产 MySQL → xtrabackup 增量备份 → 备份服务器
                                  → 压缩存储（对象存储/磁带）
                                  → 异地备份
                                  → 恢复演练环境

每日增量（周一至周六）→ 每周全量（周日）
每小时 Binlog 实时同步

-- 指定算法和锁级别
ALTER TABLE users ADD COLUMN age INT,
  ALGORITHM=INPLACE,
  LOCK=NONE;

-- 查看 DDL 进度
SHOW PROCESSLIST;

-- 即时添加列（不占用额外磁盘，不阻塞）
ALTER TABLE users ADD COLUMN age INT, ALGORITHM=INSTANT;

-- 即时删除列默认值
ALTER TABLE users ALTER COLUMN age DROP DEFAULT, ALGORITHM=INSTANT;

# pt-osc 原理：创建影子表 → 同步数据 → swap 表名
pt-online-schema-change \
  h=localhost,u=root,p=password,D=mydb,t=users \
  --alter "ADD COLUMN age INT" \
  --execute

gh-ost \
  --user="root" \
  --password="password" \
  --host="localhost" \
  --database="mydb" \
  --table="users" \
  --alter="ADD COLUMN age INT" \
  --execute

-- 如果在线 DDL 运行时进行备份
-- 备份可能捕获到新旧两张表的数据

事务备份开始 → 读快照 A（含列 name）
DDL → ALTER TABLE users DROP COLUMN name
备份继续 → 试图读 name 列 → 报错"Unknown column 'name'"

备份表 users → 含列 a,b,c（ddl 前版本）
DDL → ADD COLUMN d
备份表 orders → 含列 x,y,z
DDL → DROP COLUMN y
备份表 products → 含列 p,q

# 定时任务
00:00 - 全量备份（xtrabackup）
01:00 - 01:30 - DDL 维护窗口
02:00 - 增量备份（确保 DDL 变更被捕获）

# 1. 开始 DDL
pt-online-schema-change --alter "ADD INDEX idx_email(email)" --execute

# 2. DDL 完成后立即进行增量备份
xtrabackup --backup --incremental-basedir=/backup/full --target-dir=/backup/inc_ddl

# DDL 前备份
mysqldump --single-transaction --master-data=2 mydb > before_ddl.sql

# 执行 DDL
mysql -e "ALTER TABLE mydb.users ADD INDEX..."

# DDL 后备份
mysqldump --single-transaction --master-data=2 mydb > after_ddl.sql

# 在 pt-osc 执行前先验证备份是否存在
pt-online-schema-change \
  --check-alter \
  --alter "ADD COLUMN age INT" \
  --execute 2>&1 | grep -i "backup"

-- 查看是否有正在执行的 DDL
SELECT * FROM performance_schema.events_statements_current
WHERE SQL_TEXT LIKE 'ALTER%' OR SQL_TEXT LIKE 'CREATE INDEX%';

-- 查看是否有表正在重建
SELECT * FROM information_schema.INNODB_ALTER_TABLE_PROGRESS;

#!/bin/bash
# ddl_with_backup.sh

DB="mydb"
TABLE="users"
ALTER_SQL="ADD COLUMN age INT DEFAULT 0 AFTER name"

echo "=== 步骤 1: 检查当前备份时间 ==="
ls -la /backup/full/ | tail -5

echo "=== 步骤 2: 记录 DDL 前备份位置 ==="
mysql -e "SHOW MASTER STATUS" > /tmp/ddl_before_position.txt

echo "=== 步骤 3: 执行 DDL ==="
mysql -e "ALTER TABLE $DB.$TABLE $ALTER_SQL, ALGORITHM=INPLACE, LOCK=NONE"
echo "DDL 完成: $(date)"

echo "=== 步骤 4: DDL 后立即做增量备份 ==="
xtrabackup --backup \
  --incremental-basedir=/backup/full \
  --target-dir=/backup/inc_$(date +%Y%m%d_%H%M)

echo "=== 步骤 5: 记录 DDL 后备份位置 ==="
mysql -e "SHOW MASTER STATUS" > /tmp/ddl_after_position.txt

echo "✅ 完成：DDL 后增量备份已创建"

每周：L0 + L1 快速检查
每月：L2 逻辑检查
每季度：L3 完整恢复验证

#!/bin/bash
# 检查备份文件是否存在且非空

BACKUP_DIR="/backup/mysql"
TODAY=$(date +%Y%m%d)

# 检查全量备份
if [ -f "$BACKUP_DIR/full_$TODAY.xbstream.gz" ]; then
    FILE_SIZE=$(stat -c%s "$BACKUP_DIR/full_$TODAY.xbstream.gz")
    if [ $FILE_SIZE -gt 1000000 ]; then  # > 1MB
        echo "✅ 全量备份文件存在，大小：$FILE_SIZE 字节"
    else
        echo "❌ 全量备份文件过小：$FILE_SIZE 字节"
        exit 1
    fi
else
    echo "❌ 全量备份文件不存在"
    exit 1
fi

# 备份时计算校验和
md5sum /backup/mydb_20250615.sql.gz > /backup/mydb_20250615.sql.gz.md5

# 验证时比对
md5sum -c /backup/mydb_20250615.sql.gz.md5

# 校验压缩文件完整性（不实际解压）
gzip -t /backup/mydb_20250615.sql.gz
echo $?  # 0 = 正常，非 0 = 损坏

# xtrabackup 备份验证
# 尝试 Prepare（但回滚事务可以继续使用 prepare --apply-log-only）
xtrabackup --prepare --target-dir=/backup/full 2>&1 | tail -10

# 检查 xtrabackup_checkpoints
cat /backup/full/xtrabackup_checkpoints

# 检查 Binlog 文件是否可读
mysqlbinlog /var/lib/mysql/mysql-bin.000123 > /dev/null 2>&1
if [ $? -eq 0 ]; then
    echo "✅ Binlog 文件完整性良好"
else
    echo "❌ Binlog 文件损坏"
fi

# 检查 mysqldump 文件头部
head -50 mydb.sql | grep -q "CREATE TABLE"
if [ $? -eq 0 ]; then
    echo "✅ 备份文件包含有效的 CREATE TABLE 语句"
fi

# 检查备份文件行数（太小可能不全）
echo "SQL 文件行数：$(wc -l < mydb.sql)"

# 检查结尾是否完整
tail -20 mydb.sql | grep -q "Dump completed"
if [ $? -eq 0 ]; then
    echo "✅ 备份文件结尾完整"
fi

# 检查表数量
grep -c "CREATE TABLE" mydb.sql

# 查看备份中包含哪些表
ls -la /backup/full/mydb/*.ibd | wc -l

# 检查 binlog 位置记录
cat /backup/full/xtrabackup_binlog_info

# 检查备份元信息
cat /backup/full/xtrabackup_info | grep -E "start_time|end_time|binlog_pos|uuid"

# 不执行，仅检查 SQL 语法的正确性
mysql -u root -p --force < /dev/null 2>&1
# 或者用 pt-find
pt-find --host=localhost --user=root --password=xxx

# 最直接的检查：尝试导入到临时数据库
mysql -e "CREATE DATABASE IF NOT EXISTS verify_backup"
mysql mydb_verify < mydb.sql 2>&1 | grep -i error
mysql -e "DROP DATABASE IF EXISTS verify_backup"

#!/bin/bash
# verify_and_restore.sh — 安全验证备份文件

BACKUP_FILE=$1
DB_NAME="verify_$(date +%s)"
MYSQL_CMD="mysql -u root -p'$MYSQL_ROOT_PASSWORD'"

echo "=== 开始验证备份文件 ==="
echo "备份文件：$BACKUP_FILE"

# 1. 创建临时数据库
$MYSQL_CMD -e "CREATE DATABASE $DB_NAME"

# 2. 恢复备份到临时数据库
case "$BACKUP_FILE" in
  *.sql.gz)
    gunzip -c $BACKUP_FILE | $MYSQL_CMD $DB_NAME
    ;;
  *.sql)
    $MYSQL_CMD $DB_NAME < $BACKUP_FILE
    ;;
  *.xbstream*)
    # xtrabackup 恢复需要先 Prepare 再 copy-back
    # 建议使用独立的 MySQL 实例
    echo "xtrabackup 恢复请使用独立环境"
    exit 1
    ;;
  *)
    echo "未知备份格式"
    exit 1
esac

# 3. 验证数据
echo "=== 数据验证 ==="
$MYSQL_CMD -e "
  SELECT '表总数' as '检查项', COUNT(*) as '结果'
  FROM information_schema.tables
  WHERE table_schema = '$DB_NAME';
"

# 4. 检查特定表的数据
$MYSQL_CMD $DB_NAME -e "
  SELECT 'users表' as '表名', COUNT(*) as '行数' FROM users;
  SELECT 'orders表' as '表名', COUNT(*) as '行数' FROM orders;
"

# 5. 检查索引
$MYSQL_CMD -e "
  SELECT TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
  FROM information_schema.STATISTICS
  WHERE TABLE_SCHEMA = '$DB_NAME';
"

# 6. 清理临时数据库
$MYSQL_CMD -e "DROP DATABASE $DB_NAME"

echo "=== 验证完成 ==="

# 校验恢复后的数据与源数据是否一致
pt-table-checksum \
  h=recovery_host,u=root,p=password \
  --databases=mydb \
  --tables=users,orders

# 回放以前的生产流量验证
percona-playback \
  --mysql-host=localhost \
  --mysql-password=xxx \
  --workload-file=/tmp/general.log

生产环境备份文件 → 传输到演练环境 → 执行恢复 → 验证数据 → 清理环境

# 1. 启动临时 MySQL 容器
docker run -d \
  --name mysql_recovery_test \
  -e MYSQL_ROOT_PASSWORD=test123 \
  -v /backup:/backup:ro \
  -p 3307:3306 \
  mysql:8.0

# 2. 进入容器
docker exec -it mysql_recovery_test bash

# 3. 使用 mysqldump 备份恢复
mysql -u root -p test123 < /backup/mydb_20250615.sql

# 4. 使用 xtrabackup 备份恢复
apt-get update && apt-get install -y percona-xtrabackup-80
xtrabackup --copy-back --target-dir=/backup/xtrabackup_full/
chown -R mysql:mysql /var/lib/mysql/

# 1. 准备 MySQL 二进制包
wget https://dev.mysql.com/get/Downloads/MySQL-8.0/mysql-8.0.35-linux-glibc2.28-x86_64.tar.xz
tar xf mysql-8.0.35-*.tar.xz -C /usr/local/
mv /usr/local/mysql-8.0.35-* /usr/local/mysql_recovery

# 2. 创建数据目录
mkdir -p /data/mysql_recovery_data
chown -R mysql:mysql /data/mysql_recovery_data

# 3. 初始化数据目录
/usr/local/mysql_recovery/bin/mysqld \
  --initialize-insecure \
  --datadir=/data/mysql_recovery_data \
  --user=mysql

# 4. 启动临时实例
/usr/local/mysql_recovery/bin/mysqld \
  --datadir=/data/mysql_recovery_data \
  --port=3308 \
  --socket=/tmp/mysql_recovery.sock \
  --user=mysql \
  --skip-log-bin &

# 5. 恢复备份
/usr/local/mysql_recovery/bin/mysql \
  -S /tmp/mysql_recovery.sock \
  -u root < /backup/mydb.sql

# 6. 验证数据
/usr/local/mysql_recovery/bin/mysql \
  -S /tmp/mysql_recovery.sock \
  -u root -e "SELECT COUNT(*) FROM mydb.users"

# 7. 清理
kill `cat /data/mysql_recovery_data/*.pid`
rm -rf /data/mysql_recovery_data

备份服务器（存储备份文件）
     |
     | rsync / scp / s3
     ↓
演练服务器（独立的 MySQL 实例）

#!/bin/bash
# recover_test.sh — 自动恢复验证脚本

BACKUP_FILE=$1
RECOVERY_SERVER="10.0.1.200"

# 1. 传输备份
rsync -avz /backup/$BACKUP_FILE mysql@$RECOVERY_SERVER:/tmp/

# 2. 在恢复服务器上执行恢复
ssh mysql@$RECOVERY_SERVER << 'REMOTE'
  # 停止正在运行的 MySQL
  systemctl stop mysql
  rm -rf /var/lib/mysql/*

  # 恢复备份
  if [[ "$BACKUP_FILE" == *.sql ]]; then
    # mysqldump 恢复
    mysqld_safe --skip-grant-tables & 
    sleep 3
    mysql -u root < /tmp/$BACKUP_FILE
  elif [[ "$BACKUP_FILE" == *.xbstream ]]; then
    # xtrabackup 恢复
    xtrabackup --prepare --target-dir=/tmp/backup/
    xtrabackup --copy-back --target-dir=/tmp/backup/
    chown -R mysql:mysql /var/lib/mysql/
  fi

  systemctl start mysql
REMOTE

# 3. 验证
ssh mysql@$RECOVERY_SERVER "mysql -e 'CHECK TABLE mydb.users; SHOW TABLES;'"

#!/bin/bash
# pitr_test.sh

# 模拟场景：数据库恢复到 "2025-06-15 14:59:59"

FULL_BACKUP_DIR="/backup/full/20250614"
BINLOG_DIR="/backup/binlog"
RECOVERY_TIME="2025-06-15 14:59:59"

# 1. 准备恢复实例
docker run -d --name pitr_test mysql:8.0

# 2. 恢复全量备份
docker cp $FULL_BACKUP_DIR pitr_test:/tmp/full_backup
docker exec pitr_test bash -c "cd /tmp/full_backup && xtrabackup --prepare --target-dir=."
docker exec pitr_test bash -c "rm -rf /var/lib/mysql/* && xtrabackup --copy-back --target-dir=/tmp/full_backup"
docker exec pitr_test bash -c "chown -R mysql:mysql /var/lib/mysql"

# 3. 获取全量备份的 Binlog 位置
BINLOG_POS=$(cat $FULL_BACKUP_DIR/xtrabackup_binlog_info | awk '{print $2}')

# 4. 应用 Binlog 到目标时间点
docker cp $BINLOG_DIR pitr_test:/tmp/binlog
docker exec pitr_test bash -c "
  mysqlbinlog \
    --start-position=$BINLOG_POS \
    --stop-datetime='$RECOVERY_TIME' \
    /tmp/binlog/mysql-bin.* | mysql -u root
"

# 5. 验证数据
docker exec pitr_test mysql -u root -e "SELECT COUNT(*) FROM mydb.orders"
echo "PITR 恢复完成，请验证数据准确性"

-- 检查表和字段数量是否一致
SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'mydb';

-- 检查自增 ID 最大值
SELECT MAX(id) FROM mydb.orders;

-- 行数对比
SELECT COUNT(*) FROM mydb.orders;

-- 关键业务指标
SELECT SUM(amount) FROM mydb.orders WHERE status = 'completed';

-- 检查约束是否有效
SELECT * FROM mydb.orders WHERE status NOT IN ('pending','paid','shipped','delivered','cancelled');

-- 简单查询走索引
EXPLAIN SELECT * FROM mydb.orders WHERE id = 1;

-- 检查索引状态
SHOW INDEX FROM mydb.orders;

#!/usr/bin/env python3
# verify_backup.py

import pymysql
import sys

def verify_backup(host, user, password, db):
    conn = pymysql.connect(host=host, user=user, passwd=password, db=db)
    cursor = conn.cursor()

    checks = [
        ("表数量", "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = %s"),
        ("用户数", "SELECT COUNT(*) FROM users"),
        ("订单数", "SELECT COUNT(*) FROM orders"),
        ("最大订单金额", "SELECT MAX(amount) FROM orders"),
    ]

    all_ok = True
    for name, sql in checks:
        cursor.execute(sql, (db,))
        result = cursor.fetchone()[0]
        print(f"{name}: {result}")
        if result is None or result == 0:
            print(f"  ⚠️  {name} 异常！")
            all_ok = False

    cursor.close()
    conn.close()

    if all_ok:
        print("✅ 备份验证通过")
    else:
        print("❌ 备份验证失败")
        sys.exit(1)

if __name__ == "__main__":
    verify_backup("localhost", "root", "password", "mydb")

1. 增量备份的基础：记录全量备份之后的所有变更
2. PITR 的核心：通过重放 Binlog 恢复到任意时间点
3. 主从复制的载体：从库通过读取 Binlog 同步主库变更

写入流程：
事务提交 → 写入 Binlog（追加到文件末尾，顺序写）
        → 写入完成 → 返回成功

-- 查看所有 Binlog 文件
SHOW BINARY LOGS;

-- 切换到下一个 Binlog 文件
FLUSH LOGS;

-- 设置保留时间
-- 5.7
SET GLOBAL expire_logs_days = 7;
-- 8.0
SET GLOBAL binlog_expire_logs_seconds = 604800;

# Row 格式（默认，推荐）
binlog_format = ROW
# 记录每一行数据的变更前和变更后值
# 优点：精确恢复单行、兼容性好
# 缺点：文件大

# Statement 格式（5.7 之前默认）
# 记录执行的 SQL 语句
# 优点：文件小
# 缺点：函数如 NOW() 可能导致主从数据不一致

# Mixed 格式
# 混合模式，MySQL 自动选择
# 确定性操作用 Statement，不确定性用 Row

# 备份 Binlog 文件
cp /var/lib/mysql/mysql-bin.000001 /backup/binlog/
cp /var/lib/mysql/mysql-bin.000002 /backup/binlog/
# ...

# 恢复时（先恢复全量备份）
mysqlbinlog mysql-bin.000001 mysql-bin.000002 | mysql -u root -p

# 1. 全量备份（周一）
xtrabackup --backup --target-dir=/backup/full

# 2. 增量备份（周二）
xtrabackup --backup --incremental-basedir=/backup/full \
           --target-dir=/backup/inc1

# 3. 如果周二 15:00 发生故障
# 恢复到周二的增量备份 + 重放周二 15:00 前的 Binlog

# 使用 mysqlbinlog 的远程同步功能
mysqlbinlog --read-from-remote-server \
            --host=master_host \
            --user=repl \
            --password=xxx \
            --raw \
            --stop-never \
            mysql-bin.000001 | \
  gzip > /backup/binlog_server/binlog.$(date +%Y%m%d%H%M%S).gz

时间线：
14:00 → 全量备份完成
14:01 → 开始产生新的 Binlog（mysql-bin.000050）
15:30 → 误操作发生

恢复步骤：
1. 恢复 14:00 的全量备份 → 恢复到 14:00 状态
2. 应用 Binlog(mysql-bin.000050) 从 14:00 到 15:29:59
3. 数据库恢复到 15:29:59 的状态（误操作前）

# 确认全量备份的 Binlog 位置
cat /backup/full/xtrabackup_binlog_info
# 输出：mysql-bin.000049 438945618

# 应用增量备份后的 Binlog（从全量备份完成后开始）
mysqlbinlog \
  --start-position=438945618 \
  --stop-datetime="2025-06-15 15:29:59" \
  /var/lib/mysql/mysql-bin.000050 \
  /var/lib/mysql/mysql-bin.000051 \
  | mysql -u root -p

# 每天将 Binlog 同步到远程服务器
rsync -avz /var/lib/mysql/mysql-bin.* backup_server:/backup/binlog/

# 或使用对象存储
tar czf - /var/lib/mysql/mysql-bin.* | \
  s3cmd put - s3://my-bucket/binlog/$(date +%Y%m%d).tar.gz

# 使用 SSL 加密传输 Binlog 备份
mysqlbinlog \
  --read-from-remote-server \
  --ssl-mode=REQUIRED \
  --raw \
  --host=master_host \
  mysql-bin.*

-- 防止磁盘写满
-- 保留 7 天
SET GLOBAL binlog_expire_logs_seconds = 604800;

-- 手动清理（谨慎！）
PURGE BINARY LOGS BEFORE '2025-06-08 00:00:00';
PURGE BINARY LOGS TO 'mysql-bin.000100';

-- Binlog 文件列表和大小
SHOW BINARY LOGS;

-- 当前正在写入的 Binlog
SHOW MASTER STATUS;

-- Binlog 写入量
SHOW GLOBAL STATUS LIKE 'Binlog_%';

-- 重要指标
Binlog_cache_use         -- 事务写入 Binlog 缓存的次数
Binlog_cache_disk_use    -- 事务写入磁盘 Binlog 缓存的次数
Binlog_bytes_written     -- 总写入字节数

[mysqld]
# Binlog 配置
log_bin = mysql-bin
binlog_format = ROW
binlog_row_image = FULL
expire_logs_days = 7          # 5.7
# binlog_expire_logs_seconds = 604800  # 8.0
max_binlog_size = 1G          # 每个 Binlog 文件大小

# 全量备份策略
# 每天凌晨 2:00 全量备份（使用 xtrabackup）
# Binlog 实时同步到备份服务器

# 恢复考验
# 每季度至少一次 PITR 演练

阶段一：复制数据文件（可能不一致）
         ↓
阶段二：同步 Redo Log（使数据一致）

1. 启动备份，记录当前 LSN（Log Sequence Number）
2. 后台线程持续监控 Redo Log 的写入
3. 前台线程开始复制 InnoDB 数据文件（.ibd）
   ── 此时复制的文件是"时间点快照"——可能有部分页正在被 Redo，所以不一致
4. 复制完成后，停止监控 Redo Log
5. 对 MyISAM 表加读锁，复制 MyISAM 数据
6. 记录 Binlog 位置（用于 PITR）
7. 释放锁

至此，备份完成。但数据文件内部可能不一致。
需要执行 --prepare 来"重放"Redo Log，使数据文件达到一致状态。