mongodb（下）

mongodb 副本集

早期版本使用master-slave，一主一从和MySQL类似，但slave在此架构中为只读，当主库宕机后，从库不能自动切换为主 目前已经淘汰master-slave模式，改为副本集，这种模式下有一个主(primary)，和多个从(secondary)，只读。支持给它们设置权重，当主宕掉后，权重最高的从切换为主 在此架构中还可以建立一个仲裁(arbiter)的角色，它只负责裁决，而不存储数据 再此架构中读写数据都是在主上，要想实现负载均衡的目的需要手动指定读库的目标server

mongo 副本集原理图：

配置副本集

准备三台机器： 192.168.127.128(primary) 192.168.127.129(secondary) 192.168.127.130(secondary)

编辑三台机器的配置文件，更改或增加：

# 修改绑定的IP
bind 127.0.0.1,192.168.127.x

replication:
  # oplog大小,注意空格
  oplogSizeMB: 20
  # 复制集名称
  replSetName: mongo

重启服务

systemctl restart mongod

连接主，在主上运行命令

mongo
> use admin

>config={_id:"mongo",members:[{_id:0,host:"192.168.127.128:27017"},{_id:1,host:"192.168.127.129:27017"},{_id:2,host:"192.168.127.130:27017"}]}

> rs.initiate(config)


> rs.status() # 查看状态
 如果两个从上的状态为"stateStr" : "STARTUP", 则需要进行如下操作

> config={_id:"mongo",members:[{_id:0,host:"192.168.127.128:27017"},{_id:1,host:"192.168.127.129:27017"},{_id:2,host:"192.168.127.130:27017"}]}

> rs.reconfig(config)
 # 此时再次查看rs.status()会发现从的状态变为SECONDARY

还可选择动态添加，在主上：

mongo
> use admin

> config={_id:"mongo",members:[{_id:0,host:"192.168.127.128:27017"}]}

> rs.add("192.168.127.129:27017") # 动态添加

副本集测试

主上面：

> use mydb
> db.createCollection('testc')
> show dbs

从上面：

> show dbs 失败，因为没有权限
> rs.slaveOk()  赋予从权限
> show dbs 可以查看
> use mydb
> show tables

修改权重

# 在主上
> rs.status()  # 查看从的health 如果是1 就说明是健康的
> rs.config()  # 查看权重 （priority），权重越高就会变成主

> cfg=rs.conf()
> cfg.members[0].priority = 3  # 设置第一个从机子上的权重为 3
> cfg.members[1].priority = 2  # 设置第二个从机子上的权重为 2
> cfg.members[2].priority = 1  # 设置第三个从机子上的权重为 1

> rs.reconfig(cfg)
> rs.config()  # 此时查看从的权重是否不同

# 禁掉主上面的端口
iptables -I INPUT -p tcp  --dport 27017 -j DROP


# 从上面：
# 权重最高的从变成主，此时查看 rs.status() 就会看到原来的主 health 变成 0

# 主上面：
iptables -D INPUT -p tcp  --dport 27017 -j DROP
# 主恢复之后，从上面添加的数据会自动添加到主上面

重启问题

# 重启错误问题
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] 
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] 
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2016-02-21T20:07:22.136+0800 I CONTROL  [initandlisten] 

# 1.初始化数据库
# echo never>/sys/kernel/mm/transparent_hugepage/enabled
# echo never > /sys/kernel/mm/transparent_hugepage/defrag
# service mongod restart

# 2.关闭netfiler
iptables -F

mongodb 分片搭建

分片就是将数据库进行拆分，将大型集合分隔到不同服务器上。比如，本来100G的数据，可以分割成10份存储到10台服务器上，这样每台机器只有10G的数据。 通过一个mongos的进程（路由）实现分片后的数据存储与访问，也就是说mongos是整个分片架构的核心，对客户端而言是不知道是否有分片的，客户端只需要把读写操作转达给mongos即可。 虽然分片会把数据分隔到很多台服务器上，但是每一个节点都是需要有一个备用角色的，这样能保证数据的高可用。 当系统需要更多空间或者资源的时候，分片可以让我们按需方便扩展，只需要把mongodb服务的机器加入到分片集群中即可

分片架构图

分片的相关概念

• mongos: 数据库集群请求的入口，所有的请求都通过mongos进行协调，不需要在应用程序添加一个路由选择器，mongos自己就是一个请求分发中心，它负责把对应的数据请求请求转发到对应的shard服务器上。在生产环境通常有多mongos作为请求的入口，防止其中一个挂掉所有的mongodb请求都没有办法操作。

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

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

分片搭建

准备三台机器 A B C

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

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

• C(192.168.127.130)搭建：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配置

mongodb3.4版本以后需要对config server创建副本集

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

mkdir /etc/mongod/

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 = x.x.x.x  # 对应绑定的ip 
port = 21000
fork = true
configsvr = true #declare this is a config db of a cluster;
replSet=configs #副本集名称
maxConns=20000 #设置最大连接数

启动三台机器的config server

mongod -f /etc/mongod/config.conf  
# 三台机器都要操作
# 登录任意一台机器的21000端口，初始化副本集

mongo --port 21000
> config = { _id: "configs", members: [ {_id : 0, host : "192.168.127.128:21000"},{_id : 1, host : "192.168.127.129:21000"},{_id : 2, host : "192.168.127.129:21000"}] }
> rs.initiate(config)
{ "ok" : 1 }

分片配置

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

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 = x.x.x.x  # 对应ip
port = 27001
fork = true
httpinterface=true #打开web监控,3.6版本后这两行不支持
rest=true
replSet=shard1 #副本集名称
shardsvr = true #declare this is a shard db of a cluster;
maxConns=20000 #设置最大连接数

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 = x.x.x.x # 对应主机所在的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 #设置最大连接数

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
port = 27003
fork = true
httpinterface=true #打开web监控
rest=true   # 3.6版本移除了这2个参数, 要去掉, 不然无法启动
replSet=shard3 #副本集名称
shardsvr = true #declare this is a shard db of a cluster;
maxConns=20000 #设置最大连接数

启动shard1

mongod -f /etc/mongod/shard1.conf 
# 三台机器都要操作
# 登录128或者129任何一台机器的27001端口初始化副本集，130之所以不行，
# 是因为shard1我们把133这台机器的27001端口作为了仲裁节点


mongo --port 27001

> use admin
> config = { _id: "shard1", members: [ {_id : 0, host : "192.168.127.128:27001"}, {_id: 1,host : "192.168.127.129:27001"},{_id : 2, host : "192.168.127.130:27001",arbiterOnly:true}] }
> rs.initiate(config)

启动shard2

mongod -f /etc/mongod/shard2.conf 
# 三台机器都要操作
# 登录129或者130任何一台机器的27002端口初始化副本集，128之所以不行，
# 是因为shard2我们把130这台机器的27002端口作为了仲裁节点


mongo --port 27002

> use admin
> config = { _id: "shard2", members: [ {_id : 0, host : "192.168.127.128:27002" ,arbiterOnly:true},{_id : 1, host : "192.168.127.129:27002"},{_id : 2, host : "192.168.127.130:27002"}] }
> rs.initiate(config)

启动shard3

mongod -f /etc/mongod/shard3.conf 
# 三台机器都要操作
# 登录128或者130任何一台机器的27003端口初始化副本集，129之所以不行，
# 是因为shard3我们把132这台机器的27003端口作为了仲裁节点


mongo --port 27003

> use admin
> config = { _id: "shard3", members: [ {_id : 0, host : "192.168.127.128:27003"},  {_id : 1, host : "192.168.127.129:27003", arbiterOnly:true}, {_id : 2, host : "192.168.127.130:27003"}] }
> rs.initiate(config)

配置路由服务器

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

vim /etc/mongod/mongos.conf 
# 加入如下内容
pidfilepath = /var/run/mongodb/mongos.pid
logpath = /data/mongodb/mongos/log/mongos.log
logappend = true
bind_ip = x.x.x.x # 对应主机所在IP
port = 20000
fork = true

configdb = configs/192.168.127.128:21000, 192.168.27.129:21000, 192.168.127.130:21000 #监听的配置服务器,只能有1个或者3个，configs为配置服务器的副本集名字
maxConns=20000 #设置最大连接数

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

mongos -f /etc/mongod/mongos.conf

启用分片

登录任何一台20000端口

mongo --port 20000  

# 把所有分片和路由器串联
> sh.addShard("shard1/192.168.127.128:27001,192.168.127.129:27001,192.168.127.130:27001")
> sh.addShard("shard2/192.168.127.128:27002,192.168.127.129:27002,192.168.127.130:27002")
> sh.addShard("shard3/192.168.127.128:27003,192.168.127.129:27003,192.168.127.130:27003")

# 查看集群状态
> sh.status()

测试

登录任何一台20000端口

mongo --port 20000  

> use admin

> db.runCommand({ enablesharding : "testdb"}) 
# 或者
> sh.enableSharding("testdb") # 指定要分片的数据库


> db.runCommand( { shardcollection : "testdb.table1",key : {id: 1} } ) 
# 或者
> sh.shardCollection("testdb.table1",{"id":1} ) # 指定数据库里需要分片的集合和片键


> use testdb
> for (var i = 1; i <= 10000; i++) db.table1.save({id:i,"test1":"testval1"}) # 插入测试数据
> db.table1.stats() # 查看table1状态

mongodb 备份和恢复

# 备份指定库

mongodump --host 127.0.0.1 --port 20000  -d mydb -o /tmp/mongobak
# 它会在/tmp/目录下面生成一个mydb的目录


# 备份所有库
mongodump --host 127.0.0.1 --port 20000 -o /tmp/mongobak/alldatabase


# 指定备份集合
mongodump --host 127.0.0.1 --port 20000 -d mydb -c c1 -o /tmp/mongobak/
 # 它依然会生成mydb目录，再在这目录下面生成两个文件


# 导出集合为json文件
mongoexport --host 127.0.0.1 --port 20000 -d mydb -c c1 -o /tmp/mydb2/1.json

# 恢复所有库

mongorestore -h 127.0.0.1 --port 20000 --drop dir/ 
# 其中dir是备份所有库的目录名字，
# 其中--drop可选，意思是当恢复之前先把之前的数据删除，不建议使用


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


# 恢复集合
mongorestore -d mydb -c testc dir/mydb/testc.bson  # -c后面跟要恢复的集合名字，dir是备份mydb库时生成文件所在路径，这里是一个bson文件的路径


# 导入集合
mongoimport -d mydb -c testc --file /tmp/testc.json