MySQL 备份与恢复
MySQL 备份与恢复
一、备份的原因
我页面呢？我页面呢？ 我页面呢？ 我页面呢？
1.做备份就是为了恢复
2.保护公司的数据
3.尽量减少数据的丢失（公司的损失）
小贴士：MySQL以覆盖的形式 就是先删掉再给你创建 完后添加数据 所以备份的时候要注意 不要只备份表结构不备份数据
二、备份类型
1.冷备
停服务，做备份
停服务 不一定是停库 比如停nginx 或者redis 做备份
2.温备
（不停服务）在备份的过程中，会锁表，用户无法往表中写入数据
锁表备份,只能查询不能修改（myisam）
3.热备
（不停服务）在备份过程中，不会锁表，用户随意写数据
在数据库正常业务时,备份数据,并且能够一致性恢复（只能是innodb）
三、备份策略
1.全量备份
将所有的数据，做备份
2.增量备份
基于上一次数据备份的，新数据备份
3.差异备份
基于全备数据的，新数据备份
四、备份方式
1.逻辑备份
1.mysqlbinlog
2.mysqldump
3.into outfile(导出数据'结果') 知道就行 没什么人会这么做
4.binlog（备份SQL语句，DML，DCL，DDL，DTL）
5.replication（主从复制-延时从库）
mysql> select * from world.city into outfile '/tmp/world_city.data';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
[root@db01 ~]# vim /etc/my.cnf
[mysqld]
secure-file-priv=/tmp 等于0不行 要给个路径
[root@db01 ~]# /etc/init.d/mysqld restart
mysql> select * from world.city into outfile '/tmp/world_city.data';
[root@db01 ~]# cat /tmp/world_city.data
......
4065 Carson USA California 89089
4066 Charleston USA South Carolina 89063
4067 Charlotte Amalie VIR St Thomas 13000
4068 Harare ZWE Harare 1410000
4069 Bulawayo ZWE Bulawayo 621742
......
2.物理备份
1.cp /application/mysql/data
2.Xtrabackup 备份速度甩mysqldump一条街 大数据情况下
3.逻辑备份和物理备份的比较
mysqldump (MDP)
优点：
1.不需要下载安装
2.备份出来的是SQL，文本格式，可读性高,便于备份处理
3.压缩比较高，节省备份的磁盘空间
缺点：
依赖于数据库引擎，需要从磁盘把数据读出
然后转换成SQL进行转储，比较耗费资源，数据量大的话效率较低
mysqldump没有增量备份 它的增量备份就是binlog 只能去截取binlog日志
建议：
100G以内的数据量级，可以使用mysqldump
超过TB以上，我们也可能选择的是mysqldump，配合分布式的系统
1EB =1024 PB =1000000 TB
xtrabackup(XBK)
优点：
1.类似于直接cp数据文件，不需要管逻辑结构，相对来说性能较高
2.速度贼快（大量数据的情况下 小数据不如mysqldump）
3.全备 增备 差异备都能做
缺点：
1.可读性差
2.压缩比低，需要更多磁盘空间
建议：
>100G<TB
五、MySQL逻辑备份-mysqldump使用
客户端通用参数
mysqldump
-u：指定用户
-p：指定密码
-h：指定主机域
-S：指定socket文件
-P：指定端口
本地备份:
mysqldump -uroot -p -S /tmp/mysql.sock
远程备份:
mysqldump -uroot -p -h 10.0.0.51 -P3306
备份专用基本参数
1.全备参数：-A
[root@db02 ~]# mysqldump -A > /tmp/full.sql
就像之前说的 覆盖 有就先删除 然后给你创建 再给你插入数据
2.指定库备份：-B(指定多个库)
[root@db02 ~]# mysqldump -B dev > /tmp/dev.sql 备份dev这个库
mysql < /tmp/zls1.sql
3.什么都不加：备份库中的表
必须库事先存在,并且ues才能source恢复
[root@db02 ~]# mysqldump dev > /tmp/dev1.sql 备份dev表
mysql> create database dev;
mysql> use dev; source /tmp/dev1.sql
#没有use的话就这么恢复
mysql dev < /tmp/dev1.sql
[root@db02 ~]# mysqldump test dev > /tmp/dev1.sql 备份test库里的dev表 不是test库和dev库
对加不加-B参数的实操
# 1.备份 都成功了
[root@db02 ~]# mysqldump -B dev > /tmp/dev.sql
[root@db02 ~]# mysqldump dev > /tmp/dev1.sql
# 2.导入加-B参数的数据
mysql> drop database dev;
mysql> source /tmp/dev.sql
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| dev |
+--------------------+
mysql> use dev
mysql> show tables;
+---------------+
| Tables_in_dev |
+---------------+
| dev |
+---------------+
# 3.删除表试试
mysql> drop table dev.dev;
mysql> show tables;
Empty set (0.00 sec)
mysql> source /tmp/dev.sql
mysql> show tables;
+---------------+
| Tables_in_dev |
+---------------+
| dev |
+---------------+
#导入不加-B参数的数据
mysql> drop database dev;
mysql> source /tmp/dev1.sql
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| test |
+--------------------+
没恢复回来
#创建库 导入数据
mysql> create database dev;
mysql> use dev
mysql> source /tmp/dev1.sql
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| dev |
+--------------------+
4.备份时，刷新binlog：-F
一般不会用这个 因为你有多少个库就会刷新出来多少个binlog
[root@db01 ~]# mysqldump -A -F > /tmp/full_F.sql
[root@db02 ~]# ll /application/mysql/data/
-rw-rw---- 1 mysql mysql 718 Nov 28 11:41 mysql-bin.000001
-rw-rw---- 1 mysql mysql 143 Nov 28 12:17 mysql-bin.000002
[root@db01 ~]# mysqldump -B mysql dev -F > /tmp/full_F.sql
[root@db02 ~]# ll /application/mysql/data/
-rw-rw---- 1 mysql mysql 718 Nov 28 11:41 mysql-bin.000001
-rw-rw---- 1 mysql mysql 143 Nov 28 12:17 mysql-bin.000002
-rw-rw---- 1 mysql mysql 143 Nov 28 12:41 mysql-bin.000003
-rw-rw---- 1 mysql mysql 143 Nov 28 13:45 mysql-bin.000004
#刷新两个库 就多了两个binlog日志出来
`这样其实也不好找数据 但是增量备份怎么找？ 看下一个参数
5.打点备份：--master-data=2
用这个的前提是必须要开启binlog！！！！！！！！！
[root@db02 ~]# vim /etc/my.cnf
[mysqld]
log-bin=mysql-bin
别忘记重启
#=2是注释
[root@db02 ~]# mysqldump -A --master-data=2 > /tmp/full1.sql
#=1 不注释
[root@db02 ~]# mysqldump -A --master-data=1 > /tmp/full2.sql
#=0 关闭 就是不加这个参试 （有病可能）
[root@db02 ~]# mysqldump -A --master-data=0 > /tmp/full3.sql
**做主从复制 这个参数是最有用的 **
做主从建议用data=1好一点
# 1.创建需要的库和表
mysql> create database rep;
mysql> use rep
mysql> create table rep(id int not null primary key auto_increment);
# 2.模拟一个不停插入数据的生产库
[root@db02 ~]# vim a.sh
#!/bin/bash
while true;do
mysql -e 'insert into rep.rep values('"$num"');'
let num++
sleep 2
done
mysql> truncate rep.rep; 刚脚本写错了 把数据清空下
# 3.执行脚本
[root@db02 ~]# sh a.sh
# 4.另个窗口查看一直在变化
mysql> show master status;
# 5.备份
[root@db02 ~]# mysqldump -A --master-data=2 > /tmp/full1.sql
查看这个备份出来的数据 是有节点的
[root@db02 ~]# vim /tmp/full1.sql
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000011', MASTER_LOG_POS=195939;
# 6. 主库授权用户
mysql> grant replication slave on *.* to rep@'%' identified by '123';
# 7.找到一台服务器做从库(这里选择51)传备份 别忘记两台服务器都要配server_id
[root@db02 ~]# scp /tmp/full1.sql 172.16.1.51:/tmp
# 8.从库导入数据
mysql> change master to
-> master_host='10.0.0.52',
-> master_user='rep',
-> master_password='123',
-> master_log_file='mysql-bin.000011',
-> master_log_pos=195939;
mysql> start slave;
master-data=2与master-data=1的区别就是 1不需要执行后两个 系统会自动执行掉。
6.热备参数：--single-transaction（快照备份）
回头看看第五条的参数--master-data= 这条参数相当于温备
加上第六条的这个参数 就不会锁表了（温备会锁表）
注意：只能innodb存储引擎使用！！！！！！！！！
[root@db02 ~]# mysqldump -A --master-data=2 --single-transaction > /tmp/full2.sql
敲下的一瞬间 会把定点打个快照 （就是showmaster status里面那个变化的点）
但是它只快照到那里备份到那 你写你的数据 和我没关系
一定要配合--master-data使用 不然你不知道你快照到哪里了
7.-R(备份函数，存储过程),--triggers(触发器)，-E(备份事件)
[root@db02 ~]# mysqldump -A -R -E --triggers --master-data=2 --single-transaction > /tmp/full2.sql
专业备份这样就是这样的 参数加的不过分不过分
8.--set-gtid-purged=auto
1. --set-gtid-purged=OFF,可以使用在日常备份参数中.
mysqldump -uroot -p -A -R -E --triggers --master-data=2 --single-transaction --set-gtid-purged=OFF >/data/backup/full.sql
2.在构建主从复制环境时需要的参数配置
mysqldump -uroot -p -A -R -E --triggers --master-data=2 --single-transaction --set-gtid-purged=OFF >/data/backup/full.sql
加了--set-gtid-purged=OFF时，会记录binlog日志，如果不加，不记录binlog日志，所以在我们做主从用了gtid时，用mysqldump备份时就要加--set-gtid-purged=OFF，否则你在主上导入恢复了数据，主没有了binlog日志，同步则不会被同步。
8.压缩备份：gzip
[root@db02 ~]# mysqldump -A -R --triggers --master-data=2 --single-transaction |gzip > /tmp/full_$(date +%F).sql.gz
[root@db02 ~]# ll /tmp
-rw-r--r-- 1 root root 183425 Dec 10 17:09 full_2019-12-10.sql.gz
[root@db02 ~]# zcat /tmp/full_2019-12-10.sql.gz | mysql
#找那个点
[root@db02 ~]# zcat /tmp/full_2019-12-10.sql.gz | head -22
9.--max-allowed-packet=#
5.6没有gtid 5.7有
mysql根据配置文件会限制server接受的数据包大小。
如果一次插入数据库中的数据太大的话就会失败。
mysql> show VARIABLES like '%max_allowed_packet%';
+--------------------------+------------+
| Variable_name | Value |
+--------------------------+------------+
| max_allowed_packet | 4194304 |
| slave_max_allowed_packet | 1073741824 |
+--------------------------+------------+
#解决方法
1、修改配置文件
在mysql中的my.ini文件中（在programdata隐藏文件中），修改max_allowed_packet的值
比如：max_allowed_packet=20M
然后重启mysql就可以
10.-d：仅备份表结构
11.-t：仅备份数据
mysqldump企业故障恢复案例
背景：
正在运行的网站系统，MySQL数据库，数据量25G，日业务增量10-15M。
备份策略：
每天23：00，计划任务调用mysqldump执行全备脚本
如果是每天晚上00:00备份？（备份的是前一天的数据 到零点日期不就变成今天的了吗）
mysqldump -A -R --triggers --set-gtid-purged=OFF --master-data=2 --single-transaction|gzip > /backup/full_$(date +%F -d "- 1 day").sql.gz
故障时间点：
上午10点开发人员误删除一个核心业务表，如何恢复？
思路：
1）停业务避免数据的二次伤害
2）找一个临时的库，恢复前一天的全备
3）截取前一天23：00到第二天10点误删除之间的binlog，恢复到临时库
4）测试可用性和完整性
5）开启业务前的两种方式
如何抉择 看企业数据量
a.直接使用临时库顶替原生产库，前端应用割接到新库
b.将误删除的表单独导出，然后导入到原生产环境
6）开启业务
故障模拟
1.准备数据
#刷新binlog使内容更清晰
mysql> flush logs;
#查看当前使用的binlog
mysql> show master status;
+------------------+----------+--------------+--------------------------+-------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+--------------------------+-------------------+
| mysql-bin.000012 | 120 | | mysql,information_schema | |
+------------------+----------+--------------+--------------------------+-------------------+
#创建backup库
mysql> create database backup;
#进入backup库
mysql> use backup
#创建t1表
mysql> create table t1(id int);
#t1表插入数据
mysql> insert into t1 values(1),(2),(3);
#创建t2表
mysql> create table t2(id int);
#t2表插入数据
mysql> insert into t1 values(4),(5),(6);
#提交
mysql> commit;
#查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| t1 |
| t2 |
+------------------+
2.第一天晚23:00全备
[root@db02 ~]# mkdir /backup
[root@db02 ~]# mysqldump -A -R --triggers --set-gtid-purged=OFF --master-data=2 --single-transaction|gzip > /backup/full_$(date +%F).sql.gz
3.模拟数据变化
#进入库
mysql> use backup
#创建新表
mysql> create table new(id int);
#给新表插入数据
mysql> insert into new values(9),(10),(11);
#提交
mysql> commit;
#添加数据
mysql> insert into t1 values(11),(12),(13);
#提交
mysql> commit;
#查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
4.模拟故障
#删除new表
mysql> drop table new;
#查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| t1 |
| t2 |
+------------------+
恢复过程
0.停库
先停能连接到数据库的服务 tomcat nginx等
[root@db02 ~]# /etc/init.d/mysqld stop
1.准备临时数据库
这里我用之前配置好的多实例13307
[root@db02 ~]# systemctl start mysql13307
# 另一台数据库上初始化一个新库也可以的
[root@db01 scripts]# ./mysql_install_db --user=mysql --basedir=/application/mysql --datadir=/application/mysql/data
[root@db01 scripts]# /etc/init.d/mysqld start
2.拷贝数据到新库上
[root@db02 ~]# scp /backup/full_2019-12-10.sql.gz root@10.0.0.52:/tmp
3.全备导入新环境
#进入tmp目录
[root@db02 ~]# cd /tmp
[root@db02 /tmp]# ll
-rw-r--r-- 1 root root 183623 Dec 10 18:48 full_2019-12-10.sql.gz
srwxrwxrwx 1 mysql mysql 0 Dec 10 15:39 mysql.sock
#数据导入新库中 免解压
[root@db02 /tmp]# zcat /tmp/full_2019-12-10.sql.gz |mysql -uroot -p
#查看全备的位置点（起始位置点）
[root@db02 /tmp]# head -50 full_2019-12-10.sql |grep -i 'change master to'
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000012', MASTER_LOG_POS=1104;
【没有解压的情况下这么看 一般为了节省空间都不会解压的 不然最后还要打压缩包很麻烦】
[root@db02 /tmp]# zcat /tmp/full_2019-12-10.sql.gz |head -22
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000012', MASTER_LOG_POS=1104;
#找到drop语句执行的位置点（结束位置点）
mysql> show binlog events in 'mysql-bin.000012';
#或者这样
[root@db02 /tmp]# mysqlbinlog --base64-output=decode-rows -vvv mysql-bin.000012|less
#截取二进制
[root@db02 /tmp]# mysqlbinlog --start-position=1104 --stop-position=1654 /application/mysql/data/mysql-bin.000012 > /tmp/inc.sql
#发送增量数据到新库
[root@db02 /tmp]# scp /tmp/inc.sql root@10.0.0.52:/tmp
#在新库(mysql13307)内恢复数据
【不记录二进制日志】
[root@db02 /tmp]# mysql13307
mysql> set sql_log_bin=0;
#恢复全备数据
mysql> source /tmp/full_2019-12-10.sql
#进入backup库
mysql> use backup
# 查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| t1 |
| t2 |
+------------------+
#恢复增量数据
mysql> source /tmp/inc.sql
#查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
+------+
4.将故障表导出并恢复到生产
#导出new表
注意你做多实例的时候把socket文件放哪了
[root@db02 /tmp]# mysqldump -S /data/13307/data/mysql.sock backup new > /tmp/new.sql
#发送到生产库mysql3306
[root@db02 ~]# scp /tmp/new.sql root@10.0.0.52:/tmp/
#在生产库上mysql3306上进入backup库
[root@db02 /tmp]# mysql
mysql> use backup
#在生产库恢复数据
mysql> source /tmp/new.sql
#查看表
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
+------+
练习
1、创建一个数据库 oldboy
2、在oldboy下创建一张表t1
3、插入5行任意数据
4、全备
5、插入两行数据，任意修改3行数据，删除1行数据
6、删除所有数据
7、再t1中又插入5行新数据，修改3行数据
需求，跳过第六步恢复表数据
# 创建一个数据库 oldboy
mysql> create database oldboy;
# 查看库
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| backup |
| dev |
| mysql |
| oldboy |
| performance_schema |
| rep |
| test |
+--------------------+
# 进入到oldboy库
mysql> use oldboy
# 创建t1表
mysql> create table t1(id int);
# 插入5行任意数据
mysql> insert into t1 values(1),(2),(3),(4),(5);
# 查看t1表
mysql> show tables;
+------------------+
| Tables_in_oldboy |
+------------------+
| t1 |
+------------------+
# 查看表内数据
mysql> select * from t1;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
+------+
# 此时全备
[root@db02 ~]# mysqldump -A -R --triggers --master-data=2 --single-transaction|gzip > /tmp/full_$(date +%F).sql.gz
[root@db02 /tmp]# ll
-rw-r--r-- 1 root root 183809 Dec 10 19:40 full_2019-12-10.sql.gz
srwxrwxrwx 1 mysql mysql 0 Dec 10 15:39 mysql.sock
# 进入oldboy库 并插入2行任意数据
mysql> use oldboy
mysql> insert into t1 values(6),(7);
#查看t1表数据
mysql> select * from t1;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
+------+
# 任意修改3行数据 并查看t1表数据
mysql> update t1 set id=10 where id=1;
mysql> update t1 set id=9 where id=2;
mysql> update t1 set id=8 where id=3;
mysql> select * from t1;
+------+
| id |
+------+
| 10 |
| 9 |
| 8 |
| 4 |
| 5 |
| 6 |
| 7 |
+------+
# 删除1行数据 并查看t1表数据
mysql> delete from t1 where id=7;
mysql> select * from t1;
+------+
| id |
+------+
| 10 |
| 9 |
| 8 |
| 4 |
| 5 |
| 6 |
+------+
# 删除表内数据
mysql> truncate table t1;
# 查看t1表
mysql> select * from t1;
# 再t1中又插入5行新数据 并查看t1
mysql> insert into t1 values(11),(12),(13),(14),(15);
mysql> select * from t1;
+------+
| id |
+------+
| 11 |
| 12 |
| 13 |
| 14 |
| 15 |
+------+
# 修改3行数据 并查看t1
mysql> update t1 set id=21 where id=11;
mysql> update t1 set id=22 where id=12;
mysql> update t1 set id=23 where id=13;
mysql> select * from t1;
+------+
| id |
+------+
| 21 |
| 22 |
| 23 |
| 14 |
| 15 |
+------+
# 解压全备
[root@db02 ~]# cd /tmp/
[root@db02 /tmp]# gzip -d full_2019-12-10.sql.gz
【免解压导入新库】
[root@db01 scripts]# zcat /tmp/full_2019-12-10.sql.gz |mysql -uroot -p
# 查看全备的位置点（起始位置点）
[root@db02 /tmp]# head -50 full_2019-12-10.sql |grep -i 'change master to'
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000012', MASTER_LOG_POS=3057;
【免解压查看起始点】
[root@db02 /tmp]# zcat /backup/full_2019-12-10.sql.gz |head -22
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin.000012', MASTER_LOG_POS=3057;
# 找到drop语句执行的位置点（结束位置点）
[root@db02 /tmp]# mysql
mysql> show binlog events in 'mysql-bin.000012';
【不进库查看结束点】
[root@db02 /tmp]# mysqlbinlog --base64-output=decode-rows -vvv mysql-bin.000012|less
# 截取二进制
[root@db02 /tmp]# mysqlbinlog --start-position=3057 --stop-position=4430 /application/mysql/data/mysql-bin.000012 > /tmp/inc.sql
# 跳过第6步 截取二进制 找他的起始点与结束点
[root@db02 /tmp]# mysqlbinlog --start-position=4618 --stop-position=5476 /application/mysql/data/mysql-bin.000012 > /tmp/inc1.sql
# 不记录二进制日志
[root@db02 /tmp]# mysql
mysql> set sql_log_bin=0;
# 恢复全备数据
mysql> source /tmp/full_2019-12-10.sql;
# 进入oldboy库
mysql> use oldboy
# 导入两次增备
mysql> source /tmp/inc.sql;
mysql> source /tmp/inc1.sql;
# 查看t1表 成功
mysql> select * from t1;
+------+
| id |
+------+
| 10 |
| 9 |
| 8 |
| 4 |
| 5 |
| 6 |
| 21 |
| 22 |
| 23 |
| 14 |
| 15 |
+------+
六、MySQL物理备份-xtrabackup使用
以前用 xtrabackup
现在用 innobackupex
Xtrabackup安装
这里我就直接把压缩包拖进去 yum localinstall -y 了
#下载epel源
wget -O /etc/yum.repos.d/epel.repo https://mirrors.aliyun.com/repo/epel-6.repo
#安装依赖
yum -y install perl perl-devel libaio libaio-devel perl-Time-HiRes perl-DBD-MySQL
#下载Xtrabackup
wget httpss://www.percona.com/downloads/XtraBackup/Percona-XtraBackup-2.4.4/binary/redhat/6/x86_64/percona-xtrabackup-24-2.4.4-1.el6.x86_64.rpm
备份方式（物理备份）
1）对于非innodb表（比如myisam）是直接锁表cp数据文件，属于一种温备。
2）对于innodb的表（支持事务），不锁表，cp数据页最终以数据文件方式保存下来，并且把redo和undo一并备走，属于热备方式。
3）备份时读取配置文件/etc/my.cnf
-
第三条非常重要
-
请看第四条
全备
全量备份
# 1.全备
[root@db02 ~]# mkdir /backup/
[root@db02 ~]# innobackupex --user=root /backup/
xtrabackup: Transaction log of lsn (3245205) to (3245205) was copied.
191211 10:11:39 completed OK!
# 2.避免时间戳，自定义路径名
[root@db01 ~]# innobackupex --user=root --no-timestamp /backup/full
如果这个时候全备失败了 就回去看看备份方式的第五条内容
注意socket文件的存放位置 他会读/etc/my.cnf 里面的配置文件 如果没有 就会去默认/tmp/下去找
指定了socket文件位置得位置的话 命令行加上--socket=/opt/mysql.sock
[mysqld]
basedir=/application/mysql
datadir=/application/mysql/data
这两个也必须要加 不然他会去 /usr/local/下去找
所以后期做备份 找不到什么 就在配置文件里写上就行
还有一个深坑，后期导入全备不成功，看datadir有没有写在配置文件里，就算有也一定要注意写在[mysqld]下，写在[server]不行，写在[client]可以，但是后面还后报错！！！！！！！！！！！！！！！！！！！！！！！！
# 3.查看备份路径中的内容
[root@db02 ~]# ll /backup/
drwxr-x--- 9 root root 252 Dec 11 10:11 2019-12-11_10-11-35
[root@db02 ~]# cd /backup/2019-12-11_10-11-35/
[root@db02 /backup/2019-12-11_10-11-35]# ll
drwxr-x--- 2 root root 106 Dec 11 10:11 backup
-rw-r----- 1 root root 418 Dec 11 10:11 backup-my.cnf
drwxr-x--- 2 root root 50 Dec 11 10:11 dev
-rw-r----- 1 root root 79691776 Dec 11 10:11 ibdata1 #undo
drwxr-x--- 2 root root 4096 Dec 11 10:11 mysql
drwxr-x--- 2 root root 48 Dec 11 10:11 oldboy
drwxr-x--- 2 root root 4096 Dec 11 10:11 performance_schema
drwxr-x--- 2 root root 50 Dec 11 10:11 rep
drwxr-x--- 2 root root 56 Dec 11 10:11 test
-rw-r----- 1 root root 21 Dec 11 10:11 xtrabackup_binlog_info
-rw-r----- 1 root root 113 Dec 11 10:11 xtrabackup_checkpoints
-rw-r----- 1 root root 449 Dec 11 10:11 xtrabackup_info
-rw-r----- 1 root root 2560 Dec 11 10:11 xtrabackup_logfile #redo
# 4.这些个文件都是啥呢？
[root@db02 /backup/2019-12-11_10-11-35]# cat xtrabackup_binlog_info 全备打快照的点 （起始位置）
mysql-bin.000014 120
[root@db02 /backup/2019-12-11_10-11-35]# cat xtrabackup_checkpoints
backup_type = full-backuped 全备
from_lsn = 0 从0开始 日志版本号
to_lsn = 3245205 备份到3245205
last_lsn = 3245371 现在到3245371 因为数据在持续写入
compact = 0
recover_binlog_info = 0
备份时刻，立即将已经commit过的，内存中的数据页刷新到磁盘(CKPT).开始备份数据，数据文件的LSN会停留在to_lsn位置。
备份时刻有可能会有其他的数据写入，已备走的数据文件就不会再发生变化了。
在备份过程中，备份软件会一直监控着redo的undo，如果一旦有变化会将日志也一并备走，并记录LSN到last_lsn。
从to_lsn ---->last_lsn 就是，备份过程中产生的数据变化.
[root@db02 /backup/2019-12-11_10-11-35]# cat xtrabackup_info
uuid = 650301eb-1bbc-11ea-b4c8-000c29e98743
name =
tool_name = innobackupex
tool_command = --user=root --password=... --socket=/opt/mysql.sock /backup/
tool_version = 2.4.4
ibbackup_version = 2.4.4
server_version = 5.6.40-log
start_time = 2019-12-11 10:17:27
end_time = 2019-12-11 10:17:35
lock_time = 0
binlog_pos = filename 'mysql-bin.000004', position '48922'
innodb_from_lsn = 0
innodb_to_lsn = 2308823
partial = N
incremental = N
format = file
compact = N
compressed = N
encrypted = N
全备恢复
#前提1：被恢复的目录是空的
#前提2：被恢复的数据库的实例是关闭的
# 1.停库
[root@db02 /backup/2019-12-11_10-11-35]# /etc/init.d/mysqld stop
# 2.模拟CSR,做一遍redo,再做一遍undo
将redo进行重做，已提交的写到数据文件，未提交的使用undo回滚掉。
[root@db02 /backup/2019-12-11_10-11-35]# innobackupex --apply-log /backup/2019-12-11_10-11-35/
# 3.保证data目录是空的
[root@db02 /application/mysql]# rm -rf data/
# 4.恢复数据
[root@db02 /application/mysql]# innobackupex --copy-back /backup/2019-12-11_10-11-35/
# 5.授权
[root@db02 /application/mysql]# chown -R mysql.mysql /application/mysql/data/
增备
1）基于上一次备份进行增量
2）增量备份无法单独恢复，必须基于全备进行恢复
3）所有增量必须要按顺序合并到全备当中
增量备份
# 1.先做全备 之前全备删了
[root@db02 backup]# innobackupex --user=root --no-timestamp /backup/full_$(date +%F)
[root@db02 backup]# cat full_2019-12-11/xtrabackup_checkpoints
backup_type = full-backuped
from_lsn = 0
to_lsn = 2578215
last_lsn = 2586862
compact = 0
recover_binlog_info = 0
# 2.第一次，增量备份（基于全备）
[root@db02 backup]# innobackupex --user=root --no-timestamp --incremental --incremental-basedir=/backup/full_$(date +%F) /backup/inc_$(date +%F-%H)
--incremental:打开增量的开关
incremental-basedir=：上一次备份的目录 就是全备或者上一次增备
[root@db02 backup]# cat inc_2019-12-11-11/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 2578215
to_lsn = 2662633
last_lsn = 2662633
compact = 0
recover_binlog_info = 0
# 3.第二次，增量备份（基于第一次增备）
[root@db02 backup]# innobackupex --user=root --no-timestamp --incremental --incremental-basedir=/backup/inc_$(date +%F-%H -d "-1 hour") /backup/inc_$(date +%F-%H)
[root@db02 backup]# cat inc_2019-12-11-12/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 2662633
to_lsn = 2738509
last_lsn = 2739784
compact = 0
recover_binlog_info = 0
# 4.第三次，增量备份（基于第二次增备）
[root@db02 backup]# innobackupex --user=root --no-timestamp --incremental --incremental-basedir=/backup/inc_$(date +%F-%H -d "-1 hour") /backup/inc_$(date +%F-%H)
[root@db02 backup]# cat inc_2019-12-11-13/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 2738509
to_lsn = 2773700
last_lsn = 2777706
compact = 0
recover_binlog_info = 0
# 恢复思路：
1. 挂出维护页，停止当天的自动备份脚本
2. 检查备份：周日full+周一inc1+周二inc2，周三的完整二进制日志
3. 进行备份整理（细节），截取关键的二进制日志（从备份——误删除之前）
4. 测试库进行备份恢复及日志恢复
5. 应用进行测试无误，开启业务
6. 此次工作的总结
增备恢复
1）full+inc1+inc2
2）需要将inc1和inc2按顺序合并到full中
3）分步骤进行--apply-log
# 第0步：停库
[root@db02 backup]# /etc/init.d/mysqld stop
# 第一步：在全备中apply-log时，只应用redo，不应用undo
[root@db02 backup]# innobackupex --apply-log --redo-only /backup/full_2019-12-11/
# 第二步：合并inc1合并到full中，并且apply-log，只应用redo，不应用undo
[root@db02 backup]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_2019-12-11-11 /backup/full_2019-12-11/
# 第三步：合并inc2合并到full中，只做redo不做undo
[root@db02 backup]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_2019-12-11-12 /backup/full_2019-12-11/
# 第四步：将inc3合并到full中，redo undo都做
[root@db02 backup]# innobackupex --apply-log --incremental-dir=/backup/inc_2019-12-11-13 /backup/full_2019-12-11/
# 第五步：整体full执行apply-log，redo和undo都应用
[root@db02 backup]# innobackupex --apply-log /backup/full_2019-12-11/
# 第六步：恢复数据
[root@db02 backup]# rm -fr /application/mysql/data/
[root@db02 backup]# innobackupex --copy-back /backup/full_2019-12-11/
[root@db02 backup]# chown -R mysql.mysql /application/mysql/data
差异备
差异备份
优点：
1.备份方便
2.恢复方便
缺点：
1.重复次数多 占用磁盘空间大
# 0.模拟生产环境一直写入数据
[root@db01 ~]# vim a.sh
#!/bin/bash
num=1
while true;do
mysql -uroot -p123 -h10.0.0.51 -e 'insert into rep.rep values('"$num"');commit;'
let num++
sleep 1
done
# 1.停库
[root@db01 backup]# /etc/init.d/mysqld stop
# 2.全备
[root@db01 mysql]# innobackupex --user=root --password=123 --no-timestamp /backup/full
[root@db01 backup]# cat full/xtrabackup_checkpoints
backup_type = full-backuped
from_lsn = 0
to_lsn = 23436422
last_lsn = 23436422
compact = 0
recover_binlog_info = 0
# 3.第一次差异备份
[root@db01 mysql]# innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/full /backup/chayi1
[root@db01 backup]# cat chayi1/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23436422
to_lsn = 23445236
last_lsn = 23445236
compact = 0
recover_binlog_info = 0
# 4.第二次差异备份
[root@db01 mysql]# innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/full /backup/chayi2
按照增量备份basedir应该是chayi1路径 差异备份就还是基于全备 起始点就是全备的点
[root@db01 backup]# cat chayi2/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23436422
to_lsn = 23450202
last_lsn = 23450202
compact = 0
recover_binlog_info = 0
两次数据是不一样的
# 5.第三次差异备份
[root@db01 mysql]# innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/full /backup/chayi3
[root@db01 backup]# cat chayi3/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23436422
to_lsn = 23452936
last_lsn = 23453235
compact = 0
recover_binlog_info = 0
差异恢复
# 0.停库
[root@db01 backup]# /etc/init.d/mysqld stop
# 1.准备新环境
如果在同台服务器上 把之前的data目录改名为data.bak 不要删里面有数据
初始化一个新库
[root@db01 /application/mysql/scripts]# ./mysql_install_db --user=mysql --basedir=/application/mysql --datadir=/application/mysql/data
# 2.删除data目录
[root@db01 ~]# rm -rf /application/mysql/data/*
# 3.模拟CSR合并数据
full + chayi1 + chayi2 + chayi3
full：只做redo不做undo
chayi3：redo，undo都做 合并full
full：redo，undo都做
[root@db01 backup]# innobackupex --apply-log --redo-only /backup/full
[root@db01 backup]# innobackupex --apply-log --incremental-dir=/backup/chayi3 /backup/full
[root@db01 backup]# innobackupex --apply-log /backup/full
# 4.恢复数据
[root@db02 backup]# innobackupex --copy-back /backup/full
[root@db02 backup]# chown -R mysql.mysql /application/mysql/data
# 5.启动
[root@db01 backup]# /etc/init.d/mysqld start
Xtrabackup企业级增量恢复实战
背景：
某大型网站，mysql数据库，数据量500G，每日更新量20M-30M
备份策略：
xtrabackup，每周一0:00进行全备，周二到周日00:00进行增量备份。
故障场景：
周二下午2点出现数据库意外删除表操作。
如何恢复？
#思路：
全备到周一0:00 （周天24:00）
模拟周一数据变化
周二0:00增量备份 （周一24:00）
模拟周二数据变化
周三0:00增量备份 （周二24:00）
模拟周三数据变化 数据库被破坏
模拟环境
#起始环境
mysql> use backup
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t2 |
+------------------+
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
+------+
mysql> select * from t2;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
+------+
# 1.周日0:00 全备
[root@db02 ~]# mkdir /backup/
[root@db02 ~]# innobackupex --user=root --no-timestamp /backup/full_zhouri
# 2.模拟周一白天数据变化
mysql> use backup
mysql> insert into new values(1),(2),(3);
mysql> commit;
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
| 1 |
| 2 |
| 3 |
+------+
mysql> insert into t2 values(77),(88),(99);
mysql> commit;
mysql> select * from t2;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 77 |
| 88 |
| 99 |
+------+
# 3.周一0:00增量备份
[root@db02 ~]# innobackupex --user=root --no-timestamp --incremental --incremental-basedir=/backup/full_zhouri /backup/inc_zhouyi
# 4.模拟周二白天数据变化
mysql> use backup
mysql> create table t1(id int);
mysql> insert into t1 values(123),(456),(789);
mysql> commit;
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
mysql> select * from t1;
+------+
| id |
+------+
| 123 |
| 456 |
| 789 |
+------+
mysql> delete from t2 where id=77;
mysql> commit;
mysql> select * from t2;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 88 |
| 99 |
+------+
# 5.周二0:00增量备份
[root@db02 ~]# innobackupex --user=root --no-timestamp --incremental --incremental-basedir=/backup/inc_zhouyi /backup/inc_zhouer
# 6.查看下全备增备的文件对不对
[root@db02 ~]# ll /backup/
drwxr-x--- 9 root root 252 Dec 11 18:10 full_zhouri
drwxr-x--- 9 root root 278 Dec 11 18:25 inc_zhouer
drwxr-x--- 9 root root 278 Dec 11 18:20 inc_zhouyi
[root@db02 /backup/full_zhouri]# cat xtrabackup_checkpoints
backup_type = full-backuped
from_lsn = 0
to_lsn = 3251781
last_lsn = 3251781
compact = 0
recover_binlog_info = 0
[root@db02 /backup/full_zhouri]# cat /backup/inc_zhouyi/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 3251781
to_lsn = 3255477
last_lsn = 3255477
compact = 0
recover_binlog_info = 0
[root@db02 /backup/full_zhouri]# cat /backup/inc_zhouer/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 3255477
to_lsn = 3261454
last_lsn = 3261454
compact = 0
recover_binlog_info = 0
# 7.模拟周三白天数据变化 数据库被破坏
mysql> use backup
mysql> insert into t1 values(666),(888);
mysql> commit;
mysql> select * from t1;
+------+
| id |
+------+
| 123 |
| 456 |
| 789 |
| 666 |
| 888 |
+------+
mysql> drop table t2;
mysql> commit;
mysql> insert into new values(110),(120);
mysql> commit;
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
| 1 |
| 2 |
| 3 |
| 110 |
| 120 |
+------+
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
+------------------+
【这个时候发现t2表误删了！】
数据恢复
# 全量恢复
# 1.停库
[root@db02 ~]# /etc/init.d/mysqld stop
# 2.全备 并且apply-log，只redo不undo
[root@db02 ~]# innobackupex --apply-log --redo-only /backup/full_zhouri/
# 3.增1合并全备 并且apply-log，只redo不undo
[root@db02 ~]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_zhouyi /backup/full_zhouri/
# 4.增2合并全备，并且apply-log，redo undo都做
[root@db02 ~]# innobackupex --apply-log --incremental-dir=/backup/inc_zhouer /backup/full_zhouri/
# 5.全备整体执行apply-log，redo和undo都做
[root@db02 ~]# innobackupex --apply-log /backup/full_zhouri/
# 6.恢复数据到周二0:00
[root@db02 /application/mysql]# cp -a data/ ./data.bak #最好不要删 把他备份走 binlog在里面！
[root@db02 ~]# rm -rf /application/mysql/data/
[root@db02 ~]# innobackupex --copy-back /backup/full_zhouri/
[root@db02 ~]# chown -R mysql.mysql /application/mysql/data
[root@db02 ~]# /etc/init.d/mysqld start
mysql> use backup
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
| 1 |
| 2 |
| 3 |
+------+
mysql> select * from t1;
+------+
| id |
+------+
| 123 |
| 456 |
| 789 |
+------+
mysql> select * from t2;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 88 |
| 99 |
+------+
【表回来了 但是周三数据变化不在】
# 7.截取周二0:00到周三下午两时binlog
[root@db02 ~]# cat /backup/inc_zhouer/xtrabackup_binlog_info
mysql-bin.000001 2058
# 8.找之前的binlog 这个时候就要去备份里面找了
[root@db02 /application/mysql]# cd data.bak/
[root@db02 /application/mysql/data.bak]# mysqlbinlog --base64-output=decode-rows -vvv mysql-bin.000001|less
# 9.截取数据
2058 增备的结束点 新增数据的开始点
2292 drop前的点
[root@db02 ~]# mysqlbinlog --start-position=2058 --stop-position=2292 /application/mysql/data.bak/mysql-bin.000001 > /backup/inc_xinzeng1.sql
# 10.跳过删删表语句 截取数据
2416 drop的结束点 后面数据的开始点
2651 整个数据的结束点
[root@db02 ~]# mysqlbinlog --start-position=2416 --stop-position=2651 /application/mysql/data.bak/mysql-bin.000001 > /backup/inc_xinzeng2.sql
# 11.不记录二进制日志
[root@db02 /tmp]# mysql
mysql> set sql_log_bin=0;
# 12.进入backup库
mysql> use backup
# 13.导入新增数据
mysql> source /backup/inc_xinzeng1.sql
mysql> source /backup/inc_xinzeng2.sql
# 14.查看表 恢复成功
mysql> show tables;
+------------------+
| Tables_in_backup |
+------------------+
| new |
| t1 |
| t2 |
+------------------+
mysql> select * from t2;
+------+
| id |
+------+
| 1 |
| 2 |
| 3 |
| 88 |
| 99 |
+------+
mysql> select * from t1;
+------+
| id |
+------+
| 123 |
| 456 |
| 789 |
| 666 |
| 888 |
+------+
mysql> select * from new;
+------+
| id |
+------+
| 9 |
| 10 |
| 11 |
| 1 |
| 2 |
| 3 |
| 110 |
| 120 |
+------+
【关于何时启动mysql】
其实物理备份做好 截取完二进制文件之后启动就可以了 但是也可以不进数据库导入新增数据
整个导入成功之后启动数据库
再来一次 这次把时间戳也模拟了
背景：
某大型网站，mysql数据库，数据量500G，每日更新量100M-200M
备份策略：
xtrabackup，每周六0:00进行全备，周一到周五及周日00:00进行增量备份。
故障场景：
周三下午2点出现数据库意外删除表操作。
全备：1次
增备：4次
00:00~14:00增量数据
模拟数据
#跑个脚本 模拟生产环境持续插入数据
[root@db01 ~]# vim a.sh
#!/bin/bash
num=1
while true;do
mysql -uroot -p123 -h10.0.0.51 -e 'insert into rep.rep values('"$num"');commit;'
let num++
sleep 1
done
#全备：周五的 24点（周六00点）
innobackupex --user=root --password=123 --no-timestamp /backup/full_$(date +%F)
[root@db01 backup]# cat full_2019-12-14/xtrabackup_checkpoints
backup_type = full-backuped
from_lsn = 0
to_lsn = 23174130
last_lsn = 23174130
compact = 0
recover_binlog_info = 0
#第一次增备：周六的24点（周日的00点）
innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/full_$(date +%F -d "-1 day") /backup/inc_$(date +%F)
[root@db01 backup]# cat inc_2019-12-15/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23174130
to_lsn = 23199586
last_lsn = 23219800
compact = 0
recover_binlog_info = 0
#第二次增备：周日的24点（周一的00点）
innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/inc_$(date +%F -d "-1 day") /backup/inc_$(date +%F)
[root@db01 backup]# cat inc_2019-12-16/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23199586
to_lsn = 23250777
last_lsn = 23250777
compact = 0
recover_binlog_info = 0
#第三次增备：周一的24点（周二的00点）
innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/inc_$(date +%F -d "-1 day") /backup/inc_$(date +%F)
[root@db01 backup]# cat inc_2019-12-17/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23250777
to_lsn = 23250777
last_lsn = 23268489
compact = 0
recover_binlog_info = 0
#第四次增备：周二的24点（周三的00点）
innobackupex --user=root --password=123 --no-timestamp --incremental --incremental-basedir=/backup/inc_$(date +%F -d "-1 day") /backup/inc_$(date +%F)
[root@db01 backup]# cat inc_2019-12-18/xtrabackup_checkpoints
backup_type = incremental
from_lsn = 23250777
to_lsn = 23299475
last_lsn = 23299475
compact = 0
recover_binlog_info = 0
思路：
1.先停库
[root@db01 ~]# /etc/init.d/mysqld stop
2.准备新环境 初始化个新库
[root@db01 /application/mysql/scripts]# ./mysql_install_db --user=mysql --basedir=/application/mysql --datadir=/application/mysql/data
3.清空新环境的data目录
[root@db01 ~]# rm -fr /application/mysql/data
4.数据合并
- 将周六的全备，只做redo不做undo
[root@db01 backup]# innobackupex --apply-log --redo-only /backup/full_2019-12-14/
- 将周日的增备合并到全备中，只做redo不做undo
[root@db01 backup]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_2019-12-15 /backup/full_2019-12-14/
- 将周一的增备合并到全备中，只做redo不做undo
[root@db01 backup]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_2019-12-16 /backup/full_2019-12-14/
- 将周二的增备合并到全备中，只做redo不做undo
[root@db01 backup]# innobackupex --apply-log --redo-only --incremental-dir=/backup/inc_2019-12-17 /backup/full_2019-12-14/
- 将周三的增备合并到全备中，redo和undo都做
[root@db01 backup]# innobackupex --apply-log --incremental-dir=/backup/inc_2019-12-18 /backup/full_2019-12-14/
- 将合并后的full目录整体做一次redo和undo
[root@db01 backup]# innobackupex --apply-log /backup/full_2019-12-14/
恢复数据
[root@db01 mysql]# innobackupex --copy-back /backup/full_2019-12-14/
[root@db01 mysql]# chown -R mysql.mysql data
找数据位置点
#1.起始位置点
[root@db01 full_2019-12-14]# cat xtrabackup_binlog_info
mysql-bin.000001 13620168
#2.结束位置点
把之前出问题的data目录修改成data.bak了
[root@db01 full_2019-12-14]# mysqlbinlog --base64-output=decode-rows -vvv /application/mysql/data_bak/mysql-bin.000001 |less
13638936
截取数据
[root@db01 full_2019-12-14]# mysqlbinlog --start-position=13620168 --stop-position=13638936 /application/mysql/data_bak/mysql-bin.000001 > /backup/inc_00_14.sql
13639060
13691523
[root@db01 full_2019-12-14]# mysqlbinlog --start-position=13639060 --stop-position=13691523 /application/mysql/data_bak/mysql-bin.000001 > /backup/inc_14.sql
恢复业务
- 应用割接(修改代码，连接数据库的IP)
- 备份表，导入旧库
[root@db01 mysql]# mysqldump zls1 student2 > /backup/student2.sql
[root@db01 mysql]# mysql zls1 < /backup/student2.sql
浙公网安备 33010602011771号