[ Mongodb ] 全量备份和增量备份

1. 前言

由于线上的mongodb 数据体量越来越大，如果没有完善的备份方案，发生故障势必造成业务很长时间的暂停。参考了网上方案，写出以下总结和备份方案：

备份方案分为两种：全备和增量备份，二者结合起来使用。

 参考链接：https://www.cnblogs.com/xuliuzai/p/9917137.html  感谢作者的分享。

2. 构建mongodb 副本集测试环境

首先在测试环境进行测试，过程如下：

　　测试机：192.168.118.16  系统：CentOS 7

首先搭建mongodb 副本集（为了和线上环境保持一致）这里使用 mongodb 3.6 的版本，建议和生产环境相同的版本。

Mongdb 没啥安装的， 开箱即用。副本集参考链接：https://www.cnblogs.com/hukey/p/5769548.html

rs0:PRIMARY> rs.isMaster();
{
	"hosts" : [
		"192.168.118.16:27017",
		"192.168.118.16:27018",
		"192.168.118.16:27019"
	],
… 
…

副本集创建成功。

接下来，向集群里写入数据：

rs0:PRIMARY> for(var i=1;i<=10000;i++) db.users.insert({id:i, name:"hukey",city:"xi'an"});
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> show dbs;
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
rs0:PRIMARY> use test
switched to db test
rs0:PRIMARY> db.users.count();
10000

 写入了 1W 条数据。

准备工作完成。

3. mongodb 全量备份及恢复

全备脚本 [ mongodb_back_all.sh ] 如下：

#!/bin/bash
# Author:hukey

host='192.168.118.16'
port='27017'
sourcepath='/mongodb/bin'
targetpath='/mongodb/backup'
nowtime=$(date "+%Y%m%d")



start(){
    $sourcepath/mongodump --host $host --port $port --oplog --gzip --out ${targetpath}/${nowtime}
}

execute(){
echo "=========================$(date) backup all mongodb back start  ${nowtime}========="
start
if [ $? -eq 0 ];then
    echo "The MongoDB BackUp Successfully!"
else
    echo "The MongoDB BackUp Failure"
fi
}

if [ ! -d "${targetpath}/${nowtime}" ];then
    mkdir -p "${targetpath}/${nowtime}"
fi

execute

backtime=$(date -d '-7 days' "+%Y%m%d")
if [ -d "${targetpath}/${backtime}/" ];then
    rm -rf "${targetpath}/${backtime}/"
    echo "=======${targetpath}/${backtime}/===删除完毕=="
fi

echo "========================= $(date) backup all mongodb back end ${nowtime}========="

全库还原脚本 [ mongodb_restore_all.sh ] 如下：

#!/bin/bash
# Author:hukey

echo -e "33[31;1m*****[ Mongodb ] 全库恢复脚本*****33[0m"
host=192.168.118.16
mongo_bin=/mongodb/bin/
backpath='/mongodb/backup'


echo -e "33[32;1m[ 选择要恢复全库的日期 ] 33[0m"
for backfile in `ls $backpath`; do
    echo $backfile
done

read -p ">>>" date_bak

if [[ $date_bak == "" ]] || [[ $date_bak == '.' ]] || [[ $date_bak == '..' ]]; then 
    echo -e "33[31;1m输入不能为特殊字符.33[0m"
    exit 1
fi


if [ -d $backpath/$date_bak ];then
    read -p "请确认是否恢复全库备份[y/n]:" choice

    if [ "$choice" == "y" ];then
        echo -e "33[32;1m正在恢复全库备份，请稍后...33[0m"
        $mongo_bin/mongorestore --host $host --port 27017 --oplogReplay --gzip $backpath/$date_bak/
        if [ $? -eq 0 ];then
            echo -e "33[32;1m--------全库恢复成功.--------33[0m"
        else
            echo -e "33[31;1m恢复失败,请手动检查!33[0m"
            exit 3
        fi
    else
        exit 2
    fi
else
    echo "33[31;1m输入信息错误.33[0m"
    exit 1
fi

执行全量备份脚本：

[root@192.168.118.16 /mongodb/script]#sh mongodb_back_all.sh 
=========================Thu Sep 12 11:57:32 CST 2019 backup all mongodb back start  20190912=========
2019-09-12T11:57:32.863+0800	writing admin.system.version to 
2019-09-12T11:57:32.866+0800	done dumping admin.system.version (1 document)
2019-09-12T11:57:32.867+0800	writing test.users to 
2019-09-12T11:57:32.955+0800	done dumping test.users (10000 documents)
2019-09-12T11:57:32.956+0800	writing captured oplog to 
2019-09-12T11:57:32.975+0800		dumped 1 oplog entry
The MongoDB BackUp Successfully!
========================= Thu Sep 12 11:57:32 CST 2019 backup all mongodb back end 20190912=========

查看备份数据：

[root@192.168.118.16 /mongodb/script]#ls /mongodb/backup/20190912/
admin  oplog.bson  test

在测试全库还原之前，首先需要清库数据（注意：本次操作是在测试环境）

rs0:PRIMARY> use test;
switched to db test
rs0:PRIMARY> db.users.count();
10000
rs0:PRIMARY> db.dropDatabase();
{
	"dropped" : "test",
	"ok" : 1,
	"operationTime" : Timestamp(1568264437, 2),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1568264437, 2),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

执行全库恢复脚本：

[root@192.168.118.16 /mongodb/script]#sh mongodb_restore_all.sh 
*****[ Mongodb ] 全库恢复脚本*****
[ 选择要恢复全库的日期 ] 
20190912
>>>20190912
请确认是否恢复全库备份[y/n]:y
正在恢复全库备份，请稍后...
2019-09-12T13:43:58.956+0800	preparing collections to restore from
2019-09-12T13:43:58.959+0800	reading metadata for test.users from /mongodb/backup/20190912/test/users.metadata.json.gz
2019-09-12T13:43:59.019+0800	restoring test.users from /mongodb/backup/20190912/test/users.bson.gz
2019-09-12T13:44:01.950+0800	[#################.......]  test.users  28.0KB/37.9KB  (73.9%)
2019-09-12T13:44:04.083+0800	[########################]  test.users  37.9KB/37.9KB  (100.0%)
2019-09-12T13:44:04.083+0800	no indexes to restore
2019-09-12T13:44:04.084+0800	finished restoring test.users (10000 documents)
2019-09-12T13:44:04.084+0800	replaying oplog
2019-09-12T13:44:04.084+0800	done
--------全库恢复成功.--------

全库的备份和还原已经实现，可以通过 crontab 来制定计划任务触发。

4. mongodb 增量备份及恢复

增量备份的思路是通过 oplog 来实现的，大家可以通过文档搜索了解。
直接上脚本：

增量备份 [ mongodb_backup_incremental.sh ] 脚本

#!/bin/bash
# Author:hukey
command_linebin='/mongodb/bin/mongo'
port=27017

if [ ! -d "/mongodb/backup/mongodbOplog_bak/mongo-$port" ];then
    mkdir -p /mongodb/backup/mongodbOplog_bak/mongo-$port
fi

if [ ! -d "/mongodb/backup/mongodbOplog_bak/log-$port" ];then
    mkdir -p /mongodb/backup/mongodbOplog_bak/log-$port
fi

bkdatapath=/mongodb/backup/mongodbOplog_bak/mongo-$port
bklogpath=/mongodb/backup/mongodbOplog_bak/log-$port

logfilename=$(date +"%Y%m%d")

echo "===MongoDB 端口为" $port "的差异备份开始，开始时间为" $(date -d today +"%Y%m%d%H%M%S")

paramBakEndDate=$(date +%s)
echo "===本次备份时间参数中的结束时间为：" $paramBakEndDate

diffTime=$(expr 65 * 60)
echo "===备份设置的间隔时间为：" $diffTime

paramBakStartDate=$(expr $paramBakEndDate - $diffTime)
echo "===本次备份时间参数中的开始时间为：" $paramBakStartDate

diffTime=$(expr 61 * 60)
paramAfterBakRequestStartDate=$(expr $paramBakEndDate - $diffTime)
echo "===为保证备份的连续性,本次备份后,oplog中的开始时间需小于：" $paramAfterBakRequestStartDate

bkfilename=$(date -d today +"%Y%m%d%H%M%S")

command_line="${command_linebin} 192.168.118.16:27017"

opmes=$(/bin/echo "db.printReplicationInfo()" | $command_line --quiet)

echo $opmes > /tmp/opdoctime$port.tmplog
opbktmplogfile=/tmp/opdoctime$port.tmplog
opstartmes=$(grep "oplog first event time" $opbktmplogfile | awk -F 'CST' '{print $1}' | awk -F 'oplog first event time: '  '{print $2}' | awk -F ' GMT' '{print $1}'  )
oplogRecordFirst=$(date -d "$opstartmes"  +%s)
echo "===oplog集合记录的开始时间为[格式化]：" $oplogRecordFirst
if [ $oplogRecordFirst -le $paramBakStartDate ]; then
    echo "Message --检查设置备份时间合理。备份参数的开始时间在oplog记录的时间范围内。"
else 
    echo "Fatal Error --检查设置的备份时间不合理合理。备份参数的开始时间不在oplog记录的时间范围内。请调整oplog size或调整备份频率。本次备份可以持续进行，但还原时数据完整性丢失。"
fi

/mongodb/bin/mongodump -h 192.168.118.16 --port $port  -d local -c oplog.rs  --query '{ts:{$gte:Timestamp('$paramBakStartDate',1),$lte:Timestamp('$paramBakEndDate',9999)}}' -o $bkdatapath/mongodboplog$bkfilename


opmes=$(/bin/echo "db.printReplicationInfo()" | $command_line --quiet)
echo $opmes > /tmp/opdoctime$port.tmplog
opbktmplogfile=/tmp/opdoctime$port.tmplog
opstartmes=$(grep "oplog first event time" $opbktmplogfile | awk -F 'CST' '{print $1}' | awk -F 'oplog first event time: '  '{print $2}' | awk -F ' GMT' '{print $1}'  )
oplogRecordFirst=$(date -d "$opstartmes"  +%s)
echo "===执行备份后,oplog集合记录的开始时间为[时间格式化]:" $oplogRecordFirst

if [ $oplogRecordFirst -le $paramAfterBakRequestStartDate ]; then
    echo "Message --备份后，检查oplog集合中数据的开始时间，即集合中最早的一笔数据，时间不小于61分钟的时间（即参数 paramAfterBakRequestStartDate）。这样可以保证每个增量备份含有最近一个小时的全部op操作，满足文件的持续完整性，逐个还原无丢失数据风险。"
else
    echo "Fatal Error --备份后，检查oplog集合的涵盖的时间范围过小（小于61min）。设置的备份时间不合理合理，备份后的文件不能完全涵盖最近60分钟的数据。请调整oplog size或调整备份频率。本次备份可以持续进行，但还原时数据完整性丢失。"
fi

if [ -d "$bkdatapath/mongodboplog$bkfilename" ]
then
    echo "Message --检查此次备份文件已经产生.文件信息为:" $bkdatapath/mongodboplog$bkfilename >> $bklogpath/$logfilename.log
else 
    echo "Fatal Error --备份过程已执行，但是未检测到备份产生的文件，请检查！" >> $bklogpath/$logfilename.log
fi

keepbaktime=$(date -d '-3 days' "+%Y%m%d%H")*
if [ -d $bkdatapath/mongodboplog$keepbaktime ]; then
    rm -rf $bkdatapath/mongodboplog$keepbaktime
    echo "Message -- $bkdatapath/mongodboplog$keepbaktime 删除完毕" >> $bklogpath/$logfilename.log
fi

echo "===MongoDB 端口为" $port "的差异备份结束，结束时间为：" $(date -d today +"%Y%m%d%H%M%S")

这个脚本比较长，需要注意一个变量： diffTime

第一次定义这个变量的时候，是为了定义备份的时长，从此刻到之前 65 * 60ms 之前的时间，也就是备份从现在到之前 1小时5分这段时间的增量；

第二次定义这个变量的时候，是为了避免数据增长过快，覆盖了还未备份的数据的，比较的依据是 mongodb db.printReplicationInfo(); 的 oplog first event time 时间。

这两个定义的时间可灵活调整。

增量备份还原 [ mongodb_backup_incremental.sh ] 脚本

#!/bin/bash
# Author:hukey

host=192.168.118.16
port=27017
mongo_bin=/mongodb/bin/
backpath='/mongodb/backup/mongodbOplog_bak/mongo-27017'


echo -e "33[31;1m*****[ Mongodb ] 增量恢复脚本*****33[0m"

echo -e "33[32;1m[ 选择要恢复增量的日期(格式：年月日时分秒) ] 33[0m"
for time_file in `ls $backpath`; do
    echo $time_file
done

read -p ">>>" date_bak
if [[ $date_bak == "" ]] || [[ $date_bak == '.' ]] || [[ $date_bak == '..' ]]; then 
    echo -e "33[31;1m输入不能为特殊字符.33[0m"
    exit 1
fi
if [ -d $backpath/$date_bak ]; then
    read -p "请确认是否恢复[$date_bak]增量备份[y/n]:" choice
    if [ "$choice" == "y" ];then
        mkdir -p /tmp/mongodb/ && cp -a $backpath/$date_bak/local/oplog.rs.bson /tmp/mongodb/oplog.bson
        $mongo_bin/mongorestore --host $host --port $port --oplogReplay /tmp/mongodb/ && rm -rf /tmp/mongodb/
        if [ $? -eq 0 ];then
            echo -e "33[32;1m--------[$date_bak]增量恢复成功.--------33[0m"
        else
            echo -e "33[31;1m恢复失败,请手动检查!33[0m"
            exit 3
        fi
    else
        exit 2
    fi
else
    echo -e "33[31;1m输入信息错误.33[0m"
    exit 1
fi

测试下增量备份脚本和还原增量脚本

（1）首先写入一批数据到 mongodb

rs0:PRIMARY> for(var i=1;i<=100;i++) db.users.insert({id:i,name:"hukey"});
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> use test;
switched to db test
rs0:PRIMARY> db.users.count();
100

写入了 100 条数据成功。

（2）执行增量备份脚本

[root@192.168.118.16 /mongodb/script]#sh mongodb_backup_incremental.sh 
===MongoDB 端口为 27017 的差异备份开始，开始时间为 20190912141545
===本次备份时间参数中的结束时间为： 1568268945
===备份设置的间隔时间为： 3900
===本次备份时间参数中的开始时间为： 1568265045
===为保证备份的连续性,本次备份后,oplog中的开始时间需小于： 1568265285
===oplog集合记录的开始时间为[格式化]： 1568260252
Message --检查设置备份时间合理。备份参数的开始时间在oplog记录的时间范围内。
2019-09-12T14:15:48.648+0800	Failed: error connecting to db server: no reachable servers
===执行备份后,oplog集合记录的开始时间为[时间格式化]: 1568260252
Message --备份后，检查oplog集合中数据的开始时间，即集合中最早的一笔数据，时间不小于61分钟的时间（即参数 paramAfterBakRequestStartDate）。这样可以保证每个增量备份含有最近一个小时的全部op操作，满足文件的持续完整性，逐个还原无丢失数据风险。
===MongoDB 端口为 27017 的差异备份结束，结束时间为： 20190912141548

（3）再次新增 100 条数据到 mongodb

rs0:PRIMARY> use test
switched to db test
rs0:PRIMARY> for(var i=1;i<=100;i++) db.users.insert({id:i,name:"xiaofei"});
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.users.count();
200

（4）再次执行增量备份

[root@192.168.118.16 /mongodb/script]#sh mongodb_backup_incremental.sh 
===MongoDB 端口为 27017 的差异备份开始，开始时间为 20190912141728
===本次备份时间参数中的结束时间为： 1568269048
===备份设置的间隔时间为： 3900
===本次备份时间参数中的开始时间为： 1568265148
===为保证备份的连续性,本次备份后,oplog中的开始时间需小于： 1568265388
===oplog集合记录的开始时间为[格式化]： 1568260252
Message --检查设置备份时间合理。备份参数的开始时间在oplog记录的时间范围内。
2019-09-12T14:17:31.696+0800	Failed: error connecting to db server: no reachable servers
===执行备份后,oplog集合记录的开始时间为[时间格式化]: 1568260252
Message --备份后，检查oplog集合中数据的开始时间，即集合中最早的一笔数据，时间不小于61分钟的时间（即参数 paramAfterBakRequestStartDate）。这样可以保证每个增量备份含有最近一个小时的全部op操作，满足文件的持续完整性，逐个还原无丢失数据风险。
===MongoDB 端口为 27017 的差异备份结束，结束时间为： 20190912141731

到此，已知：

第一次增量备份前，数据是 100 条

第二次增量备份前，数据是 200 条

（5）删除 mongodb 数据，恢复第一次增量备份数据

rs0:PRIMARY> db.users.count();
200
rs0:PRIMARY> db.dropDatabase();
{
	"dropped" : "test",
	"ok" : 1,
	"operationTime" : Timestamp(1568270110, 2),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1568270110, 2),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
rs0:PRIMARY> 
rs0:PRIMARY> show dbs;
admin   0.000GB
config  0.000GB
local   0.001GB

执行恢复增量备份的脚本：

[root@192.168.118.16 /mongodb/script]#sh mongodb_restore_incremental.sh 
*****[ Mongodb ] 增量恢复脚本*****
[ 选择要恢复增量的日期(格式：年月日时分秒) ] 
mongodboplog20190912144121
mongodboplog20190912144403
>>>mongodboplog20190912144121
请确认是否恢复[mongodboplog20190912144121]增量备份[y/n]:y
2019-09-12T14:44:34.534+0800	preparing collections to restore from
2019-09-12T14:44:34.534+0800	replaying oplog
2019-09-12T14:44:37.531+0800	oplog  1.12MB
2019-09-12T14:44:40.021+0800	oplog  1.79MB
2019-09-12T14:44:40.021+0800	done
--------[mongodboplog20190912144121]增量恢复成功.--------

此时，mongodb 应该是 100 条数据才对，验证下：

rs0:PRIMARY> use test;
switched to db test
rs0:PRIMARY> db.users.count();
100

数据正确，执行第二次增量备份的还原：

[root@192.168.118.16 /mongodb/script]#sh mongodb_restore_incremental.sh 
*****[ Mongodb ] 增量恢复脚本*****
[ 选择要恢复增量的日期(格式：年月日时分秒) ] 
mongodboplog20190912144121
mongodboplog20190912144403
>>>mongodboplog20190912144403
请确认是否恢复[mongodboplog20190912144403]增量备份[y/n]:y
2019-09-12T14:45:41.886+0800	preparing collections to restore from
2019-09-12T14:45:41.887+0800	replaying oplog
2019-09-12T14:45:44.882+0800	oplog  1.04MB
2019-09-12T14:45:47.882+0800	oplog  1.75MB
2019-09-12T14:45:50.341+0800	oplog  1.81MB
2019-09-12T14:45:50.341+0800	done
--------[mongodboplog20190912144403]增量恢复成功.--------

此时，mongodb 应该是 200 条数据才对，验证下：

rs0:PRIMARY> use test;
switched to db test
rs0:PRIMARY> db.users.count();
200

正确，数据恢复没有问题。增量备份完成。

5. 后记

对于线上生产环境，目前的备份解决方案是：

　　全量备份 1 周执行一次，增量备份每天执行一次。

　　后期准备在建立一个备用的副本集，每天都会将备份数据还原到 新建的副本集中，进行数据备份的校验，准备还是通过脚本来实现。后期在编写。