基于 Docker 部署的 MySQL 备份操作

原创已于 2025-11-05 09:19:40 修改 · 249 阅读

5 ·

CC 4.0 BY-SA版权

删除

文章标签：

#docker #mysql #容器

于 2025-11-03 15:37:23 首次发布

一、基础环境说明

宿主机系统：CentOS/RHEL 系统（需 root 权限）MySQL 部署方式：Docker 容器（后续步骤查询容器名称、获取数据卷路径）已知信息：MySQL root 密码（示例：123456）

二、mysqldump 备份方案（逻辑备份）

1. 安装 mysqldump（宿主机操作）

bash

# 安装 MySQL 客户端（含 mysqldump）
yum install -y mysql

# 验证安装（输出版本信息即为成功）
mysqldump --version

2. 步骤 1：查询 Docker MySQL 容器名称

bash

# 列出运行中容器，获取 MySQL 容器名（示例容器名：mysql）
docker ps
# 输出示例：
# CONTAINER ID   IMAGE       COMMAND                  CREATED       STATUS          PORTS                                                  NAMES
# 4a2e67d1bf7c   mysql:5.7   "docker-entrypoint.s…"   4 hours ago   Up 55 minutes   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   mysql
# 记录 NAMES 列值，后续用 <容器名> 指代（示例：<容器名>=mysql）

3. 步骤 2：获取 Docker 数据卷宿主机路径

bash

# 替换 <容器名>，查询数据卷挂载信息
docker inspect <容器名> | grep "Mounts" -A 30
# 关键输出（记录 Source 字段值，记为 $VOLUME_PATH）：
# "Source": "/var/lib/docker/volumes/0085dc410d85d076e3a18fc6f738a11965c06fc8899f660bafb66861f2aea983/_data"
# 示例：
VOLUME_PATH=/var/lib/docker/volumes/0085dc410d85d076e3a18fc6f738a11965c06fc8899f660bafb66861f2aea983/_data

4. 步骤 3：创建 MySQL 备份用户并授权

bash

# 1. 进入容器内 MySQL（输入 root 密码 123456）
docker exec -it <容器名> mysql -u root -p123456

# 2. 创建备份用户 admin（密码 123，允许所有地址连接）
mysql> grant reload,process,lock tables,replication client on *.* to 'admin'@'%' identified by '123';
# 在mysql5.7之后的版本不允许这样操作，可以执行下面的操作
mysql> create user 'admin'@'%' identified by '123';
mysql> grant reload,process,lock tables,replication client on *.* to 'admin'@'%';

# 3. 刷新权限
mysql> flush privileges;

# 4. 验证用户（输出 user:admin, host:% 即为成功）
mysql> select user,host from mysql.user where user='admin';

# 5. 退出 MySQL 和容器
mysql> exit;

5. 步骤 4：全量备份（保存路径 /tmp/sqlbak）

bash

# 1. 创建全量备份目录（按要求改为 /tmp/sqlbak）
mkdir -p /tmp/sqlbak
chmod 700 /tmp/sqlbak  # 收紧权限，仅 root 可读写

# 2. 执行全量备份（备份所有数据库到 /tmp/sqlbak）
mysqldump -h 127.0.0.1 \
  -P 3306 \
  -u admin \
  -p123 \
  --all-databases \
  --single-transaction \  # 保证 InnoDB 一致性
  --routines \
  --triggers \
  --events \
  > /tmp/sqlbak/full_backup_$(date +%Y%m%d_%H%M%S).sql  # 带时间戳，避免覆盖

（3）验证全量备份是否成功（mysqldump 专用）

bash

# 1. 确认备份文件存在且非空（基础验证）
ls /tmp/sqlbak
# 先获取备份文件名（替换 <备份时间戳> 为实际生成的时间，如 20251103_180000）
BACKUP_FILE="/tmp/sqlbak/full_backup_<备份时间戳>.sql"
ls -lh $BACKUP_FILE
# 成功标志：文件大小 > 0（如 1.5M，根据数据量不同大小不一），无 "No such file or directory" 错误

# 2. 检查备份文件头部信息（确认备份参数正确）
head -n 20 $BACKUP_FILE
# 关键信息需包含：
# - /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;（标准 SQL 备份头）
# - -- Databases: 列出所有数据库（如 mysql、sys、业务库 test 等）
# - -- mysqldump 版本信息（与安装版本一致）

# 3. 检查备份文件尾部信息（确认备份正常结束）
tail -n 10 $BACKUP_FILE
# 成功标志：包含 "/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;"（标准结束符），无 "error" 或 "aborted" 等错误关键词

# 4. 验证数据完整性（核心步骤：通过导入测试库检查）
# 4.1 创建临时测试库（避免影响生产数据）
docker exec -it <容器名> mysql -u root -p123456 -e "create database if not exists test_restore;"

# 4.2 将备份文件导入临时库（验证能否正常解析）
cat $BACKUP_FILE | docker exec -i <容器名> mysql -u admin -p123 test_restore
# 若执行无报错（无 "syntax error" 等提示），说明备份文件语法正确

# 4.3 检查关键表数据（以 mysql.user 为例，验证系统库数据）
docker exec -it <容器名> mysql -u admin -p123 -e "select user,host from test_restore.mysql.user;"
# 成功标志：输出包含 admin@%、root@localhost 等用户（与生产库一致）

# 4.4 清理临时库（避免占用空间）
docker exec -it <容器名> mysql -u root -p123456 -e "drop database test_restore;"

（4）数据库损坏恢复示例（以误删 test 数据库为例）

假设误删了业务核心数据库test（该数据库已包含在全量备份中，库内有user表，字段为id和name），需通过全量备份恢复：

bash

# 1. 确认数据库已丢失（验证故障场景）
docker exec -it <容器名> mysql -u admin -p123 -e "show databases like 'test';"
# 若输出结果为空，说明数据库已被删除

# 2. 定位全量备份文件（替换 <备份时间戳> 为实际备份生成的时间，如 20251103_180000）
BACKUP_FILE="/tmp/sqlbak/full_backup_<备份时间戳>.sql"

# 3. 从全量备份中提取指定数据库（仅恢复 test，避免覆盖其他正常数据库）
# 筛选备份文件中 test 数据库的相关 SQL 语句（从库创建到表结构/数据）
sed -n '/^-- Current Database: `test`/,/^-- Current Database: `/p' $BACKUP_FILE > /tmp/test_restore.sql

# 4. 执行恢复操作（将提取的 SQL 导入 MySQL）
cat /tmp/test_restore.sql | docker exec -i <容器名> mysql -u admin -p123

# 5. 验证恢复结果
# 5.1 确认数据库已重建
docker exec -it <容器名> mysql -u admin -p123 -e "show databases like 'test';"
# 5.2 确认核心表及数据完整（以 test 下的 user 表为例）
docker exec -it <容器名> mysql -u admin -p123 -e "select count(*) from test.user;"
# 成功标志：表数据量与备份前一致（如输出 count(*) = 2，与备份前 test.user 表数据量匹配）

# 6. 清理临时文件（避免占用宿主机空间）
rm -f /tmp/test_restore.sql

6. 步骤 5：增量备份（基于二进制日志）

（1）开启容器 MySQL 二进制日志

bash

# 1. 进入容器 bash 终端
docker exec -it <容器名> /bin/bash

# 2. 安装编辑器（MySQL 5.7 容器基于 Debian，使用 apt）
apt update && apt install -y vim

# 3. 编辑 MySQL 配置文件
vim /etc/mysql/mysql.conf.d/mysqld.cnf

# 4. 添加配置（[mysqld] 段落内）
log_bin = /var/lib/mysql/mysql-bin
server-id = 1
expire_logs_days = 7

# 5. 保存退出（Esc → :wq），退出容器
exit

# 6. 重启容器生效
docker restart <容器名>

# 7. 验证日志开启（输出 Value: ON）
docker exec -it <容器名> mysql -u admin -p123 -e "show variables like 'log_bin';"

（2）首次全量备份（记录日志位置）

bash

# 1. 创建增量备份目录（自定义路径，示例 /tmp/sqlbak_incr）
mkdir -p /tmp/sqlbak_incr
chmod 700 /tmp/sqlbak_incr  # 收紧权限

# 2. 执行全量备份并记录日志位置
mysqldump -h 127.0.0.1 \
  -P 3306 \
  -u admin \
  -p123 \
  --all-databases \
  --single-transaction \
  --flush-logs \
  --master-data=2 \
  > /tmp/sqlbak/initial_full_backup_$(date +%Y%m%d_%H%M%S).sql

# 3. 提取日志位置（替换 <全量文件名> 为实际文件名，如 initial_full_backup_20251103_183000.sql）
grep "CHANGE MASTER TO" /tmp/sqlbak/<全量文件名>.sql
# 示例输出：# CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000001', MASTER_LOG_POS=154;
# 记录 <日志文件名>=mysql-bin.000001，<起始位置>=154

（3）模拟增量数据

bash

# 进入容器 MySQL（用root用户）
docker exec -it <容器名> mysql -u root -p123456

# 新增增量数据（操作 test 库的 user 表）
mysql> use test;
mysql> insert into user values (9,'增量9'),(10,'增量10');
mysql> exit;

（4）导出增量日志

bash

# 1. 容器内导出增量日志（替换 <日志文件名> 为 mysql-bin.000001，<起始位置> 为 154）
docker exec -it <容器名> mysqlbinlog \
  --start-position=<起始位置> \
  /var/lib/mysql/<日志文件名> \
  > /var/lib/mysql/incr_backup_$(date +%Y%m%d_%H%M%S).sql

# 2. 复制到宿主机增量目录
# 替换 <容器内增量文件名>（通过 docker exec -it <容器名> ls /var/lib/mysql/ 查看，如 incr_backup_20251103_190000.sql）
docker cp <容器名>:/var/lib/mysql/<容器内增量文件名>.sql /tmp/sqlbak_incr/

# 3. 验证（含 insert into test.user 语句即为成功）
cat /tmp/sqlbak_incr/<容器内增量文件名>.sql

（5）数据库损坏恢复示例（以误删 test 数据库为例）

假设全量备份后新增的test数据库（含user表增量数据（9,' 增量 9'）、（10,' 增量 10'））被误删，需通过 “全量备份 + 增量日志” 恢复：

bash

# 1. 模拟数据库丢失（手动删除 test 库）
docker exec -it <容器名> mysql -u root -p123456
mysql> show databases like 'test';
mysql> drop database test;
mysql> show databases like 'test';
mysql> exit;

# 2. 确认数据库丢失（验证故障）
docker exec -it <容器名> mysql -u admin -p123 -e "show databases like 'test';"
# 输出为空，说明 test 已被删除

# 3. 先恢复全量备份（恢复增量数据的基础环境）
# 替换 <全量文件名> 为首次全量备份文件名（如 initial_full_backup_20251103_183000.sql）
FULL_BACKUP_FILE="/tmp/sqlbak/<全量文件名>.sql"
cat $FULL_BACKUP_FILE | docker exec -i <容器名> mysql -u admin -p123

# 4. 恢复增量日志（补充全量备份后的增量数据）
# 替换 <容器内增量文件名> 为实际导出的增量日志文件名（如 incr_backup_20251103_190000.sql）
INCR_BACKUP_FILE="/tmp/sqlbak_incr/<容器内增量文件名>.sql"
cat $INCR_BACKUP_FILE | docker exec -i <容器名> mysql -u admin -p123

# 5. 验证恢复结果
# 5.1 确认 test 数据库已重建
docker exec -it <容器名> mysql -u admin -p123 -e "show databases like 'test';"
# 5.2 确认增量数据完整（test.user 表包含增量数据）
docker exec -it <容器名> mysql -u admin -p123 -e "select * from test.user where id in (9,10);"
# 成功标志：输出 (9,'增量9'),(10,'增量10')，与模拟增量数据一致

三、Percona XtraBackup 备份方案（物理备份）

1. 安装 XtraBackup（宿主机操作）

bash

# 1. 安装 Percona YUM 源
yum install -y https://repo.percona.com/yum/percona-release-latest.noarch.rpm

# 2. 启用工具仓库
percona-release enable-only tools release

# 3. 安装 2.4 版本（兼容 MySQL 5.7）
yum install -y percona-xtrabackup-24

# 4. 验证（输出版本信息即为成功）
xtrabackup --version

2. 步骤 1：查询 Docker MySQL 容器名称（独立步骤）

bash

# 同 mysqldump 步骤1，获取 <容器名>（示例：mysql）
docker ps

3. 步骤 2：获取 Docker 数据卷宿主机路径（独立步骤）

bash

# 替换 <容器名>，查询数据卷挂载信息
docker inspect <容器名> | grep "Mounts" -A 30
# 关键输出（记录 Source 字段值，记为 $VOLUME_PATH）：
# "Source": "/var/lib/docker/volumes/0085dc410d85d076e3a18fc6f738a11965c06fc8899f660bafb66861f2aea983/_data"
# 示例：
VOLUME_PATH=/var/lib/docker/volumes/0085dc410d85d076e3a18fc6f738a11965c06fc8899f660bafb66861f2aea983/_data

4. 步骤 3：创建 MySQL 备份用户并授权（独立步骤）

bash

# 1. 进入容器 MySQL（root 密码 123456）
docker exec -it <容器名> mysql -u root -p123456

# 2. 重新创建 admin 用户（与 mysqldump 独立，避免依赖）
mysql> drop user if exists 'admin'@'%';

mysql> grant reload,process,lock tables,replication client on *.* to 'admin'@'%' identified by '123';
# 在mysql5.7之后的版本不允许这样操作，可以执行下面的操作
mysql> create user 'admin'@'%' identified by '123';
mysql> grant reload,process,lock tables,replication client on *.* to 'admin'@'%';

mysql> flush privileges;

# 3. 验证用户
mysql> select user,host from mysql.user where user='admin';

# 4. 退出
mysql> exit;

5. 步骤 4：解决 Docker MySQL sock 路径问题

bash

# 1. 查看容器内 sock 路径
docker exec -it <容器名> ls -l /var/run/mysqld/mysqld.sock

# 2. 宿主机创建软链接（指向容器内 sock）
mkdir -p /var/lib/mysql
rm -f /var/lib/mysql/mysql.sock  # 删除旧链接
ln -s /var/run/mysqld/mysqld.sock /var/lib/mysql/mysql.sock

# 3. 验证链接（指向正确即为成功）
ls -l /var/lib/mysql/mysql.sock

6. 步骤 5：全量备份（保存路径 /full_xtrabackup）

bash

# 1. 创建全量备份目录（按要求改为 /full_xtrabackup）
mkdir -p /full_xtrabackup
chmod 700 /full_xtrabackup  # 收紧权限

# 2. 获取容器 IP
CONTAINER_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' <容器名>)
echo "容器 IP：$CONTAINER_IP"  # 示例：172.17.0.2

# 3. 执行全量备份
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --host=$CONTAINER_IP \
  --port=3306 \
  --datadir=$VOLUME_PATH \
  /full_xtrabackup  # 备份目录（最后一个参数）

（4）验证全量备份是否成功（xtrabackup 专用）

bash

# 1. 确认备份目录生成（基础验证）
ls /full_xtrabackup
# 获取全量备份时间目录（替换 <备份时间戳> 为实际生成的时间，如 2025-11-03_190000）
FULL_BACKUP_DIR="/full_xtrabackup/<备份时间戳>"
# 若变量未生效，手动赋值（示例）：
# FULL_BACKUP_DIR=$(ls -dt /full_xtrabackup/*/ | head -1)  # 取最新目录
ls -ld $FULL_BACKUP_DIR
# 成功标志：目录存在，无 "No such file or directory" 错误

# 2. 检查备份目录核心文件（物理备份必需文件）
ls -l $FULL_BACKUP_DIR | grep -E "ibdata1|xtrabackup_info|mysql"
# 成功标志：
# - ibdata1：InnoDB 共享表空间文件（大小与生产库一致，如 12M）
# - xtrabackup_info：备份元信息文件（非空，记录备份关键参数）
# - mysql/：系统库目录（包含 user.frm、user.ibd 等文件）

# 3. 查看备份日志（确认无报错，正常结束）
cat $FULL_BACKUP_DIR/xtrabackup_logfile | grep -iE "error|future|corrupt"
# 成功标志：无任何 "error"、"future"、"corrupt" 相关输出（这些均为日志损坏信号）

# 4. 验证备份元信息（确认备份参数正确）
cat $FULL_BACKUP_DIR/xtrabackup_info
# 关键信息需包含：
# - backup_type = full-backuped
# - start_lsn / end_lsn：非 0
# - database_version = 5.7.44-log（与容器版本一致）
# - status = complete

# 5. 模拟恢复测试（核心验证）
# 5.1 创建临时恢复目录
mkdir -p /tmp/xtra_full_restore_test
chmod 700 /tmp/xtra_full_restore_test

# 5.2 执行日志整合（恢复前必需）
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --apply-log \
  $FULL_BACKUP_DIR

# 5.3 恢复数据到临时目录（选项在前，备份目录在后）
innobackupex \
  --copy-back \
  --datadir=/tmp/xtra_full_restore_test \
  -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  $FULL_BACKUP_DIR

# 5.4 修正权限（匹配容器 MySQL 用户 UID 999）
chown -R 999:999 /tmp/xtra_full_restore_test

# 5.5 启动临时容器验证
docker run -d \
  --name mysql_full_restore_test \
  -p 3309:3306 \
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v /tmp/xtra_full_restore_test:/var/lib/mysql \
  mysql:5.7

# 5.6 检查数据（以 test.user 为例）
docker exec -it mysql_full_restore_test mysql -u root -p123456 -e "select * from test.user;"
# 成功标志：输出与生产库一致

# 5.7 清理临时资源
docker stop mysql_full_restore_test && docker rm mysql_full_restore_test
# （可选）删除临时恢复目录：rm -rf /tmp/xtra_full_restore_test

（5）数据库损坏恢复示例（以误删 test 数据库为例）

假设误删了物理备份包含的test数据库（库内有user表，字段为id和name），且原数据卷已损坏，需通过 XtraBackup 全量备份恢复：

bash

# 1. 模拟数据库丢失（手动删除 test 库）
docker exec -it <容器名> mysql -u root -p123456
mysql> show databases like 'test';
mysql> drop database test;
mysql> show databases like 'test';
mysql> exit;

# 2. 停止 MySQL 容器（避免数据卷占用，确保恢复正常）
docker stop <容器名>

# 3. 备份损坏的数据卷（防止恢复失败后无回退方案）
mv $VOLUME_PATH $VOLUME_PATH.bak_$(date +%Y%m%d)
# 重新创建空的数据卷目录
mkdir -p $VOLUME_PATH

# 4. 定位全量备份目录（替换 <备份时间戳> 为实际备份目录时间，如 2025-11-03_190000）
FULL_BACKUP_DIR="/full_xtrabackup/<备份时间戳>"

# 5. 执行日志整合（物理备份恢复必需步骤，确保数据一致性）
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --apply-log \
  $FULL_BACKUP_DIR

# 6. 恢复物理备份到数据卷
innobackupex \
  --copy-back \
  --datadir=$VOLUME_PATH \
  -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  $FULL_BACKUP_DIR

# 7. 修正数据卷权限（匹配 Docker 容器内 MySQL 用户 UID 999，否则容器无法读取数据）
chown -R 999:999 $VOLUME_PATH

# 8. 启动容器并验证恢复结果
docker start <容器名>
# 8.1 确认 test 数据库已恢复
docker exec -it <容器名> mysql -u root -p123456 -e "show databases like 'test';"
# 8.2 确认数据库内表及数据完整（以 test 下的 user 表为例）
docker exec -it <容器名> mysql -u root -p123456 -e "select * from test.user limit 10;"
# 成功标志：表结构正常，数据与备份前一致

7. 步骤 6：全量备份日志整合（为增量备份做准备）

bash

# 1. 定义全量目录变量（手动赋值示例，取最新全量备份目录）
FULL_BACKUP_DIR=$(ls -dt /full_xtrabackup/*/ | head -1)

# 2. 执行日志整合（--redo-only 确保不回滚未提交事务，为增量备份保留基础）
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --apply-log \  # 整合备份过程中的事务日志
  --redo-only \  # 仅应用已提交事务，不回滚未提交事务（增量备份必需）
  $FULL_BACKUP_DIR

# 3. 验证日志整合成功
# 成功标志：命令结尾输出 "completed OK!"，且备份目录中生成 xtrabackup_checkpoints 文件
cat $FULL_BACKUP_DIR/xtrabackup_checkpoints
# 示例输出（记录 LSN 信息，增量备份需基于此）：
# backup_type = full-prepared
# from_lsn = 0
# to_lsn = 1234567  # 全量备份结束时的 LSN
# last_lsn = 1234567
# compact = 0

8. 步骤 7：增量备份（基于全量备份）

（1）模拟增量数据（新增业务数据）

bash

docker exec -it <容器名> mysql -u root -p123456  # 输入 root 密码

# 新增增量数据（操作 test 库的 user 表）
mysql> use test;
mysql> insert into user values (9,'增量9'),(10,'增量10');
mysql> exit;  # 退出 MySQL 和容器

（2）执行增量备份

bash

# 1. 宿主机创建增量备份目录
mkdir -p /full_xtra_incr
chmod 700 /full_xtra_incr  # 收紧权限

# 2. 执行增量备份（基于前面的全量备份）
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --host=$CONTAINER_IP \  # 容器 IP（步骤5中已获取）
  --port=3306 \
  --datadir=$VOLUME_PATH \  # 宿主机数据卷路径（步骤2中已获取）
  --incremental /full_xtra_incr \  # 增量备份存储目录
  --incremental-basedir=$FULL_BACKUP_DIR  # 基于的全量备份目录

（3）验证增量备份是否成功

bash

# 1. 获取最新增量备份目录
INCR_BACKUP_DIR=$(ls -dt /full_xtra_incr/*/ | head -1)

# 2. 检查增量目录核心文件
ls -l $INCR_BACKUP_DIR | grep -E "xtrabackup_info|xtrabackup_logfile|xtrabackup_checkpoints"
# 成功标志：三个文件均存在且非空

# 3. 验证 LSN 连续性（增量备份的起点需与全量备份的终点一致）
cat $INCR_BACKUP_DIR/xtrabackup_checkpoints
# 示例输出（需满足以下条件）：
# backup_type = incremental
# from_lsn = 1234567  # 必须等于全量备份的 to_lsn
# to_lsn = 1239876    # 大于 from_lsn，说明有增量数据
# last_lsn = 1239876

# 4. 检查备份命令输出（结尾是否为 "completed OK!"）

9. 步骤 8：整合增量备份到全量备份（恢复前必需）

bash

# 1. 将增量数据合并到全量备份
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --apply-log \
  $FULL_BACKUP_DIR \
  --incremental-dir=$INCR_BACKUP_DIR

   # 若报错 "needs target prepared with --apply-log-only"，执行以下修复：
   # 1. 重新对全量备份执行预处理（确保状态为 full-prepared）：
   # innobackupex -S /var/run/mysqld/mysqld.sock --user=admin --password=123 --apply-log --redo-only $FULL_BACKUP_DIR
   # 2. 再次执行上述合并命令

   # 若报错 "LSN in the future" 或 "corrupt"，说明全量/增量备份损坏，需：
   # 1. 删除当前全量和增量备份目录
   # 2. 重新执行全量备份（步骤5）→ 预处理（步骤6）→ 增量备份（步骤7）→ 合并（当前步骤）

# 2. 验证合并成功
# 成功标志：命令结尾输出 "completed OK!"，且全量备份的 LSN 终点更新
cat $FULL_BACKUP_DIR/xtrabackup_checkpoints
# 示例输出（to_lsn 应等于增量备份的 to_lsn）：
# backup_type = full-prepared
# from_lsn = 0
# to_lsn = 1239876  # 与增量备份的 to_lsn 一致
# last_lsn = 1239876

10. 步骤 9：增量备份成功验证（最终确认）

（1）模拟恢复合并后的全量 + 增量数据

bash

# 1. 创建临时恢复目录
mkdir -p /tmp/xtra_restore_test
chmod 700 /tmp/xtra_restore_test

# 2. 恢复合并后的备份数据到临时目录
innobackupex \
  --copy-back \
  --datadir=/tmp/xtra_restore_test \
  -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  $FULL_BACKUP_DIR

# 3. 修正权限（匹配容器内 MySQL 用户 UID 999）
chown -R 999:999 /tmp/xtra_restore_test

# 4. 启动临时容器验证数据
docker run -d \
  --name mysql_restore_test \
  -p 3308:3306 \  # 避免占用生产端口
  -e MYSQL_ROOT_PASSWORD=123456 \
  -v /tmp/xtra_restore_test:/var/lib/mysql \
  mysql:5.7

# 5. 检查增量数据是否存在
docker exec -it mysql_restore_test mysql -u root -p123456 -e "select * from test.user;"
# 成功标志：输出包含全量数据和增量数据（9,'增量9'),(10,'增量10'）

# 6. 清理临时资源
docker stop mysql_restore_test && docker rm mysql_restore_test
rm -rf /tmp/xtra_restore_test  # 可选，删除临时恢复目录

（2）数据库损坏恢复示例（以误删 test 数据库为例）

假设包含全量 + 增量数据的test数据库（库内user表含全量数据和增量数据（9,' 增量 9'）、（10,' 增量 10'））被误删，需通过合并后的备份恢复：

bash

# 1. 模拟数据库丢失（手动删除 test 库）
docker exec -it <容器名> mysql -u root -p123456
mysql> show databases like 'test';
mysql> drop database test;
mysql> show databases like 'test';
mysql> exit;

# 2. 停止生产容器（确保数据卷可恢复）
docker stop <容器名>

# 3. 备份原数据卷并重建空目录
mv $VOLUME_PATH $VOLUME_PATH.final_bak_$(date +%Y%m%d)
mkdir -p $VOLUME_PATH

# 4. 定义合并后的全量备份目录（已包含增量数据）
FULL_BACKUP_DIR=$(ls -dt /full_xtrabackup/*/ | head -1)

# 5. 执行日志整合（确保合并后的数据一致性）
innobackupex -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  --apply-log \
  $FULL_BACKUP_DIR

# 6. 恢复数据到生产数据卷
innobackupex \
  --copy-back \
  --datadir=$VOLUME_PATH \
  -S /var/run/mysqld/mysqld.sock \
  --user=admin \
  --password=123 \
  $FULL_BACKUP_DIR

# 7. 修正权限并启动容器
chown -R 999:999 $VOLUME_PATH
docker start <容器名>

# 8. 验证恢复结果
# 8.1 确认 test 数据库存在
docker exec -it <容器名> mysql -u root -p123456 -e "show databases like 'test';"
# 8.2 确认全量+增量数据完整（user 表包含全量数据和增量数据）
docker exec -it <容器名> mysql -u root -p123456 -e "select * from test.user;"
# 成功标志：输出包含全量数据和(9,'增量9'),(10,'增量10')，与备份前数据完全一致