文档章节

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

Axin-linux
 Axin-linux
发布于 04/01 16:26
字数 5343
阅读 14
收藏 2

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 27001、副本集2 27002、副本集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

 

 

 

 

 

 

© 著作权归作者所有

Axin-linux
粉丝 6
博文 121
码字总数 249504
作品 0
济南
私信 提问
mongodb安装、连接,mongodb用户管理、创建集合、数据管理、备份恢复,副本集介绍、搭建、测试,分片介绍、搭建、测试,php的mongodb扩展、mongo扩展

21.26 mongodb介绍 21.27 mongodb安装 21.28 连接mongodb 21.29 mongodb用户管理 21.30 mongodb创建集合、数据管理 21.31 php的mongodb扩展 21.32 php的mongo扩展 21.33 mongodb副本集介绍 ...

tobej
07/16
77
0
【0716】NoSQL——mogodb

21.26 mongodb介绍 介绍: 官网www.mongodb.com, 当前最新版3.4 C++ 编写,基于分布式的,属于 NoSQL 的一种 在 NoSQL 中是最像关系型数据库的 MongoDB 将数据存储为一个文档,数据结构由键...

alexis7gunner
07/21
0
0
从零开始搭建MongoDB数据库即服务(有彩蛋)

本文根据DBAplus社群第118期线上分享整理而成,文末还有好书送哦~ 分享大纲: 首先介绍一下『数据库即服务』。『数据库即服务』其实是『Database-as-a-service』的中文翻译,我们看看它在维基...

郑涔
2017/09/07
0
0
mongodb备份与恢复(下)—ttlsa教程系列之mongodb(九)

一. 适用于mongodb任何架构(standalon、replic set、sharding)备份脚本 需要安装perl的MongoDB模块,安装方法参见:使用cpanm安装perl相关模块 http://www.ttlsa.com/html/2030.html 。代码这...

90后爱国
2014/09/15
41
0
MongoDB 最佳实践

已经有很多关于 NoSQL 选择的文章了。影响你选择数据库的因素有:读/写操作的吞吐量,持久性,一致性,延迟性等等。Nathan Hurst 的文章“Visual Guide to NoSQL System” 很好的总结了这一点...

红薯
2012/02/21
7.7K
11

没有更多内容

加载失败,请刷新页面

加载更多

3_数组

3_数组

行者终成事
今天
7
0
经典系统设计面试题解析:如何设计TinyURL(二)

原文链接:https://www.educative.io/courses/grokking-the-system-design-interview/m2ygV4E81AR 编者注:本文以一道经典的系统设计面试题:《如何设计TinyURL》的参考答案和解析为例,帮助...

APEMESH
今天
7
0
使用logstash同步MySQL数据到ES

概述   在生成业务常有将MySQL数据同步到ES的需求,如果需要很高的定制化,往往需要开发同步程序用于处理数据。但没有特殊业务需求,官方提供的logstash就很有优势了。   在使用logstas...

zxiaofan666
今天
10
0
X-MSG-IM-分布式信令跟踪能力

经过一周多的鏖战, X-MSG-IM的分布式信令跟踪能力已基本具备, 特点是: 实时. 只有要RX/TX就会实时产生信令跟踪事件, 先入kafka, 再入influxdb待查. 同时提供实时sub/pub接口. 完备. 可以完整...

dev5
今天
7
0
OpenJDK之CyclicBarrier

OpenJDK8,本人看的是openJDK。以前就看过,只是经常忘记,所以记录下 图1 CyclicBarrier是Doug Lea在JDK1.5中引入的,作用就不详细描述了,主要有如下俩个方法使用: await()方法,如果当前线...

克虏伯
今天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部