02 . MongoDB复制集,分片集,备份与恢复

复制集

MongoDB复制集RS(ReplicationSet): 基本构成是1主2从的结构，自带互相监控投票机制(Raft(MongoDB)Paxos(mysql MGR 用的是变种))

如果发生主库宕机, 复制集内部会进行投票选举，选择一个新的主库替代原有主库对外提供服务。同时复制集会自动通知。客户端程序, 主库已经发生切换了, 应用就会连接到新的主库;

4.png

配置Replication Set

1 . 单台配置多实例

// 多套目录
su - mongod
mkdir -p /mongodb/{28017,28018,28019,28020}/{conf,data,log,bin}

2 . 配置文件

cat > /mongodb/28017/conf/mongod.conf <<EOF
systemLog:
  destination: file
  path: /mongodb/28017/log/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /mongodb/28017/data
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger: # 引擎功能有事务、行级锁(4.0以后事务支持才完全)
    engineConfig:
      cacheSizeGB: 1  # 缓冲功能,缓冲区大小
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
processManagement:
  fork: true
net:
  bindIp: 192.168.0.4,127.0.0.1
  port: 28017
replication: 							# 复制集相关的配置
  oplogSizeMB: 2048 			# 和二进制相关的日志，这里设置两个G
  replSetName: my_repl	  # 复制集的名
EOF

cp /mongodb/28017/conf/mongod.conf /mongodb/28018/conf/mongod.conf
cp /mongodb/28017/conf/mongod.conf /mongodb/28019/conf/mongod.conf
cp /mongodb/28017/conf/mongod.conf /mongodb/28020/conf/mongod.conf
sed -i 's#28017#28018#g' /mongodb/28018/conf/mongod.conf
sed -i 's#28017#28019#g' /mongodb/28019/conf/mongod.conf
sed -i 's#28017#28020#g' /mongodb/28020/conf/mongod.conf

启动多个实例

mongod -f /mongodb/28017/conf/mongod.conf
mongod -f /mongodb/28018/conf/mongod.conf
mongod -f /mongodb/28019/conf/mongod.conf
mongod -f /mongodb/28020/conf/mongod.conf

关闭多个示例

mongod -f /mongodb/28017/conf/mongod.conf --shutdown
mongod -f /mongodb/28018/conf/mongod.conf --shutdown
mongod -f /mongodb/28019/conf/mongod.conf --shutdown
mongod -f /mongodb/28020/conf/mongod.conf --shutdown

查看4个端口是否启动成功

netstat -lnp|grep 280

配置普通复制集

1主2从

mongo --port 28017 admin
// _id和配置文件的replication.replSetName保持一致
config = {_id: 'my_repl', members: [
                          {_id: 0, host: '192.168.0.4:28017'},
                          {_id: 1, host: '192.168.0.4:28018'},
                          {_id: 2, host: '192.168.0.4:28019'}]
}

// 初始化
rs.initiate(config) 

// 查询复制集状态
rs.status();

配置1主1从1个arbiter

arbiter节点：主要负责选主过程中的投票，但是不存储任何数据，也不提供任何服务

mongo --port 28017 admin
config = {_id: 'my_repl', members: [
                          {_id: 0, host: '10.9.119.18:28017'},
                          {_id: 1, host: '10.9.119.18:28018'},
                          {_id: 2, host: '10.9.119.18:28019',"arbiterOnly":true}]
          }    

rs.initiate(config) 

rs.status();

添加arbiter节点

连接到主节点
>rs.status(); 查看哪个是主节点"stateStr" : "PRIMARY"

mongo --port 28017 admin

添加仲裁节点
>rs.addArb("192.168.0.4:28020")

查看节点状态
>rs.isMaster()

        "hosts" : [
                "192.168.0.4:28017",
                "192.168.0.4:28018",
                "192.168.0.4:28019"
        ],
        "arbiters" : [
                "192.168.0.4:28020"
        ],

删除节点和新增节点

rs.remove("192.168.0.4:28018"); // 删除一个节点
rs.isMaster() // 查看节点状态
rs.add("192.168.0.4:28018")// 新增从节点
rs.isMaster() // 查看节点状态

特殊从节点

介绍:

** arbiter节点：主要负责选主过程中的投票，但是不存储任何数据，也不提供任何服务

hidden节点：隐藏节点，不参与选主，也不对外提供服务。

delay节点： 延时节点，数据落后于主库一段时间，因为数据是延时的，也不应该提供服务或参与选主，所以通常会配合hidden(隐藏), 一般用来解决逻辑损坏问题;**

**一般情况下会将delay+hidden一起配置使用**

配置延时节点（一般延时节点也配置成hidden）

cfg=rs.conf()
cfg.members[2].priority=0 		//这个[2]是什么意思，从rs.conf()的"members"开始数(从0开始),跟id没关系
cfg.members[2].hidden=true		// 隐藏起来,不参与业务
cfg.members[2].slaveDelay=120 // 延时从库
rs.reconfig(cfg)    

>rs.conf(); 如以下的"_id" : 3 就是[2]
{
        "_id" : "my_repl",
        "version" : 4,
        "protocolVersion" : NumberLong(1),
        "members" : [
        		{
                        "_id" : 0,
                        "host" : "192.168.0.4:28017",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },
                {
                        "_id" : 1,
                        "host" : "192.168.0.4:28018",
                        "arbiterOnly" : false,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 1,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },
                {
                        "_id" : 3,
                        "host" : "192.168.0.4:28020",
                        "arbiterOnly" : true,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 0,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },
 ...

配置延时节点前
                {
                        "_id" : 3,
                        "host" : "192.168.0.4:28020",
                        "arbiterOnly" : true,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 0,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },
-----------------------------------------------------------------
配置延时节点后
				{
                        "_id" : 3,
                        "host" : "192.168.0.4:28020",
                        "arbiterOnly" : true,
                        "buildIndexes" : true,
                        "hidden" : true,
                        "priority" : 0,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(120),
                        "votes" : 1
                },

取消延时节点配置

cfg=rs.conf()
cfg.members[2].priority=1
cfg.members[2].hidden=false
cfg.members[2].slaveDelay=0
rs.reconfig(cfg)

rs.conf()查看取消配置后
                {
                        "_id" : 3,
                        "host" : "192.168.0.4:28020",
                        "arbiterOnly" : true,
                        "buildIndexes" : true,
                        "hidden" : false,
                        "priority" : 0,
                        "tags" : {

                        },
                        "slaveDelay" : NumberLong(0),
                        "votes" : 1
                },

分片集群

分片集群原理

MongoDB Sharding Cluster 分片集群

分片是一种用于在多台计算机之间分配数据的方法; MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署;

具有大数据集或高吞吐量应用程序的数据库系统可能会挑战单个服务器的容量;

例如，高查询率可能会耗尽服务器的CPU容量;

大于系统RAM的工作集大小会增加磁盘驱动器的I/O容量;

解决系统增长的方法有两种：垂直缩放和水平缩放;

垂直扩展

​ 涉及增加单个服务器的容量，例如使用功能更强大的CPU，添加更多RAM或增加存储空间量, 可用技术的局限性可能会限制一台计算机对于给定的工作负载没有足够的功能, 此外, 基于云的提供程序具有基于可用硬件配置的严格上限, 结果, 对于垂直缩放有实际的最大值;

水平扩展

涉及划分系统数据集并在多台服务器上加载, 并添加其他服务器以根据需要增加容量, 虽然单台计算机的整体速度或容量可能不高，但是每台计算机只能处理全部工作量的一部分,因此与单台高速大容量服务器相比, 可能会提供更高的效率, 扩展部署的容量仅需要根据需要添加其他服务器, 这可以比单台机器的高端硬件降低总体成本, 折衷方案是增加基础结构和部署维护的复杂性;

MongoDB通过分片(sharding)支持水平扩展

MongoDB分片集群由以下组件组成:

shard: 每个碎片包含碎片数据的子集; 每个分片都可以部署为[副本集(replica-set);

mongos: **mongos**充当查询路由器, 在客户端应用程序和分片群集之间提供接口;

config-servers: 配置服务器存储集群的元数据和配置设置, 从MongoDB 3.4开始，配置服务器必须部署为副本集(CSRS);

分片集群中组件的交互:

3.png

如何存储的

mongo的自动分片就是靠Chunk迁移,拆分实现;

2.png

均衡特性

chunk分裂及迁移

随着数据增长,其中的数据大小超过了配置的chunk size, 默认是64M, 则这个chunk就会分裂成两个, 数据的增长会让chunk分裂的越来越多, 这时候, 各个shard上的chunk数量就会不平衡, 这时,mongos中的一个组件balancer就会执行自动平衡, 把chunk从chunk数量最多的shard节点挪到最少的节点;

1.png

分片键shard key

必须为分片 collection 定义分片键

基于一个或多个列( 类似一个索引)

分片键定义数据空间;

想象key space 类似一条线上一个点数据

一个key range是一条线上一段数据;

我们可以按照分片键进行Range和Hash分片;

分片注意事项

分片键是不可变

分片键必须有索引

分片键大小限制512bytes

分片键用于路由查询

Mongo不接受已进行collection级分片的collection上插入无分片键的文档(也不支持空值插入)

配置分片集群

机器规划

10个实例：38017-38026
	mongos：38017
	config-servers:			3台构成的复制集（1主两从，不支持arbiter）38018-38020（复制集名字configsvr）
	shard:
                sh1：38021-28023    （1主两从，其中一个节点为arbiter，复制集名字sh1）
                sh2：38024-38026    （1主两从，其中一个节点为arbiter，复制集名字sh2）

shard复制集配置

// 创建目录
mkdir -p /mongodb/{38021,38022,38023,38024,38025,38026}/{conf,data,log}

// 配置文件
---------------------------sh1---------------------------
cat > /mongodb/38021/conf/mongodb.conf<<EOF
systemLog:
  destination: file
  path: /mongodb/38021/log/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /mongodb/38021/data
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
net:
  bindIp: 0.0.0.0
  port: 38021
replication:
  oplogSizeMB: 2048
  replSetName: sh1
sharding:
  clusterRole: shardsvr
processManagement:
  fork: true
EOF

cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38022/conf/
cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38023/conf/
sed -i 's#38021#38022#g' /mongodb/38022/conf/mongodb.conf
sed -i 's#38021#38023#g' /mongodb/38023/conf/mongodb.conf 

---------------------------sh2---------------------------
cat > /mongodb/38024/conf/mongodb.conf<<EOF
systemLog:
  destination: file
  path: /mongodb/38024/log/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /mongodb/38024/data
  directoryPerDB: true
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
net:
  bindIp: 0.0.0.0
  port: 38024
replication:
  oplogSizeMB: 2048
  replSetName: sh2
sharding:
  clusterRole: shardsvr
processManagement:
  fork: true
EOF

cp  /mongodb/38024/conf/mongodb.conf  /mongodb/38025/conf/
cp  /mongodb/38024/conf/mongodb.conf  /mongodb/38026/conf/
sed -i 's#38024#38025#g' /mongodb/38025/conf/mongodb.conf
sed -i 's#38024#38026#g' /mongodb/38026/conf/mongodb.conf 

启动所有节点
mongod -f  /mongodb/38021/conf/mongodb.conf
mongod -f  /mongodb/38022/conf/mongodb.conf
mongod -f  /mongodb/38023/conf/mongodb.conf
mongod -f  /mongodb/38024/conf/mongodb.conf
mongod -f  /mongodb/38025/conf/mongodb.conf
mongod -f  /mongodb/38026/conf/mongodb.conf 

搭建复制集
---------------------------sh1---------------------------
mongo --port 38021 admin

config = {_id: 'sh1', members: [
                          {_id: 0, host: '192.168.0.5:38021'},
                          {_id: 1, host: '192.168.0.5:38022'},
                          {_id: 2, host: '192.168.0.5:38023',"arbiterOnly":true}]
           }

rs.initiate(config)
---------------------------sh2---------------------------
mongo --port 38024  admin

config = {_id: 'sh2', members: [
                          {_id: 0, host: '192.168.0.5:38024'},
                          {_id: 1, host: '192.168.0.5:38025'},
                          {_id: 2, host: '192.168.0.5:38026',"arbiterOnly":true}]
           }

rs.initiate(config)

config-servers节点配置

** config-servers可以是一个节点，官方建议复制集。config-servers不能有arbiter;

mongodb 3.4之后，虽然要求config-servers为replica set，但是不支持arbiter;**

# 创建目录
mkdir -p /mongodb/{38018,38019,38020}/{conf,data,log}

# 配置文件
cat > /mongodb/38018/conf/mongodb.conf <<EOF
systemLog:
  destination: file
  path: /mongodb/38018/log/mongodb.conf
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /mongodb/38018/data
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
net:
  bindIp: 0.0.0.0
  port: 38018
replication:
  oplogSizeMB: 2048
  replSetName: configReplSet
sharding:
  clusterRole: configsvr
processManagement:
  fork: true
EOF

cp /mongodb/38018/conf/mongodb.conf /mongodb/38019/conf/
cp /mongodb/38018/conf/mongodb.conf /mongodb/38020/conf/
sed -i 's#38018#38019#g' /mongodb/38019/conf/mongodb.conf
sed -i 's#38018#38020#g' /mongodb/38020/conf/mongodb.conf

# 启动所有节点
mongod -f /mongodb/38018/conf/mongodb.conf
mongod -f /mongodb/38019/conf/mongodb.conf
mongod -f /mongodb/38020/conf/mongodb.conf

# 配置复制集
mongo --port 38018 admin

config = {_id: 'configReplSet', members: [
                          {_id: 0, host: '192.168.0.5:38018'},
                          {_id: 1, host: '192.168.0.5:38019'},
                          {_id: 2, host: '192.168.0.5:38020'}]
           }
rs.initiate(config)

mongos节点配置

# 创建目录
mkdir -p /mongodb/38017/{conf,log}

# 配置文件
cat >/mongodb/38017/conf/mongos.conf<<EOF
systemLog:
  destination: file
  path: /mongodb/38017/log/mongos.log
  logAppend: true
net:
  bindIp: 0.0.0.0
  port: 38017
sharding:
  configDB: configReplSet/192.168.0.5:38018,192.168.0.5:38019,192.168.0.5:38020
processManagement:
  fork: true
EOF

# 启动mongos
mongos -f /mongodb/38017/conf/mongos.conf

# 连接到其中一个mongos的admin库
mongo --port 38017 admin

# 添加分片
db.runCommand( { addshard : "sh1/192.168.0.5:38021,192.168.0.5:38022,192.168.0.5:38023",name:"shard1"} )
db.runCommand( { addshard : "sh2/192.168.0.5:38024,192.168.0.5:38025,192.168.0.5:38026",name:"shard2"} )

# 列出分片
db.runCommand( { listshards : 1 } )

# 分片集群整体状态查看
sh.status();

分片策略

RANGE分片配置及测试

Ranged根据分片键值将数据划分为多个范围。然后，根据分片键值为每个块分配一个范围

test库下的vast大表进行手工分片

# 激活数据库分片功能
mongo --port 38017 admin

db.runCommand( { enablesharding : "test" } )	// ( { enablesharding : "数据库名称" } )

# 指定分片建对集合分片,创建索引
use test
>db.vast.ensureIndex( { id: 1 } )

# 开启分片
use admin
>db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )

# 集合分片验证
use test
>for(i=1;i<1000000;i++){ db.vast.insert({"id":i,"name":"ruan","age":23,"date":new Date()}); }
>db.vast.stats()

# 分片结果测试
连接sh1
mongo --port 38021
db.vast.count();

# 连接sh2
mongo --port 38024
db.vast.count();

哈希分片

哈希分片涉及计算分片键字段值的哈希值。然后，根据散列的分片键值为每个块分配一个范围;

注意：使用哈希索引解析查询时，MongoDB自动计算哈希值。应用程序也不会需要计算哈希值;

对app库下的vast大表进行hash;

# 连接到其中一个mongos
mongo --port 38017 admin

# 开启数据库分片功能
db.runCommand( { enablesharding : "app" } )

# 对app库下的vast表建立hash索引
use app
db.vast.ensureIndex( { id: "hashed" } )

# 开启分片
use admin
sh.shardCollection( "app.vast", { id: "hashed" } )

# 集合分片验证
use app
for(i=1;i<100000;i++){ db.vast.insert({"id":i,"name":"ruan","age":23,"date":new Date()}); }

# hash分片结果测试
# 连接sh1
mongo --port 38021
use app
db.vast.count();

# 连接sh2
mongo --port 38024
use app
db.vast.count();

分片操作

use admin
db.runCommand({ isdbgrid : 1})			# 判断是否Shard集群
db.runCommand({ listshards : 1})		# 列出所有分片信息
db.printShardingStatus()						# 查看分片的详细信息

# 列出开启分片的数据库
use config
db.databases.find( { "partitioned": true } )  # 或者 db.databases.find() //列出所有数据库分片情况
db.collections.find().pretty()			# 查看分片的片键

# 删除分片节点（谨慎）
sh.getBalancerState()	确认blance是否在工作
db.runCommand( { removeShard: "shard2" } )	# 删除shard2节点(谨慎)

# 删除操作一定会立即触发blancer!!!

balancer操作

mongos的一个重要功能，自动巡查所有shard节点上的chunk的情况，自动做chunk迁移;

什么时候工作？

** 1 . 自动运行，会检测系统不繁忙的时候做迁移;

2 . 在做节点删除的时候，立即开始迁移工作(生产删除节点千万避免业务高峰期) ;

3 . balancer只能在预设定的时间窗口内运行;**

关闭和开启blancer（备份的时候）

mongos> sh.stopBalancer()
mongos> sh.startBalancer()

预设定的时间做balancer

连接到其中一个mongos
mongo --port 38017 admin

use config
sh.setBalancerState( true )
// 每天3-5点
db.settings.update({ _id : "balancer" }, { $set : { activeWindow : { start : "3:00", stop : "5:00" } } }, true )

sh.getBalancerWindow()	// 查看balancer时间窗口
sh.status()

关于集合的balancer

关闭某个集合的balance

sh.disableBalancing("test.vast")

打开某个集合的balancer

sh.enableBalancing("test.vast")

确定某个集合的balance是开启或者关闭

db.getSiblingDB("config").collections.findOne({_id : "test.vast"}).noBalance;

备份与恢复

备份工具

mongoexport/mongoimport  导入/导出的是JSON格式或者CSV格式

mongodump/mongorestore   导入/导出的是BSON格式

JSON可读性强但体积较大，BSON则是二进制文件，体积小但对人类几乎没有可读性

版本兼容性问题

在一些mongodb版本之间，BSON格式可能会随版本不同而有所不同，所以不同版本之间用mongodump/mongorestore可能不会成功，具体要看版本之间的兼容性。当无法使用BSON进行跨版本的数据迁移的时候，使用JSON格式即mongoexport/mongoimport是一个可选项。

跨版本的mongodump/mongorestore个人并不推荐，实在要做请先检查文档看两个版本是否兼容（大部分时候是不兼容的）

注意

JSON虽然具有较好的跨版本通用性，但其只保留了数据部分，不保留索引，账户等其他基础信息。使用时应该注意;

应用场景

mongoexport/mongoimport

导入导出可以是json/csv

1 . 异构平台迁移  mysql  <---> mongodb

2 . 同平台, 跨大版本：mongodb 2   <---> mongodb 3

mongodump/mongorestore

导入导出的是BSON格式,日常备份恢复时使用, 不同版本的BSON是不一样的, 不能通用的;

导出工具mongoexport

Mongodb中的mongoexport工具可以把一个collection导出成JSON格式或CSV格式的文件。

可以通过参数指定导出的数据项，也可以根据指定的条件导出数据。

1 . 版本差异较大

** 2 . 异构平台数据迁移**

参数说明

mongoexport --help
# 参数说明：
  -h:指明数据库宿主机的IP
  -u:指明数据库的用户名
  -p:指明数据库的密码
  -d:指明数据库的名字
  -c:指明collection的名字
  -f:指明要导出那些列
  -o:指明到要导出的文件名
  -q:指明导出数据的过滤条件
  --authenticationDatabase admin

单表备份至json格式

备份文件的名字可以自定义，默认导出了JSON格式的数据

mongoexport  -h 127.0.0.1:27017 -uyoumen -pyoumen --authenticationDatabase admin -d app -c app -o /mongodb/bak/app.json

单表备份至csv格式

导出CSV格式的数据，需要使用--type=csv参数

-f导出的列头

mongoexport  -h 127.0.0.1:27017  -uyoumen -pyoumen --authenticationDatabase admin -d app -c app --type=csv -f id  -o /mongodb/bak/app.csv

导入工具mongoimport

Mongodb中的mongoimport工具可以把一个特定格式文件中的内容导入到指定的collection中。该工具可以导入JSON格式数据，也可以导入CSV格式数据;

参数说明

mongoimport --help
# 参数说明：
  -h:指明数据库宿主机的IP
  -u:指明数据库的用户名
  -p:指明数据库的密码
  -d:指明数据库的名字
  -c:指明collection的名字
  -f:指明要导入那些列
  -j, //并行多少CPU

恢复json格式表数据

mongoimport  -h 127.0.0.1:27017  -uyoumen -pyoumen  --authenticationDatabase admin -d app -c app /mongodb/bak/app.json

// -j   并行导入

恢复csv格式的文件

# csv格式的文件头行，有列名字
mongoimport   -uroot -padmin --port 27017 --authenticationDatabase admin   -d app -c test2 --type=csv --headerline --file  /mongodb/bak/app.csv

# csv格式的文件头行，没有列名字
mongoimport   -uroot -padmin --port 27017 --authenticationDatabase admin   -d app -c test3 --type=csv -f id --file  /mongodb/bak/app.csv

异构平台迁移

mysql迁移mongodb

mysql开启安全路径
vim /etc/my.cnf   --->添加以下配置
secure-file-priv=/tmp

重启数据库生效
systemctl restart mysql

导出mysql的表数据
select * from app.user into outfile '/tmp/user.csv' fields terminated by ',';
#fields terminated by ','　　　 字段间以,号分隔
#####其它参数
#optionally enclosed by '"'　　 字段用"号括起
#escaped by '"'   　　　　　　   字段中使用的转义符为"
#lines terminated by '\r\n';　　行以\r\n结束

处理csv文件
vim /tmp/user.csv   ----> 添加对应第一行列名信息

mongodb中导入csv文件
mongoimport -uroot -padmin --port 27017 --authenticationDatabase admin -d app  -c user --type=csv --headerline --file  /tmp/user.csv

BSON工具介绍

mongodump能够在Mongodb运行时进行备份，它的工作原理是对运行的Mongodb做查询，然后将所有查到的文档写入磁盘。但是存在的问题时使用mongodump产生的备份不一定是数据库的实时快照，如果我们在备份时对数据库进行了写入操作，则备份出来的文件可能不完全和Mongodb实时数据相等。另外在备份时可能会对其它客户端性能产生不利的影响。

导出工具mongodump

参数说明

mongodump --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
-j n 并行n个CPU
--oplog  备份的同时备份oplog

全库备份

mongodump  -uroot -padmin --port 27017 --authenticationDatabase admin -o /mongodb/bak

备份单库

mongodump   -uroot -padmin --port 27017 --authenticationDatabase admin -d app -o /mongodb/bak

备份库下的集合

mongodump   -uroot -padmin --port 27017 --authenticationDatabase admin -d app -c test3 -o /mongodb/bak

压缩备份

mongodump  -uroot -padmin --port 27017 --authenticationDatabase admin -o /mongodb/bak --gzip
mongodump  -uroot -padmin --port 27017 --authenticationDatabase admin -d app -o /mongodb/bak --gzip
mongodump  -uroot -padmin --port 27017 --authenticationDatabase admin -d app -c test3 -o /mongodb/bak --gzip

导入工具mongorestore

参数说明

mongorestore --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
--drop表示恢复的时候把之前的集合drop掉(危险)
--oplogReplay 同时导入oplog文件

恢复全部

mongorestore -uroot -padmin --port 27017 --authenticationDatabase admin /mongodb/bak

恢复库

mongorestore -uroot -padmin --port 27017 --authenticationDatabase admin -d app /mongodb/bak/app

恢复库下的集合

mongorestore -uroot -padmin --port 27017 --authenticationDatabase admin -d app -c app  /mongodb/bak/app/app.bson.gz

--drop恢复

mongorestore   -uroot -padmin --port 27017 --authenticationDatabase admin -d app --drop /mongodb/bak/app

oplog介绍

mongodump和mongorestore对replica set或者master/slave使用

在replica set中oplog是一个定容集合（capped collection），它的默认大小是磁盘空间的5%（可以通过--oplogSizeMB参数修改）

oplog其中记录的是整个mongod实例一段时间内数据库的所有变更（插入/更新/删除）操作。当空间用完时新记录自动覆盖最老的记录。其覆盖范围被称作oplog时间窗口。需要注意的是，因为oplog是一个定容集合，所以时间窗口能覆盖的范围会因为你单位时间内的更新次数不同而变化。

想要查看当前的oplog时间窗口预计值，可以使用以下命令：

> rs.printReplicationInfo()
configured oplog size:   2048MB <--集合大小
log length start to end: 60295secs (16.75hrs) <--预计窗口覆盖时间
oplog first event time:  Sat Apr 17 2021 00:26:26 GMT+0800 (CST)
oplog last event time:   Sat Apr 17 2021 17:11:21 GMT+0800 (CST)
now:                     Sat Apr 17 2021 17:11:29 GMT+0800 (CST)

查看oplog的详细信息

use local
db.oplog.rs.find().pretty()

oplog应用

实现热备，在备份时使用--oplog选项，--oplog 会记录备份过程中的数据变化，会以oplog.bson保存下来

mongodump --port 28017 --oplog -o /mongodb/bak

ls /mongodb/bak/
admin  oplog.bson

恢复

mongorestore  --port 28017 --oplogReplay /mongodb/bak

oplog使用示例

背景：每天0点全备，oplog恢复窗口为48小时

某天，上午10点业务表被误删除。

恢复思路：

1、停应用

2、找测试库

3、恢复昨天晚上全备

4、截取全备之后到world.city误删除时间点的oplog，并恢复到测试库

5、将误删除表导出，恢复到生产库

恢复步骤

备份现有的oplog.rs表
mongodump --port 28017 -d local -c oplog.rs  -o /mongodb/bak

截取oplog并恢复到drop之前的位置
mongo --port 28017
use local
db.oplog.rs.find({op:"c"}).pretty();
-----------------
op的值说明：
    "i": insert
    "u": update
    "d": delete
    "c": db cmd
假设误删命令是db.test.drop() 这里选”c“做关键查询
-----------------
获取到oplog误删除时间点位置
"ts" : Timestamp(1111111111, 1)  获取时间这一关键段

恢复备份+oplog.bson
ls /mongodb/bak/local/
oplog.rs.bson  oplog.rs.metadata.json

cp /mongodb/bak/local/oplog.rs.bson /mongodb/bak/oplog.bson
rm -rf /mongodb/backup/local/
mongorestore --port 28018  --oplogReplay --oplogLimit "1111111111:1"  --drop   /mongodb/bak/
即可恢复误删的集合

分片集群的备份思路

要备份什么？

config server
shard 节点
---单独进行备份

备份有什么困难和问题？

(1)chunk迁移的问题
人为控制在备份的时候，避开迁移的时间窗口
(2)shard节点之间的数据不在同一时间点。
选业务量较少的时候