84.mongodb分片介绍 搭建 测试 及mongodb备份与恢复

21.36 mongodb分片介绍

21.37/21.38/21.39 mongodb分片搭建

21.40 mongodb分片测试

21.41 mongodb备份恢复

 

 

 

21.36 mongodb分片介绍

 

 

分片是由一个一个的副本集组成的

1.分片就是将数据库进行拆分，将大型集合分隔到不一样服务器上。好比，原本100G的数据，能够分割成10份存储到10台服务器上，这样每台机器只有10G的数据。

2.经过一个mongos的进程（路由分发）实现分片后的数据存储与访问，也就是说mongos是整个分片架构的核心，对客户端而言是不知道是否有分片的，客户端只须要把读写操做转达给mongos便可。

3.虽然分片会把数据分隔到不少台服务器上，可是每个节点都是须要有一个备用角色的，这样能保证数据的高可用。

#节点其实就是一个副本集。能够理解成分片的下一级别的单位就是副本集。分片是由副本集组成的

4.当系统须要更多空间或者资源的时候，分片可让咱们按需方便扩展，只须要把mongodb服务的机器加入到分片集群中便可

#支持横向扩展，不够了的时候直接加副本集节点进来就能够了

 

MongoDB分片架构图

 

 

MongoDB分片相关概念

1.mongos: 数据库集群请求的入口，全部的请求都经过mongos进行协调，不须要在应用程序添加一个路由选择器，mongos本身就是一个请求分发中心，它负责把对应的数据请求请求转发到对应的shard服务器上。在生产环境一般有多mongos做为请求的入口，防止其中一个挂掉全部的mongodb请求都没有办法操做。

#就是实现一个路由，反馈，的分发

2.config server: 配置服务器，存储全部数据库元信息（路由、分片）的配置。mongos自己没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据。mongos第一次启动或者关掉重启就会从 config server 加载配置信息，之后若是配置服务器信息变化会通知到全部的 mongos 更新本身的状态，这样 mongos 就能继续准确路由。在生产环境一般有多个 config server 配置服务器，由于它存储了分片路由的元数据，防止数据丢失！

#存储配置的

3.shard: 存储了一个集合部分数据的MongoDB实例，每一个分片是单独的mongodb服务或者副本集，在生产环境中，全部的分片都应该是副本集。

#存储配置的

 

 

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

 

 

 

21.37/21.38/21.39 mongodb分片搭建

 

 

一.分片搭建 -服务器规划

三台机器 A B C

A搭建：mongos、config server、副本集1主节点、副本集2仲裁、副本集3从节点

#至关于每一个机器上都要开启这五个端口

B搭建：mongos、config server、副本集1从节点、副本集2主节点、副本集3仲裁

C搭建：mongos、config server、副本集1仲裁、副本集2从节点、副本集3主节点

端口分配：mongos 20000、config 21000、副本集1 2700一、副本集2 2700二、副本集3 27003

三台机器所有关闭firewalld服务和selinux，或者增长对应端口的规则

 

二.分片搭建 – 建立目录

分别在三台机器上建立各个角色所须要的目录

#每台机器都要执行这个五条

mkdir -p /data/mongodb/mongos/log

mkdir -p /data/mongodb/config/{data,log}

mkdir -p /data/mongodb/shard1/{data,log}

mkdir -p /data/mongodb/shard2/{data,log}

mkdir -p /data/mongodb/shard3/{data,log}

 

三.分片搭建–config server配置（config server）

1.mongodb3.4版本之后须要对config server建立副本集

2.添加配置文件(三台机器都操做)

3.mkdir /etc/mongod/

#分别建立三台配置文件的目录，三台都要操做

4.vim /etc/mongod/config.conf（也就是config sever的配置文件） //加入以下内容

pidfilepath = /var/run/mongodb/configsrv.pid

dbpath = /data/mongodb/config/data

logpath = /data/mongodb/config/log/congigsrv.log

logappend = true

bind_ip = 192.168.208.128 #内网IP。也能够所有监听0.0.0.0（不安全）

port = 21000 #指定端口数

fork = true #进程相关

configsvr = true #declare this is a config db of a cluster;

replSet=configs #副本集名称

maxConns=20000 #设置最大链接数

5.启动三台机器的config server

mongod -f /etc/mongod/config.conf（启动的时候加-f指定他的配置文件就能够了） //三台机器都要操做

6.登陆任意一台机器的21000端口，初始化副本集

mongo --port 21000

config = { _id: "configs", members: [ {_id : 0, host : "192.168.133.130:21000"},{_id : 1, host : "192.168.133.132:21000"},{_id : 2, host : "192.168.133.133:21000"}] }

#config命令，重要一步，将三个机器联系起来

rs.initiate(config) #初始化

{ "ok" : 1 }

 

四.分片搭建–分片配置（shard）

#分片至少要保证有三个副本集进来，就是下面的shard1 2 3

添加配置文件(三台机器都操做)

#每一台机器都要添加这三个配置文件（shard1 2 3 ）

1.shard1配置:

1.1vim /etc/mongod/shard1.conf //加入以下内容

pidfilepath = /var/run/mongodb/shard1.pid

dbpath = /data/mongodb/shard1/data

logpath = /data/mongodb/shard1/log/shard1.log

logappend = true

bind_ip = 192.168.208.128 #01机器的内网ip

port = 27001

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard1 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

shard2配置:

2.1vim /etc/mongod/shard2.conf //加入以下内容

pidfilepath = /var/run/mongodb/shard2.pid

dbpath = /data/mongodb/shard2/data

logpath = /data/mongodb/shard2/log/shard2.log

logappend = true

bind_ip = 192.168.208.130 #02机器的内网ip

port = 27002

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard2 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

shard3配置:

3.1vim /etc/mongod/shard3.conf //加入以下内容

pidfilepath = /var/run/mongodb/shard3.pid

dbpath = /data/mongodb/shard3/data

logpath = /data/mongodb/shard3/log/shard3.log

logappend = true

bind_ip = 192.168.208.133 #03机器的内网ip

port = 27003

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard3 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

2.启动shard1，并把shard1的副本集搭建起来

mongod -f /etc/mongod/shard1.conf //三台机器都要操做

登陆128或者130任何一台机器的27001端口初始化副本集，133之因此不行，是由于shard1咱们把133这台机器的27001端口做为了仲裁节点

mongo --host 192.168.208.128 --port 27001

use admin

config = { _id: "shard1", members: [ {_id : 0, host : "192.168.208.128:27001"}, {_id: 1,host : "192.168.208.130:27001"},{_id : 2, host : "192.168.208.133:27001",arbiterOnly:true}] }

rs.initiate(config)

启动shard2，并把shard2的副本集搭建起来

mongod -f /etc/mongod/shard2.conf //三台机器都要操做

登陆130或者133任何一台机器的27002端口初始化副本集，128之因此不行，是由于shard2咱们把128这台机器的27002端口做为了仲裁节点

mongo --host 192.168.208.130 --port 27002

use admin

config = { _id: "shard2", members: [ {_id : 0, host : "192.168.208.128:27002" ,arbiterOnly:true},{_id : 1, host : "192.168.208.130:27002"},{_id : 2, host : "192.168.208.133:27002"}] }

rs.initiate(config)

启动shard3，并把shard3的副本集搭建起来

mongod -f /etc/mongod/shard3.conf //三台机器都要操做

登陆128或者133任何一台机器的27003端口初始化副本集，130之因此不行，是由于shard3咱们把130这台机器的27003端口做为了仲裁节点

mongo --host 192.168.208.133 --port 27003

use admin

config = { _id: "shard3", members: [ {_id : 0, host : "192.168.208.128:27003"}, {_id : 1, host : "192.168.208.130:27003", arbiterOnly:true}, {_id : 2, host : "192.168.208.133:27003"}] }

rs.initiate(config)

五.分片搭建–配置路由服务器（mongos）

mongos放在最后的缘由是，mongos要想启动起来，他先要知道你的config server是谁、还有那三个shard（副本集）都是谁

mongos没有数据，他不须要存数据，因此他不须要data的指定目录

添加配置文件(三台机器都操做)

1.vim /etc/mongod/mongos.conf //加入以下内容

pidfilepath = /var/run/mongodb/mongos.pid

logpath = /data/mongodb/mongos/log/mongos.log

logappend = true

bind_ip = 0.0.0.0

port = 20000

fork = true

configdb = configs/192.168.208.128:21000,192.168.208.128:21000,192.168.208.128:21000

#关键，指定config server

#监听的配置服务器,只能有1个或者3个，configs为配置服务器的副本集名字

maxConns=20000 #设置最大链接数

2.启动mongos服务，注意命令，前面都是mongod，这里是mongos

mongos -f /etc/mongod/mongos.conf

六.分片搭建–启用分片

登陆任何一台20000端口

mongo --port 20000

把全部分片和路由器串联（也就是进入mongos链接分片{shard1 2 3}）

sh.addShard("shard1/192.168.208.128:27001,192.168.208.130:27001,192.168.208.133:27001") #注意语法，逗号分隔没有空格。这是链接shard1

sh.addShard("shard2/192.168.208.128:27002,192.168.208.130:27002,192.168.208.133:27002") #注意语法，逗号分隔没有空格。这是链接shard2

sh.addShard("shard3/192.168.208.128:27003,192.168.208.130:27003,192.168.208.133:27003") #注意语法，逗号分隔没有空格。这是链接shard3

查看集群状态

sh.status() #查看分片。与rs.status()（查看副本集）不同

 

 

 

实例：

[root@axinlinux-01 ~]# mkdir -p /data/mongodb/mongos/log

[root@axinlinux-01 ~]# mkdir -p /data/mongodb/config/{data,log}

[root@axinlinux-01 ~]# mkdir -p /data/mongodb/shard1/{data,log}

[root@axinlinux-01 ~]# mkdir -p /data/mongodb/shard2/{data,log}

[root@axinlinux-01 ~]# mkdir -p /data/mongodb/shard3/{data,log}

[root@axinlinux-01 ~]# mkdir /etc/mongod/ #建立他的配置文件目录

#！！02 03上也要这样建立目录，这里就不作演示了

[root@axinlinux-01 ~]# vim /etc/mongod/config.conf

pidfilepath = /var/run/mongodb/configsrv.pid

dbpath = /data/mongodb/config/data

logpath = /data/mongodb/config/log/congigsrv.log

logappend = true

bind_ip = 192.168.208.128 #内网IP

port = 21000

fork = true #进程相关

configsvr = true #declare this is a config db of a cluster;

replSet=configs #副本集名称

maxConns=20000 #设置最大链接数

#！！以上，02 03机器也要这样操做。注意监听IP要修改本机

[root@axinlinux-01 ~]# mongod -f /etc/mongod/config.conf #-f指定他的配置文件。这样把它启动起来

about to fork child process, waiting until server is ready for connections.

forked process: 2070

child process started successfully, parent exiting

[root@axinlinux-01 ~]# ps aux |grep mongod #查看有没有指定配置文件的进程

root 2070 5.2 2.6 1083880 49716 ? Sl 21:08 0:01 mongod -f /etc/mongod/config.conf

[root@axinlinux-01 ~]# netstat -lntp #还要查看有没有指定的端口数

tcp 0 0 192.168.208.128:21000 0.0.0.0:* LISTEN 2070/mongod

#！！以上，02 03都要这样-f指定刚建好的配置文件，将他启动起来。并查看进程和端口是否是咱们指定的

[root@axinlinux-01 ~]# mongo --host 192.168.208.128 --port 21000 #进入任何一个机器里

> config = { _id: "configs", members: [ {_id : 0, host : "192.168.208.128:21000"},{_id : 1, host : "192.168.208.130:21000"},{_id : 2, host : "192.168.208.133:21000"}] } #执行该命令

{

"_id" : "configs",

"members" : [

{

"_id" : 0,

"host" : "192.168.208.128:21000"

},

{

"_id" : 1,

"host" : "192.168.208.130:21000"

},

{

"_id" : 2,

"host" : "192.168.208.133:21000"

}

]

}

> rs.initiate(config)

{ "ok" : 1 }

四.分片搭建–分片配置

[root@axinlinux-01 ~]# vim /etc/mongod/shard1.conf

pidfilepath = /var/run/mongodb/shard1.pid

dbpath = /data/mongodb/shard1/data

logpath = /data/mongodb/shard1/log/shard1.log

logappend = true

bind_ip = 0.0.0.0 #可设置为01机器的内网ip。为方便实验设置了监听全部网段，不安全！

port = 27001

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard1 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

[root@axinlinux-01 ~]# vim /etc/mongod/shard2.conf

pidfilepath = /var/run/mongodb/shard2.pid

dbpath = /data/mongodb/shard2/data

logpath = /data/mongodb/shard2/log/shard2.log

logappend = true

bind_ip = 0.0.0.0 #可设置为02机器的内网ip。为方便实验设置了监听全部网段，不安全！

port = 27002

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard2 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

[root@axinlinux-01 ~]# vim /etc/mongod/shard3.conf

pidfilepath = /var/run/mongodb/shard3.pid

dbpath = /data/mongodb/shard3/data

logpath = /data/mongodb/shard3/log/shard3.log

logappend = true

bind_ip = 0.0.0.0 #可设置为02机器的内网ip。为方便实验设置了监听全部网段，不安全！

port = 27003

fork = true

httpinterface=true #打开web监控

rest=true

replSet=shard3 #副本集名称

shardsvr = true #declare this is a shard db of a cluster;

maxConns=20000 #设置最大链接数

#！！注意三台机器都要添加这三个shard 1 2 3 的文件。02 03的监听内网ip和pid文件的数字要注意修改

阿鑫在实验的时候，就是没有每台机器配置三个shard.conf，致使出错。

！！总结：每台机器都要配置这三个shard配置文件。而且每台都要开启相应的shard 1 2 3 服务！！

[root@axinlinux-01 ~]# mongod -f /etc/mongod/shard1.conf #开启shard1这个服务

#02 03机器也要开启shard1.conf这个服务

[root@axinlinux-01 ~]# mongo --host 192.168.208.128 --port 27001 #进入128机器

> config = { _id: "shard1", members: [ {_id : 0, host : "192.168.208.128:27001"}, {_id: 1,host : "192.168.208.130:27001"},{_id : 2, host : "192.168.208.133:27001",arbiterOnly:true}] }

> rs.initiate(config)

{ "ok" : 1 } #ok才能够

[root@axinlinux-02 ~]# mongod -f /etc/mongod/shard2.conf #三台机器上都要开启这个shard2服务

[root@axinlinux-02 ~]# mongo --port 27002 #要在02 机器上登陆mongodb，是由于shard2咱们把128这台机器的27002端口做为了仲裁节点

> config = { _id: "shard2", members: [ {_id : 0, host : "192.168.208.128:27002" ,arbiterOnly:true},{_id : 1, host : "192.168.208.130:27002"},{_id : 2, host : "192.168.208.133:27002"}] }

> rs.initiate(config)

{ "ok" : 1 }

[root@axinlinux-01 mongod]# mongod -f /etc/mongod/shard3.conf #全部机器上都要启动shard3服务

[root@axinlinux-01 mongod]# mongo --port 27003 #在01机器上登陆mongod

> use admin

> config = { _id: "shard3", members: [ {_id : 0, host : "192.168.208.128:27003"}, {_id : 1, host : "192.168.208.130:27003", arbiterOnly:true}, {_id : 2, host : "192.168.208.133:27003"}] }

> rs.initiate(config)

{ "ok" : 1 }

五.分片搭建–配置路由服务器（mongos）

[root@axinlinux-01 ~]# vim /etc/mongod/mongos.conf #建立mongos

cat /etc/mongod/mongos.conf

pidfilepath = /var/run/mongodb/mongos.pid

logpath = /data/mongodb/mongos/log/mongos.log

logappend = true

bind_ip = 0.0.0.0

port = 20000

fork = true

configdb = configs/192.168.208.128:21000,192.168.208.128:21000,192.168.208.128:21000

#关键，指定config server

#监听的配置服务器,只能有1个或者3个，configs为配置服务器的副本集名字

maxConns=20000 #设置最大链接数

#以上建立mongos，02 03机器上也要作

[root@axinlinux-01 ~]# scp /etc/mongod/mongos.conf 192.168.208.130:/etc/mongod/ #可以使用scp

[root@axinlinux-01 ~]# scp /etc/mongod/mongos.conf 192.168.208.133:/etc/mongod/

[root@axinlinux-01 ~]# mongos -f /etc/mongod/mongos.conf #01 02 03均开启mongos

[root@axinlinux-02 ~]# mongos -f /etc/mongod/mongos.conf

[root@axinlinux-03 ~]# mongos -f /etc/mongod/mongos.conf

六.分片搭建–启用分片

[root@axinlinux-01 ~]# mongo --port 20000 #任何一台机器上登陆2000端口。也就是进入了mongos

mongos> sh.addShard("shard1/192.168.208.128:27001,192.168.208.130:27001,192.168.208.133:27001")

#注意语法，ip之间逗号链接，没有空格。链接shard1

{ "shardAdded" : "shard1", "ok" : 1 } #显示ok为1正常

mongos> sh.addShard("shard2/192.168.208.128:27002,192.168.208.130:27002,192.168.208.133:27002")

{ "shardAdded" : "shard2", "ok" : 1 } #链接shard2

mongos> sh.addShard("shard3/192.168.208.128:27003,192.168.208.130:27003,192.168.208.133:27003")

{ "shardAdded" : "shard3", "ok" : 1 } #链接shard3

mongos> sh.status() #查看分片

--- Sharding Status ---

sharding version: {

"_id" : 1,

"minCompatibleVersion" : 5,

"currentVersion" : 6,

"clusterId" : ObjectId("5bf419a348657fd107487a17")

}

shards: #正常的话就会看到下面这三个

{ "_id" : "shard1", "host" : "shard1/192.168.208.128:27001,192.168.208.130:27001", "state" : 1 }

{ "_id" : "shard2", "host" : "shard2/192.168.208.130:27002,192.168.208.133:27002", "state" : 1 }

{ "_id" : "shard3", "host" : "shard3/192.168.208.128:27003,192.168.208.133:27003", "state" : 1 }

active mongoses:

"3.4.18" : 3

autosplit:

Currently enabled: yes

balancer:

Currently enabled: yes

Currently running: no #没有启动是由于，尚未建立任何的库和表

NaN

Failed balancer rounds in last 5 attempts: 0

Migration Results for the last 24 hours:

No recent migrations

databases:

 

 

 

 

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

 

 

 

21.40 mongodb分片测试

 

 

 

1.登陆任何一台20000端口

2.mongo --port 20000

3.use admin #进入admin库

4.db.runCommand({ enablesharding : "testdb"}) 或者

sh.enableSharding("testdb") //指定要分片的数据库

#这两条命令都是同样的，都是指定要分片的库。没有的话会被建立

5.db.runCommand( { shardcollection : "testdb.table1",key : {id: 1} } ) 或者

sh.shardCollection("testdb.table1",{"id":1} ) //#指定数据库里须要分片的集合和片键

#也就是testdb库里的table1集合

6.use testdb #在进入咱们刚建立的testdb库

7.for (var i = 1; i <= 10000; i++) db.table1.save({id:i,"test1":"testval1"})//插入测试数据

#在测试库里插入10000条数据

8.db.table1.stats()//查看table1状态

#多建几个会自动的均衡分到各个sgard里面去

 

 

 

实例：

[root@axinlinux-01 ~]# mongo --port 20000 #进入20000

mongos> use admin #要先进入admin

switched to db admin

mongos> db.runCommand({ enablesharding : "testdb"}) #建立testdb测试库

{ "ok" : 1 }

mongos> db.runCommand( { shardcollection : "testdb.table1",key : {id: 1} } ) #指定要分片的集合

{ "collectionsharded" : "testdb.table1", "ok" : 1 }

mongos> use testdb #进入测试库

switched to db testdb

mongos> for (var i = 1; i <= 10000; i++) db.table1.save({id:i,"test1":"testval1"}) #插入一些数据（10000条）

WriteResult({ "nInserted" : 1 })

mongos> show dbs #能够看一下

admin 0.000GB

config 0.001GB

testdb 0.000GB

mongos> sh .status() #看一下分片状态

。。。

databases:

{ "_id" : "testdb", "primary" : "shard2", "partitioned" : true } #这能够看到咱们建立的testdb

testdb.table1

shard key: { "id" : 1 }

unique: false

balancing: true

chunks:

shard2 1 #这些数据在shard2里面

{ "id" : { "$minKey" : 1 } } -->> { "id" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 0)

mongos> sh.enableSharding("db2") #为知足实验效果，在多建立几个库和要分片的集合。db2库里的axin2集合

{ "ok" : 1 }

mongos> sh.shardCollection("db2.axin2",{"id":1} )

{ "collectionsharded" : "db2.axin2", "ok" : 1 }

mongos> sh.enableSharding("db3") #为知足实验效果，在多建立几个库和要分片的集合。db2库里的axin2集合

{ "ok" : 1 }

mongos> sh.shardCollection("db3.axin3",{"id":1} )

{ "collectionsharded" : "db3.axin3", "ok" : 1 }

mongos> sh.status() #咱们再来看一下分片

。。。。。

databases:

{ "_id" : "testdb", "primary" : "shard2", "partitioned" : true }

testdb.table1

shard key: { "id" : 1 }

unique: false

balancing: true

chunks:

shard2 1 #能够看到testdb1仍是在shard2里

{ "id" : { "$minKey" : 1 } } -->> { "id" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 0)

{ "_id" : "db2", "primary" : "shard3", "partitioned" : true }

db2.axin2

shard key: { "id" : 1 }

unique: false

balancing: true

chunks:

shard3 1 #db2被分到了shaed3里

{ "id" : { "$minKey" : 1 } } -->> { "id" : { "$maxKey" : 1 } } on : shard3 Timestamp(1, 0)

{ "_id" : "db3", "primary" : "shard1", "partitioned" : true }

db3.axin3

shard key: { "id" : 1 }

unique: false

balancing: true

chunks:

shard1 1 #db3被分到了shard1里

{ "id" : { "$minKey" : 1 } } -->> { "id" : { "$maxKey" : 1 } } on : shard1 Timestamp(1, 0)

 

 

 

 

 

 

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

 

 

 

21.41 mongodb备份恢复

 

 

 

！！咱们使用了分片那么在备份的时候，也是要到分片的这个端口里去备份的（也就是20000，mongos服务的那个端口）

MongoDB备份

1.备份指定库

mongodump --host 127.0.0.1 --port 20000 -d mydb -o /tmp/mongobak

#备份使用mongodump来备份，跟mysqldump类似

#-d 指定数据库、-o 指定你把数据库备份在哪里，它会在/tmp/mongobak目录下面生成一个mydb的目录

他会生成对应集合的两个文件.bson .json

2.备份全部库

mongodump --host 127.0.0.1 --port 20000 -o /tmp/mongobak/alldatabase

#跟指定库备份同样，不用-d指定库便可。目标目录自动生成

3.指定备份集合

mongodump --host 127.0.0.1 --port 20000 -d mydb -c c1 -o /tmp/mongobak/

#-c指定集合

它依然会生成mydb目录，再在这目录下面生成两个文件

4.导出集合为json文件

mongoexport --host 127.0.0.1 --port 20000 -d mydb -c c1 -o /tmp/mydb2/1.json

MongoDB恢复

1.恢复全部库

mongorestore -host 127.0.0.1 --port 20000 --drop dir/

#恢复的库的时候，要指定到这个备份库的所在目录下

//其中dir是备份全部库的目录名字，其中--drop可选，意思是当恢复以前先把以前的数据删除，不建议使用

2.恢复指定库

mongorestore --host 127.0.0.1 --port 20000 -d testdb dir/

//-d跟要恢复的库名字，dir就是该库备份时所在的目录

3.恢复集合

mongorestore -d mydb -c testc dir/mydb/testc.bson

// -c后面跟要恢复的集合名字，dir是备份mydb库时生成文件所在路径，这里是一个bson文件的路径，也就是说恢复集合的时候，只须要指定这个bson的文件

4.导入集合（若是恢复的是导出集合的json文件就使用mongoimport）

mongoimport -d mydb -c testc --file /tmp/testc.json

#--file指定这个json的文件

 

 

 

 

实例：

1.备份指定库

[root@axinlinux-01 ~]# mkdir /tmp/mongobak

[root@axinlinux-01 ~]# mongodump --host 127.0.0.1 --port 20000 -d testdb -o /tmp/mongobak/

2018-11-21T15:04:49.290+0800 writing testdb.table1 to

2018-11-21T15:04:49.911+0800 [........................] testdb.table1 101/10000 (1.0%)

2018-11-21T15:04:50.039+0800 [########################] testdb.table1 10000/10000 (100.0%)

2018-11-21T15:04:50.039+0800 done dumping testdb.table1 (10000 documents)

[root@axinlinux-01 ~]# ls /tmp/mongobak/testdb/

table1.bson table1.metadata.json

2.备份全部库

[root@axinlinux-01 ~]# mongodump --host 127.0.0.1 --port 20000 -o /tmp/mongobak/alldatabase

[root@axinlinux-01 ~]# ls /tmp/mongobak/alldatabase/

admin config db2 db3 testdb #全部的目录对应全部的库

3.备份指定集合

[root@axinlinux-01 ~]# mongodump --host 127.0.0.1 --port 20000 -d testdb -c table1 -o /tmp/mongobak3/

#-c 指定备份集合

2018-11-21T15:16:55.774+0800 writing testdb.table1 to

2018-11-21T15:16:57.262+0800 done dumping testdb.table1 (10000 documents)

[root@axinlinux-01 ~]# ls /tmp/mongobak3/testdb/ #这个目录里就是咱们备份集合的两个文件

table1.bson table1.metadata.json

4.导出集合为json文件

[root@axinlinux-01 ~]# mongoexport --host 127.0.0.1 --port 20000 -d testdb -c table1 -o /tmp/mongobak4/1.json #咱们处处以前插入在testdb的table集合。里面是咱们插入的10000条数据

[root@axinlinux-01 ~]# vim !$

vim /tmp/mongobak4/1.json

{"_id":{"$oid":"5bf4f6db490e5e6d7b55b539"},"id":6.0,"test1":"testval1"}

{"_id":{"$oid":"5bf4f6db490e5e6d7b55b55e"},"id":43.0,"test1":"testval1"}

{"_id":{"$oid":"5bf4f6d8490e5e6d7b55b534"},"id":1.0,"test1":"testval1"}

。。。。。

恢复数据以前先把以前的数据删掉，好达到实验效果：

[root@axinlinux-01 ~]# mongo --port 20000 #先进入mongodb，要进mongos服务的那个20000端口

mongos> use testdb #进入testdb库，直接删掉

switched to db testdb

mongos> db.dropDatabase()

{ "dropped" : "testdb", "ok" : 1 }

mongos> show databases #查看一下，把db2 db3也一块儿删掉

admin 0.000GB

config 0.001GB

db2 0.000GB

db3 0.000GB

mongos> use db2

switched to db db2

mongos> db.dropDatabase()

{ "dropped" : "db2", "ok" : 1 }

mongos> use db3

switched to db db3

mongos> db.dropDatabase()

{ "dropped" : "db3", "ok" : 1 }

mongos> show dbs

admin 0.000GB

config 0.001GB

1.恢复全部库

[root@axinlinux-01 tmp]# mongorestore -h 127.0.0.1 --port 20000 --drop /tmp/mongobak/alldatabase #选择这个文件，就是恢复这个文件的全部

2018-11-21T15:41:38.681+0800 preparing collections to restore from

2018-11-21T15:41:38.687+0800 Failed: cannot do a full restore on a sharded system - remove the 'config' directory from the dump directory first

#报错，是由于这个目录里有admin和config文件的备份，这两个比较重要，可能不能恢复。咱们也没有将他们删除，因此先把这两个备份文件删掉

[root@axinlinux-01 tmp]# rm -rf /tmp/mongobak/alldatabase/

admin/ config/ db2/ db3/ testdb/

[root@axinlinux-01 tmp]# rm -rf /tmp/mongobak/alldatabase/admin/

[root@axinlinux-01 tmp]# rm -rf /tmp/mongobak/alldatabase/config/

[root@axinlinux-01 tmp]# mongorestore -h 127.0.0.1 --port 20000 --drop /tmp/mongobak/alldatabase #这样就能够了

[root@axinlinux-01 tmp]# mongo --port 20000 #咱们在进入到mongodb分片里看一下是否已恢复

mongos> show dbs #查看一下就有了

admin 0.000GB

config 0.001GB

db2 0.000GB

db3 0.000GB

testdb 0.000GB

2.恢复指定库

[root@axinlinux-01 tmp]# mongorestore --host 127.0.0.1 --port 20000 -d testdb /tmp/mongobak/alldatabase/testdb