精华内容
下载资源
问答
  • MongoDB集群新增副本集

    2021-06-18 09:51:24
    背景: 公司MongoDB集群(做了用户登录认证)是有三台机器,做的副本集+分片的集群模式,由于数据量越来越大,导致机器负载不断增大,为了解决机器负载高的问题,需要添加新副本集来解决集群压力。 环境: MongoDB集群...

    背景:

           公司MongoDB集群(做了用户登录认证)是有三台机器,做的副本集+分片的集群模式,由于数据量越来越大,导致机器负载不断增大,为了解决机器负载高的问题,需要添加新副本集来解决集群压力。

    环境:

    MongoDB集群现状(副本集+分片)
    主机IP地址 端口备注
    MongoDB110.0.8.74

    数据端口:27017、27018、27019

    config端口:20000

    mongos路由端口:30000

    27017为primary
    MongoDB210.0.8.75

    数据端口:27017、27018、27019

    config端口:20000

    mongos路由端口:30000

    27019为primary
    MongoDB310.0.8.76

    数据端口:27017、27018、27019

    config端口:20000

    mongos路由端口:30000

    27018为primary

    新增副本集
    MongoDB410.0.8.55数据端口:27017、27018、27019

    statestr状态说明/解释:

    STARTUP:刚加入到复制集中,配置还未加载
    STARTUP2:配置已加载完,初始化状态
    RECOVERING:正在恢复,不适用读
    ARBITER: 仲裁者
    DOWN:节点不可到达
    UNKNOWN:未获取其他节点状态而不知是什么状态,一般发生在只有两个成员的架构
    REMOVED:移除复制集
    ROLLBACK:数据回滚,在回滚结束时,转移到RECOVERING或SECONDARY状态
    FATAL:出错。查看日志grep “replSet FATAL”找出错原因,重新做同步
    PRIMARY:主节点
    SECONDARY:备份节点

    说明:

    1、在添加副本集的过程中,通过rs.status()查看,新增的副本集stateStr的状态会从 STARTUP--> STARTUP2 --> SECONDARY,STARTUP2状态会维持很久,这是因为在同步主的数据,当状态变成SECONDARY,表示副本集添加成功。

    2、新增的节点在安装MongoDB过程中只需要开启认证,不需要新建用户,在添加副本集的过程中,会自动同步账号密码。

    操作步骤:

    1、在新增的机器(10.0.8.55)上安装mongodb,并且启动三个mongod进程,端口分别为27017、27018、27019(略)

    可参考:mongodb集群搭建

    2、在MongoDB1上新增10.0.8.55:27017副本集

    [ yukw @ MongoDB1 10.0.8.74 ] ~
    $ /data/service/mongodbwork/mongodb/bin/mongo -port 27017
    MongoDB shell version: 3.0.6
    connecting to: 127.0.0.1:27017/test
    shard1:PRIMARY> use admin
    switched to db admin
    shard1:PRIMARY> db.auth("yukw27017","Yukw27017_qwer")
    1
    shard1:PRIMARY> rs.status()
    {
    	"set" : "shard1",
    	"date" : ISODate("2021-06-18T02:19:02.462Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27017",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5527840,
    			"optime" : Timestamp(1623982729, 5),
    			"optimeDate" : ISODate("2021-06-18T02:18:49Z"),
    			"electionTime" : Timestamp(1618454907, 1),
    			"electionDate" : ISODate("2021-04-15T02:48:27Z"),
    			"configVersion" : 11,
    			"self" : true
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27017",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527492,
    			"optime" : Timestamp(1623982729, 5),
    			"optimeDate" : ISODate("2021-06-18T02:18:49Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:19:02.078Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:19:01.257Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.74:27017",
    			"configVersion" : 11
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27017",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527828,
    			"optime" : Timestamp(1623982729, 5),
    			"optimeDate" : ISODate("2021-06-18T02:18:49Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:19:02.078Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:19:01.936Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.74:27017",
    			"configVersion" : 11
    		}
    	],
    	"ok" : 1,
    	"$gleStats" : {
    		"lastOpTime" : Timestamp(0, 0),
    		"electionId" : ObjectId("6077a97b5cfe481bacbf3233")
    	}
    }
    shard1:PRIMARY> rs.add("10.0.8.55:27017")
    {
    	"ok" : 1,
    	"$gleStats" : {
    		"lastOpTime" : Timestamp(1623982772, 1),
    		"electionId" : ObjectId("6077a97b5cfe481bacbf3233")
    	}
    }
    shard1:PRIMARY> rs.status()
    {
    	"set" : "shard1",
    	"date" : ISODate("2021-06-18T02:19:35.278Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27017",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5527873,
    			"optime" : Timestamp(1623982772, 1),
    			"optimeDate" : ISODate("2021-06-18T02:19:32Z"),
    			"electionTime" : Timestamp(1618454907, 1),
    			"electionDate" : ISODate("2021-04-15T02:48:27Z"),
    			"configVersion" : 12,
    			"self" : true
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27017",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527525,
    			"optime" : Timestamp(1623982772, 1),
    			"optimeDate" : ISODate("2021-06-18T02:19:32Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:19:34.606Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:19:33.328Z"),
    			"pingMs" : 0,
    			"configVersion" : 12
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27017",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527861,
    			"optime" : Timestamp(1623982772, 1),
    			"optimeDate" : ISODate("2021-06-18T02:19:32Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:19:34.606Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:19:34.001Z"),
    			"pingMs" : 0,
    			"configVersion" : 12
    		},
    		{
    			"_id" : 3,
    			"name" : "10.0.8.55:27017",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY", ### stateStr状态会从 STARTUP --> STARTUP2 --> SECONDARY
    			"uptime" : 0,
    			"optime" : Timestamp(1623982716, 1),
    			"optimeDate" : ISODate("2021-06-18T02:18:36Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:19:34.623Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:19:34.750Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.74:27017",
    			"configVersion" : 12
    		}
    	],
    	"ok" : 1,
    	"$gleStats" : {
    		"lastOpTime" : Timestamp(1623982772, 1),
    		"electionId" : ObjectId("6077a97b5cfe481bacbf3233")
    	}
    }
    

    3、在MongoDB2上新增10.0.8.55:27019副本集

    [ yukw @ MongoDB2 10.0.8.75 ] ~
    $ /data/service/mongodbwork/mongodb/bin/mongo -port 27019
    MongoDB shell version: 3.0.6
    connecting to: 127.0.0.1:27019/test
    shard3:PRIMARY> use admin
    switched to db admin
    shard3:PRIMARY> db.auth("yukw27019","Yukw27019_qwer")
    1
    shard3:PRIMARY> rs.status()
    {
    	"set" : "shard3",
    	"date" : ISODate("2021-06-18T02:24:43.916Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27019",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527828,
    			"optime" : Timestamp(1623983002, 1),
    			"optimeDate" : ISODate("2021-06-18T02:23:22Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:24:42.516Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:24:42.705Z"),
    			"pingMs" : 0,
    			"lastHeartbeatMessage" : "could not find member to sync from",
    			"configVersion" : 3
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27019",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5527830,
    			"optime" : Timestamp(1623983002, 1),
    			"optimeDate" : ISODate("2021-06-18T02:23:22Z"),
    			"electionTime" : Timestamp(1618455259, 1),
    			"electionDate" : ISODate("2021-04-15T02:54:19Z"),
    			"configVersion" : 3,
    			"self" : true
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27019",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527828,
    			"optime" : Timestamp(1623983002, 1),
    			"optimeDate" : ISODate("2021-06-18T02:23:22Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:24:42.536Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:24:42.875Z"),
    			"pingMs" : 0,
    			"lastHeartbeatMessage" : "could not find member to sync from",
    			"configVersion" : 3
    		}
    	],
    	"ok" : 1
    }
    shard3:PRIMARY> rs.add("10.0.8.55:27019")
    { "ok" : 1 }
    shard3:PRIMARY> rs.status()
    {
    	"set" : "shard3",
    	"date" : ISODate("2021-06-18T02:25:01.372Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27019",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527846,
    			"optime" : Timestamp(1623983098, 1),
    			"optimeDate" : ISODate("2021-06-18T02:24:58Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:25:00.214Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:25:00.770Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.75:27019",
    			"configVersion" : 4
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27019",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5527848,
    			"optime" : Timestamp(1623983098, 1),
    			"optimeDate" : ISODate("2021-06-18T02:24:58Z"),
    			"electionTime" : Timestamp(1618455259, 1),
    			"electionDate" : ISODate("2021-04-15T02:54:19Z"),
    			"configVersion" : 4,
    			"self" : true
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27019",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527846,
    			"optime" : Timestamp(1623983098, 1),
    			"optimeDate" : ISODate("2021-06-18T02:24:58Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:25:00.213Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:25:00.935Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.75:27019",
    			"configVersion" : 4
    		},
    		{
    			"_id" : 3,
    			"name" : "10.0.8.55:27019",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",  ### stateStr状态会从 STARTUP --> STARTUP2 --> SECONDARY
    			"uptime" : 1,
    			"optime" : Timestamp(1623983098, 1),
    			"optimeDate" : ISODate("2021-06-18T02:24:58Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:25:00.230Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:25:00.362Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.75:27019",
    			"configVersion" : 4
    		}
    	],
    	"ok" : 1
    }

    4、在MongoDB3上新增10.0.8.55:27018副本集

    [ yukw @ MongoDB3 10.0.8.76 ] ~
    $ /data/service/mongodbwork/mongodb/bin/mongo -port 27018
    MongoDB shell version: 3.0.6
    connecting to: 127.0.0.1:27018/test
    shard2:PRIMARY> use admin
    switched to db admin
    shard2:PRIMARY> db.auth("yukw27018","Yukw27018_Nsw0316")
    1
    shard2:PRIMARY> rs.status()
    {
    	"set" : "shard2",
    	"date" : ISODate("2021-06-18T02:27:03.762Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27018",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5528293,
    			"optime" : Timestamp(1623983202, 1),
    			"optimeDate" : ISODate("2021-06-18T02:26:42Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:27:02.902Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:27:02.946Z"),
    			"pingMs" : 0,
    			"lastHeartbeatMessage" : "could not find member to sync from",
    			"configVersion" : 3
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27018",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527971,
    			"optime" : Timestamp(1623983202, 1),
    			"optimeDate" : ISODate("2021-06-18T02:26:42Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:27:02.902Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:27:03.259Z"),
    			"pingMs" : 0,
    			"lastHeartbeatMessage" : "could not find member to sync from",
    			"configVersion" : 3
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27018",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5528294,
    			"optime" : Timestamp(1623983202, 1),
    			"optimeDate" : ISODate("2021-06-18T02:26:42Z"),
    			"electionTime" : Timestamp(1618454955, 1),
    			"electionDate" : ISODate("2021-04-15T02:49:15Z"),
    			"configVersion" : 3,
    			"self" : true
    		}
    	],
    	"ok" : 1
    }
    shard2:PRIMARY> rs.add("10.0.8.55:27018")
    { "ok" : 1 }
    shard2:PRIMARY> rs.status()
    {
    	"set" : "shard2",
    	"date" : ISODate("2021-06-18T02:27:21.282Z"),
    	"myState" : 1,
    	"members" : [
    		{
    			"_id" : 0,
    			"name" : "10.0.8.74:27018",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5528310,
    			"optime" : Timestamp(1623983202, 1),
    			"optimeDate" : ISODate("2021-06-18T02:26:42Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:27:21.001Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:27:20.998Z"),
    			"pingMs" : 2,
    			"configVersion" : 4
    		},
    		{
    			"_id" : 1,
    			"name" : "10.0.8.75:27018",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",
    			"uptime" : 5527988,
    			"optime" : Timestamp(1623983238, 1),
    			"optimeDate" : ISODate("2021-06-18T02:27:18Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:27:20.989Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:27:19.323Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.76:27018",
    			"configVersion" : 4
    		},
    		{
    			"_id" : 2,
    			"name" : "10.0.8.76:27018",
    			"health" : 1,
    			"state" : 1,
    			"stateStr" : "PRIMARY",
    			"uptime" : 5528312,
    			"optime" : Timestamp(1623983238, 1),
    			"optimeDate" : ISODate("2021-06-18T02:27:18Z"),
    			"electionTime" : Timestamp(1618454955, 1),
    			"electionDate" : ISODate("2021-04-15T02:49:15Z"),
    			"configVersion" : 4,
    			"self" : true
    		},
    		{
    			"_id" : 3,
    			"name" : "10.0.8.55:27018",
    			"health" : 1,
    			"state" : 2,
    			"stateStr" : "SECONDARY",  ### stateStr状态会从 STARTUP --> STARTUP2 --> SECONDARY
    			"uptime" : 0,
    			"optime" : Timestamp(1623983238, 1),
    			"optimeDate" : ISODate("2021-06-18T02:27:18Z"),
    			"lastHeartbeat" : ISODate("2021-06-18T02:27:21.006Z"),
    			"lastHeartbeatRecv" : ISODate("2021-06-18T02:27:21.123Z"),
    			"pingMs" : 0,
    			"syncingTo" : "10.0.8.76:27018",
    			"configVersion" : 4
    		}
    	],
    	"ok" : 1
    }
    

    附加:

    删除副本集:

    ### 在primary机器上删除副本集
    
    shard1:PRIMARY> rs.remove("10.0.8.55:27017")
    { "ok" : 1 }
    
    shard2:PRIMARY> rs.remove("10.0.8.55:27019")
    { "ok" : 1 }
    
    shard3:PRIMARY> rs.remove("10.0.8.55:27018")
    { "ok" : 1 }
    
    展开全文
  • 由于51cto的编辑不太好用,这是有道上的文档http://note.youdao.com/noteshare?id=aedd53c99b4a97aebbe9af136104113a在 MongoDB 中,有两种数据冗余方式...三种集群:1、 主从集群(目前已经不推荐使用)2、 副本集3、 ...

    由于51cto的编辑不太好用,这是有道上的文档http://note.youdao.com/noteshare?id=aedd53c99b4a97aebbe9af136104113a

    在 MongoDB 中,有两种数据冗余方式,一种 是 Master-Slave 模式(主从复制),一种是 Replica Sets 模式(副本集)。

    三种集群:

    1、 主从集群(目前已经不推荐使用)

    2、 副本集

    3、 分片集群

    分片集群是三种模式中最复杂的一种,副本集其实一种互为主从的关系,可理解为主主。

    副本集指将数据复制,多份保存,不同服务器保存同一份数据,在出现故障时自动切换。对应的是数据冗余、备份、镜像、读写分离、高可用性等关键词;

    而分片则指为处理大量数据,将数据分开存储,不同服务器保存不同的数据,它们的数据总和即为整个数据集。追求的是高性能。

    在生产环境中,通常是这两种技术结合使用,分片+副本集。

    下面的内容将介绍mongodb副本集、分片集群、拆分gridfs上传的文件、利用nginx-gridfs结合mongodb分片集群,并且在浏览器显示拆分的文件,四大类。

    第1章 Mongodb副本集集群介绍

    1.1 简介

    为什么介绍副本集,因为在3.6版本后,分片集群搭建和副本集一起使用。

    副本集实现了mongodb集群的高可用。

    副本集是一种在多台机器同步数据的进程,副本集体提供了数据冗余,扩展了数据可用性。在多台服务器保存数据可以避免因为一台服务器导致的数据丢失。

    也可以从硬件故障或服务中断解脱出来,利用额外的数据副本,可以从一台机器致力于灾难恢复或者备份。

    在一些场景,可以使用副本集来扩展读性能,客户端有能力发送读写操作给不同的服务器。也可以在不同的数据中心获取不同的副本来扩展分布式应用的能力。

    mongodb副本集是一组拥有相同数据的mongodb实例,主mongodb接受所有的写操作,所有的其他实例可以接受主实例的操作以保持数据同步。

    主实例接受客户的写操作,副本集只能有一个主实例,因为为了维持数据一致性,只有一个实例可写,主实例的日志保存在oplog。

    1.2 原理

    MongoDB 的副本集不同于以往的主从模式。

    在集群Master故障的时候,副本集可以自动投票,选举出新的Master,并引导其余的Slave服务器连接新的Master,而这个过程对于应用是透明的。可以说MongoDB的副本集是自带故障转移功能的主从复制。

    相对于传统主从模式的优势

    传统的主从模式,需要手工指定集群中的 Master。如果 Master 发生故障,一般都是人工介入,指定新的 Master。 这个过程对于应用一般不是透明的,往往伴随着应用重

    新修改配置文件,重启应用服务器等。而 MongoDB 副本集,集群中的任何节点都可能成为 Master 节点。一旦 Master 节点故障,则会在其余节点中选举出一个新的 Master 节点。 并引导剩余节点连接到新的 Master 节点。这个过程对于应用是透明的。

    6156b79a5891c33ef1834ae7a1eefc09.png

    一个副本集即为服务于同一数据集的多个MongoDB实例,其中一个为主节点,其余的都为从节点。主节点上能够完成读写操作,从节点仅能用于读操作。主节点需要记录所有改变数据库状态的操作,这些记录保存在oplog中,这个文件存储在local数据库,各个从节点通过此oplog来复制数据并应用于本地,保持本地的数据与主节点的一致。oplog具有幂等性,即无论执行几次其结果一致,这个比mysql的二进制日志更好用。集群中的各节点还会通过传递心跳信息来检测各自的健康状况。

    当主节点故障时,多个从节点会触发一次新的选举操作,并选举其中的一个成为新的主节点(通常谁的优先级更高,谁就是新的主节点),心跳信息默认每2秒传递一次。客户端连接到副本集后,不关心具体哪一台机器是否挂掉。主服务器负责整个副本集的读写,副本集定期同步数据备份。一旦主节点挂掉,副本节点就会选举一个新的主服务器。这一切对于应用服务器不需要关心。

    3d689ac6056491b01f8406d00a17f030.png

    94f11ca116ec414b2da7a0c36901a6c7.png

    副本集中的副本节点在主节点挂掉后通过心跳机制检测到后,就会在集群内发起主节点的选举机制,自动选举出一位新的主服务器。

    5eb78ac32d65c0d65b1918b4c563d265.png

    1.3 节点

    副本集拥有三种节点:主节点、从节点、仲裁节点

    1)主节点负责处理客户端请求,读、写数据, 记录在其上所有操作的oplog;

    2)从节点定期轮询主节点获取这些操作,然后对自己的数据副本执行这些操作,从而保证从节点的数据与主节点一致。默认情况下,从节点不支持外部读取,但可以设置;副本集的机制在于主节点出现故障的时候,余下的节点会选举出一个新的主节点,从而保证系统可以正常运行。

    3)仲裁节点不复制数据,仅参与投票。由于它没有访问的压力,比较空闲,因此不容易出故障。由于副本集出现故障的时候,存活的节点必须大于副本集节点总数的一半,否则无法选举主节点,或者主节点会自动降级为从节点,整个副本集变为只读。因此,增加一个不容易出故障的仲裁节点,可以增加有效选票,降低整个副本集不可用的风险。仲裁节点可多于一个。也就是说只参与投票,不接收复制的数据,也不能成为活跃节点。

    注意:

    官方推荐MongoDB副本节点最少为3台,建议副本集成员为奇数,最多12个副本节点,最多7个节点参与选举。限制副本节点的数量,主要是因为一个集群中过多的副本节点,增加了复制的成本,反而拖累了集群的整体性能。太多的副本节点参与选举,也会增加选举的时间。而官方建议奇数的节点,是为了避免脑裂 的发生。

    1.4 工作流程

    在MongoDB副本集中,主节点负责处理客户端的读写请求,备份节点则负责映射主节点的数据。备份节点的工作原理过程可以大致描述为,备份节点定期轮询主节点上的数据操作,从而保证跟主节点的数据同步。至于主节点上的所有数据库状态改变的操作,都会存放在一张特定的系统表中。备份节点则是根据这些数据进行自己的数据更新。

    1.4.1 Oplog

    上面提到的数据库状态改变的操作,称为 oplog(operationlog,主节点操作记录。oplog 存储在local数据库的"oplog.rs"表中。副本集中备份节点异步的从主节点同步oplog,然后重新执行它记录的操作,以此达到了数据同步的作用。

    关于 oplog 有几个注意的地方:

    1)oplog 只记录改变数据库状态的操作

    2)存储在oplog 中的操作并不是和主节点执行的操作完全一样,例如"$inc"操作就会转化为"$set"操作

    3)oplog 存储在固定集合中(capped collection),当oplog的数量超过oplogSize,新的操作就会覆盖旧的操作

    1.4.2 数据同步

    在副本集中,有两种数据同步的方式:

    1)initial sync(初始化):这个过程发生在当副本集中创建一个新的数据库或其中某个节点刚从宕机中恢复,或者向副本集中添加新的成员的时候,默认的,副本集中的节点会从离它最近的节点复制oplog来同步数据,这个最近的节点可以是primary也可以是拥有最新oplog副本的 secondary节点。该操作一般会重新初始化备份节点,开销较大。

    2)replication(复制):在初始化后这个操作会一直持续的进行着,以保持各个secondary节点之间的数据同步。

    当遇到无法同步的问题时,只能使用以下两种方式进行initial sync了

    1)第一种方式就是停止该节点,然后删除目录中的文件,重新启动该节点。这样,这个节点就会执行 initial sync

    注意:通过这种方式,sync的时间是根据数据量大小的,如果数据量过大,sync时间就会很长同时会有很多网络传输,可能会影响其他节点的工作

    2)第二种方式,停止该节点,然后删除目录中的文件,找一个比较新的节点,然后把该节点目录中的文件拷贝到要 sync 的节点目录中

    1.5 副本集选举过程

    Mongodb副本集选举采用的是Bully算法,这是一种协调者(主节点)竞选算法,主要思想是集群的每个成员都可以声明它是主节点并通知其他节点。别的节点可以选择接受这个声称或是拒绝并进入主节点竞争,被其他所有节点接受的节点才能成为主节点。

    节点按照一些属性来判断谁应该胜出,这个属性可以是一个静态ID,也可以是更新的度量像最近一次事务ID(最新的节点会胜出)

    1.5.1 副本集的选举过程

    1)得到每个服务器节点的最后操作时间戳。每个 mongodb 都有 oplog 机制会记录本机的操作,方便和主服 务器进行对比数据是否同步还可以用于错误恢复。

    2)如果集群中大部分服务器 down 机了,保留活着的节点都为 secondary 状态并停止,不选举了。

    3)如果集群中选举出来的主节点或者所有从节点最后一次同步时间看起来很旧了,停止选举等待人来操作。

    4)如果上面都没有问题就选择最后操作时间戳最新(保证数据是最新的)的服务器节点作为主节点。

    1.5.2 副本集选举的特点

    选举还有个前提条件,参与选举的节点数量必须大于副本集总节点数量的一半(建议副本集成员为奇数。最多12个副本节点,最多7个节点参与选举)如果已经小于一半了所有节点保持只读状态。集合中的成员一定要有大部分成员(即超过一半数量)是保持正常在线状态,3个成员的副本集,需要至少2个从属节点是正常状态。

    如果一个从属节点挂掉,那么当主节点down掉 产生故障切换时,由于副本集中只有一个节点是正常的,少于一半,则选举失败。

    4个成员的副本集,则需要3个成员是正常状态(先关闭一个从属节点,然后再关闭主节点,产生故障切换,此时副本集中只有2个节点正常,则无法成功选举出新主节点)。

    1.6 MongoDB 同步延迟问题

    当你的用户抱怨修改过的信息不改变,删除掉的数据还在显示,你掐指一算,估计是数据库主从不同步。与其他提供数据同步的数据库一样,MongoDB 也会遇到同步延迟的问题,在MongoDB的Replica Sets模式中,同步延迟也经常是困扰使用者的一个大问题。

    1.6.1 什么是同步延迟

    首先,要出现同步延迟,必然是在有数据同步的场合,在 MongoDB 中,有两种数据冗余方式,一种是Master-Slave 模式,一种是Replica Sets模式。这两个模式本质上都是在一个节点上执行写操作, 另外的节点将主节点上的写操作同步到自己这边再进行执行。在MongoDB中,所有写操作都会产生 oplog,oplog是每修改一条数据都会生成一条,如果你采用一个批量 update 命令更新了 N 多条数据, 那么,oplog会有很多条,而不是一条。所以同步延迟就是写操作在主节点上执行完后,从节点还没有把 oplog拿过来再执行一次。而这个写操作的量越大,主节点与从节点的差别也就越大,同步延迟也就越大了。

    1.6.2 同步延迟带来的问题

    首先,同步操作通常有两个效果,一是读写分离,将读操作放到从节点上来执行,从而减少主节点的 压力。对于大多数场景来说,读多写少是基本特性,所以这一点是很有用的。

    另一个作用是数据备份, 同一个写操作除了在主节点执行之外,在从节点上也同样执行,这样我们就有多份同样的数据,一旦 主节点的数据因为各种天灾人祸无法恢复的时候,我们至少还有从节点可以依赖。但是主从延迟问题 可能会对上面两个效果都产生不好的影响。

    如果主从延迟过大,主节点上会有很多数据更改没有同步到从节点上。这时候如果主节点故障,就有 两种情况:

    1)主节点故障并且无法恢复,如果应用上又无法忍受这部分数据的丢失,我们就得想各种办法将这部 数据更改找回来,再写入到从节点中去。可以想象,即使是有可能,那这也绝对是一件非常恶心的活。

    2)主节点能够恢复,但是需要花的时间比较长,这种情况如果应用能忍受,我们可以直接让从节点提 供服务,只是对用户来说,有一段时间的数据丢失了,而如果应用不能接受数据的不一致,那么就只能下线整个业务,等主节点恢复后再提供服务了。

    如果你只有一个从节点,当主从延迟过大时,由于主节点只保存最近的一部分 oplog,可能会导致从 节点青黄不接,不得不进行 resync 操作,全量从主节点同步数据。

    带来的问题是:当从节点全量同步的时候,实际只有主节点保存了完整的数据,这时候如果主节点故障,很可能全部数据都丢掉了。

    1.7 副本集搭建过程

    1.7.1 环境准备

    Centos7 64位系统

    Mongodb 4.0版本

    三台虚拟机

    192.168.1.182:27017

    192.168.1.186:27017

    192.168.1.122:27017

    安装包(三台一样)

    下载地址

    https://www.mongodb.com/download-center?jmp=nav#community

    https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.2.tgz

    解压到/usr/local/mongodb/目录下

    1.7.2 搭建过程

    1、 创建数据目录(三台创建)

    mkdir /data/mongodb/27017/ -p

    2、 创建配置文件(三台配置一样)

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/27017/mongodb.log

    storage:

    dbPath: /data/mongodb/27017/

    journal:

    enabled: true

    processManagement:

    fork: true

    net:

    port: 27017

    bindIp: 0.0.0.0

    #副本集标志,三台name要一样,才能加入到副本集。

    replication:

    replSetName: data

    3、 启动

    启动三台实例

    /usr/local/mongodb/bin/mongod -f /data/mongodb/27017/mongodb.conf

    4、 初始化

    登录任意一台实例,进行初始化sql语句,三大步sql。

    config = { _id:"data", members:[

    {_id:0,host:"192.168.1.182:27017"},

    {_id:1,host:"192.168.1.186:27017"},

    {_id:2,host:"192.168.1.122:27017"}]

    }

    进入到admin,进行初始化

    use admin

    初始化需要时间

    rs.initiate( config )

    查看状态

    rs.status() #副本集状态,一个primary,其它SECONDARY。primary是主,只有primary能写入。

    注意:-id,为副本集配置文件里面的name一致。

    1.7.3 优先级设置

    primary的选举依赖于各个实例的优先权重,默认权重都是1

    复本集的主挑选权重最高的,权重一样的无法控制谁为主

    设置各个实例的优先权重,挑选自己想要的实例为主,只有primary可以更改权重配置

    conf = rs.config() #获取副本集的配置,默认权重都是1

    conf.members[0].priority = 10 #索引号从0开始,每次递增1,类似数组

    conf.members[1].priority = 5

    conf.members[2].priority = 2

    rs.reconfig(conf) #更新mongodb副本集的配置,优先权重最高的提升为primary。

    关闭启动后也为主

    至此,副本集搭建介绍完成

    第2章 Mongodb分片集群介绍

    Sharding cluster是一种可以水平扩展的模式,在数据量很大时特给力,实际大规模应用一般会采用这种架构去构建。sharding分片很好的解决了单台服务器磁盘空间、内存、cpu等硬件资源的限制问题,把数据水平拆分出去,降低单节点的访问压力。每个分片都是一个独立的数据库,所有的分片组合起来构成一个逻辑上的完整的数据库。因此,分片机制降低了每个分片的数据操作量及需要存储的数据量,达到多台服务器来应对不断增加的负载和数据的效果。

    2.1 Sharding分区概念

    将数据分散到不同的机器上,不需要功能强大的服务器就可以存储更多的数据和处理更大的负载。

    2.1.1 分片的基本思想

    将集合切成小块,这些块分散到若干片里,每个片只负责总数据的一部分。通过一个名为mongos的路由进程进行操作,mongos知道数据和片的对应关系(通过配置服务器)。大部分使用场景都是解决磁盘空间的问题,对于写入有可能会变差(+++里面的说明+++),查 询则尽量避免跨分片查询。

    2.1.2 使用分片的时机

    1)机器的磁盘不够用了。使用分片解决磁盘空间的问题。

    2)单个mongod已经不能满足写数据的性能要求。通过分片让写压力分散到各个分片上面,使用分片服务器自身的资源。

    3)想把大量数据放到内存里提高性能。和上面一样,通过分片使用分片服务器自身的资源。

    2.1.3 三种角色

    1)分片服务器(Shard Server)

    mongod实例,用于存储实际的数据块,实际生产环境中一个 shard server 角色可由几台机器组个一个 relica set 承担,防止主机单点故障。

    这是一个独立普通的mongod进程,保存数据信息。可以是一个副本集也可以是单独的一台服务器(生产环境都是副本集)。

    2)配置服务器(Config Server)

    mongod 实例,存储了整个 Cluster Metadata,其中包括 chunk 信息。

    这是一个独立的mongod进程,保存集群和分片的元数据,即各分片包含了哪些数据的信息。最先开始建立,启用日志功能。像启动普通的 mongod 一样启动。

    配置服务器,指定configsvr 选项。不需要太多的空间和资源,配置服务器的 1KB 空间相当于真是数据的 200MB。保存的只是数据的分布表。

    3)路由服务器(Route Server)

    mongos实例,前端路由,客户端由此接入,且让整个集群看上去像单一数据库,前端应用

    起到一个路由的功能,供程序连接。本身不保存数据,在启动时从配置服务器加载集群信息,开启 mongos 进程需要知道配置服务器的地址,指定configdb选项。

    2.1.4 片键的意义

    一个好的片键对分片至关重要。片键必须是一个索引,通过sh.shardCollection 加会自动创建索引。一个自增的片键对写入和数据均匀分布就不是很好, 因为自增的片键总会在一个分片上写入,后续达到某个阀值可能会写到别的分片。但是按照片键查询会非常高效。随机片键对数据的均匀分布效果很好。注意尽量避免在多个分片上进行查询。

    在所有分片上查询,mongos 会对结果进行归并排序

    7aa1f31c7d39d46baec9dae08b5e4ec2.png

    f605f36ba738557446371d9945891270.png

    2.1.5 分片的原理

    分片,是指将数据拆分,将其分散到不同的机器上。这样的好处就是,不需要功能强大的大型计算机也可以存储更多的数据,处理更大的负载。mongoDB 的分片,是将collection 的数据进行分割,然后将不同的部分分别存储到不同的机器上。当 collection 所占空间过大时,我们需要增加一台新的机器,分片会自动将 collection 的数据分发到新的机器上。

    2.1.6 分片集群的构造

    5b55298eaeefe6c80120f453b45ae273.png

    2.2 分片集群的搭建

    2.2.1 环境准备

    Centos7 64位系统

    Mongodb 4.0版本

    三台虚拟机

    ##三台路由服务器

    192.168.1.182:20000

    192.168.1.186:20000

    192.168.1.122:20000

    ##三台配置服务器

    192.168.1.182:21000

    192.168.1.186:21000

    192.168.1.122:21000

    ##九个分片数据服务器(测试复用三台),三组分片数据,各组为副本集。

    192.168.1.182:27001

    192.168.1.186:27001

    192.168.1.122:27001

    192.168.1.182:27002

    192.168.1.186:27002

    192.168.1.122:27002

    192.168.1.182:27003

    192.168.1.186:27003

    192.168.1.122:27003

    ###创建数据目录

    #三台服务器,创建路由配置目录

    mkdir /data/mongodb/20000 –p

    #三台服务器,创建配置服务器目录

    mkdir /data/mongodb/21000 –p

    #三台服务器,创建shard目录

    mkdir /data/mongodb/27001 –p

    mkdir /data/mongodb/27002 –p

    mkdir /data/mongodb/27003 –p

    安装包

    三台服务下载安装包,解压到/usr/local/mongodb目录

    https://www.mongodb.com/download-center?jmp=nav#community

    https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.2.tgz

    解压到/usr/local/mongodb/目录下

    2.2.2 配置角色搭建(configsvr)

    1、编辑文件vim /usr/local/mongodb/conf/config.conf,三台服务器配置一样。

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/21000/mongodb.log

    storage:

    dbPath: /data/mongodb/21000/

    journal:

    enabled: true

    processManagement:

    fork: true

    net:

    port: 21000

    bindIp: 127.0.0.1

    replication:

    replSetName: conf

    sharding:

    clusterRole: configsvr

    2、启动跟单例的启动方式一致,都是使用mongod

    3、配置角色副本集搭建,配置角色也是副本集,达到高可用

    config = { _id:"conf ",

    configsvr: true,

    members:[

    {_id:0,host:"192.168.1.182:21000"},

    {_id:1,host:"192.168.1.186:21000"},

    {_id:2,host:"192.168.1.122:21000"}

    ]

    }

    rs.initiate(config)

    rs.status() #查看状态

    2.2.3 路由角色搭建(mongos)

    1、 编辑配置文件vim /usr/local/mongodb/conf/mongos.conf,三台一样配置,配置多个router,任何一个都能正常的获取数据

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/20000/mongodb.log

    processManagement:

    fork: true

    net:

    port: 20000

    bindIp: 0.0.0.0

    sharding:

    configDB: config/192.168.1.182:21000,192.168.1.186:21000,192.168.1.122:21000

    ##文件最后指定,配置角色的ip+端口。

    2、 启动

    /usr/local/mongodb/bin/mongos -f /usr/local/mongodb/conf/mongos.conf

    #路由服务器的启动和其他角色不一样。

    2.2.4 数据角色搭建(shard)

    三个shard,共有三个副本集。

    ##shard1

    1、 编辑配置文件vim /usr/local/mongodb/conf/shard1.conf,三台shard1,配置一样。

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/27001/mongodb.log

    storage:

    dbPath: /data/mongodb/27001/

    journal:

    enabled: true

    processManagement:

    fork: true

    net:

    port: 27001

    bindIp: 0.0.0.0

    replication:

    replSetName: data1

    #name三台一致,副本集。不同的shard名称不同,如:data2、data3

    sharding:

    clusterRole: shardsvr

    2、 启动

    3、 配置副本集

    config = { _id:"data1",

    members:[

    {_id:0,host:"192.168.1.182:27001"},

    {_id:1,host:"192.168.1.186:27001"},

    {_id:2,host:"192.168.1.122:27001"}

    ]

    }

    #初始化

    rs.initiate(config)

    rs.status() #查看状态

    至此搭建完成。

    2.3 验证

    2.3.1 分片集群添加数据角色

    #连接路由角色

    sh.addShard("data1/192.168.1.182:27001,192.168.1.186:27001,192.168.1.122:27001");

    sh.addShard("data2/192.168.1.182:27002,192.168.1.186:27002,192.168.1.122:27002");

    sh.addShard("data3/192.168.1.182:27003,192.168.1.186:27003,192.168.1.122:27003");

    sh.status()

    2.3.2 分片策略设置

    默认添加数据没有分片存储,操作都是在路由角色里面

    针对某个数据库的某个表使用hash分片存储,分片存储就会同一个colloection分配两个数据角色

    use admin

    db.runCommand( { enablesharding :"malin"});

    db.runCommand( { shardcollection : "malin.myuser",key : {_id: "hashed"} } )

    2.3.3 插入数据进行分片

    use malin

    for(i=1; i<=500;i++){

    db.myuser.insert( {name:'mytest'+i, age:i} )

    }

    查看三个shard是否有数据。

    第3章 Mongodb gridfs介绍

    GridFS是用于存储和检索超过 BSON -文档大小限制为16 MB的文件的规范。

    GridFS不是将文件存储在单个文档中,而是将文件分成多个部分或块[1],并将每个块存储为单独的文档。默认情况下,GridFS使用默认的块大小255 kB; 也就是说,GridFS将文件分成255 kB的块,但最后一个块除外。最后一个块只有必要的大小。同样,不大于块大小的文件只有最终的块,只使用所需的空间和一些额外的元数据。

    GridFS使用两个集合来存储文件。一个集合存储文件块(chunks),另一个存储文件元数据(files)。

    GridFS不仅可用于存储超过16 MB的文件,还可用于存储您想要访问的任何文件,而无需将整个文件加载到内存中。

    3.1 使用时机

    1、 如果文件系统限制目录中的文件数,则可以使用GridFS根据需要存储任意数量的文件。

    2、 如果要从大型文件的各个部分访问信息而无需将整个文件加载到内存中,可以使用GridFS调用文件的各个部分,而无需将整个文件读入内存。

    3、 如果要保持文件和元数据在多个系统和工具中自动同步和部署,可以使用GridFS。使用地理位置分散的副本集时,MongoDB可以自动将文件及其元数据分发到多个 mongod实例和工具中。

    3.2 Gridfs集合

    chunks存储二进制块。默认是fs.chunks

    #字段

    {

    “ _ id ” : < ObjectId > ,

    “files_id” : < ObjectId > ,

    “n” : < num > ,

    “data” : < binary >

    }

    files存储文件的元数据。默认是fs.files

    #字段

    {

    "_id" : ,

    "length" : ,

    "chunkSize" : ,

    "uploadDate" : ,

    "md5" : ,

    "filename" : ,

    "contentType" : ,

    "aliases" : ,

    "metadata" : ,

    }

    3.3 拆分GridFS

    3.3.1 拆分chunks

    对chunks集合进行分片,使用files_id字段,利用哈希进行分片

    3.3.2 拆分files

    对files集合进行分片,使用_id字段,利用哈希进行分片

    3.4 实例

    1、配置分片策略

    #进入到路由服务器

    use admin

    #指定拆分的数据库test

    db.runCommand( { enablesharding :"test"});

    #指定拆分的files,test数据库中的test-file.files集合,利用_id字段

    db.runCommand( { shardcollection : "test.test-file.files",key : {_id: "hashed"} } )

    #指定拆分的chunks,test数据库中的test.test-file.chunks集合,利用files_id,字段

    db.runCommand( { shardcollection : "test.test-file.chunks",key : {files_id: "hashed"}})

    2、 上传文件到test库中的test-file集合

    命令行

    mongofiles -d test1 -h 127.0.0.1 --port 20000 --prefix test-file put 1553.png

    -d指定数据库

    -h主机

    --port端口(路由角色)

    --prefix 指定集合

    Put 上传

    第4章 Nginx GridFS介绍

    mongodb分片已经搭建完成,利用nginx的GridFS模块,实现nginx直接连接到mongodb数据库读取文件、图片。

    4.1 下载nginx

    1、安装 nginx 需要的依赖

    yum install -y zlib zlib-devel gcc-c++ pcre pcre-devel zlib zlib-devel openssl openssl-devel

    注意:编译nginx过程中,如在出现问题,自行安装依赖。

    2、下载nginx

    wget -c https://nginx.org/download/nginx-1.12.1.tar.gz

    tar -zxvf nginx-1.12.1.tar.gz -C /usr/local/nginx

    4.2 下载nginx-gridfs模块

    nginx通过该模块和mongodb的gridfs进行整合

    wget -c https://github.com/mdirolf/nginx-gridfs/archive/v0.8.tar.gz -O nginx-gridfs-0.8.tar.gz

    tar -xzvf ./nginx-gridfs-0.8.tar.gz

    4.3 下载nginx的mongodb驱动

    将这个驱动下的所有移动到nginx-gridfs模块目录下的mongo-c-driver目录,为了后期编译

    wget https://github.com/mongodb/mongo-c-driver/archive/v0.3.1.tar.gz

    tar -zxvf v0.3.1.tar.gz

    cd /root/mongo-c-driver-0.3.1

    #将驱动下的所有移动到nginx-gridfs目录下的mongo-c-driver目录下。

    mv ./* /root/nginx-gridfs-0.8/mongo-c-driver/

    [root@hadoop-namenode mongo-c-driver]# ll

    total 36

    -rw-rw-r-- 1 root root 11358 May 13 2011 APACHE-2.0.txt

    drwxrwxr-x 2 root root 40 May 13 2011 buildscripts

    drwxrwxr-x 2 root root 41 May 13 2011 docs

    -rw-rw-r-- 1 root root 10760 May 13 2011 doxygenConfig

    -rw-rw-r-- 1 root root 363 May 13 2011 HISTORY.md

    -rw-rw-r-- 1 root root 3024 May 13 2011 README.md

    -rw-rw-r-- 1 root root 4090 May 13 2011 SConstruct

    drwxrwxr-x 2 root root 185 May 13 2011 src

    drwxrwxr-x 2 root root 282 May 13 2011 test

    4.4 编译安装

    #进入到nginx包目录下

    cd nginx-1.12.0

    #开始编译,--add-module=/root/nginx-gridfs-0.8。这个目录就是nginx-gridfs模块的位置。

    ./configure --user=nginx --group=nginx --prefix=/usr/local/nginx/ --with-http_v2_module --with-http_ssl_module --with-http_sub_module --with-http_stub_status_module --with-http_gzip_static_module --with-pcre --add-module=/root/nginx-gridfs-0.8/

    make && make install

    4.5 问题处理

    1、在make && make install的时候报错:

    ngx_http_gridfs_module.c:684:16: 错误:变量‘chunksize’被设定但未被使用

    处理方法:进入nginx包目录 vi nginx-1.12.0/objs/Makefile修改一个小错误,把第3行的-Werror错误去掉。

    2、not exist /root/nginx-gridfs-0.8/mongo-c-driver/src/*.h,表示nginx的mongodb驱动没有安装。

    处理方法:安装驱动,下载nginx的mongodb驱动。

    至此nginx和nginx-gridfs模块编译成功,下面是配置文件的修改。

    4.6 nginx-gridfs配置文件

    #进入安装好的nginx配置文件conf目录下

    server{

    listen 80;

    server_name 192.168.60.235;

    #charset koi8-r;

    #access_log logs/host.access.log main;

    location /pics/ {

    gridfs test

    field=_id

    type=objectid;

    mongo 192.168.xx.2x7:27017;

    }

    }

    4.7 配置文件参数详解

    gridfs:nginx识别插件的关键字

    edusns:db名

    [root_collection]: 选择collection,如root_collection=blog, mongod就会去找blog.files与blog.chunks两个块,默认是fs

    [field]: 查询字段,保证mongdb里有这个字段名,支持_id, filename, 可省略, 默认是_id

    [type]: 解释field的数据类型,支持objectid, int, string, 可省略, 默认是int

    [user]: 用户名, 可省略

    [pass]: 密码, 可省略

    mongo: mongodb 路由地址(集群中)

    4.8 测试

    1、上传文件到mongodb,然后进行浏览器测试。

    #命令行mongodb上传文件

    mongofiles put 1234.jpg --local ~/1234.jpg --host 172.0.0.1 --port 27017 --db testdb --type jpg

    2、浏览器访问

    ip/pics/1234.jpg

    #nginx地址

    第5章 总结

    5.1 分片集群搭建

    5.1.1 Config角色

    配置文件(三台都配置)

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/21000/mongodb.log

    storage:

    dbPath: /data/mongodb/21000/

    journal:

    enabled: true

    processManagement:

    fork: true

    net:

    port: 21000

    bindIp: 127.0.0.1

    replication:

    replSetName: conf

    sharding:

    clusterRole: configsvr

    #只需修改端口即可,三台一致。

    配置副本集

    启动进入到任意一台实例进行配置

    config = { _id:"conf ",

    configsvr: true,

    members:[

    {_id:0,host:"192.168.1.182:21000"},

    {_id:1,host:"192.168.1.186:21000"},

    {_id:2,host:"192.168.1.122:21000"}

    ]

    }

    rs.initiate(config)

    rs.status() #查看状态

    #注意:_id为副本集名称

    5.1.2 mongos角色

    配置文件(三台一样配置文件)

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/20000/mongodb.log

    processManagement:

    fork: true

    net:

    port: 20000

    bindIp: 0.0.0.0

    sharding:

    configDB: config/192.168.1.182:21000,192.168.1.186:21000,192.168.1.122:21000

    #指定配置角色位置

    5.1.3 shard角色

    配置文件(九个实例,三个为一组副本集),只需修改端口和副本集名称

    systemLog:

    destination: file

    logAppend: true

    path: /data/mongodb/27001/mongodb.log

    storage:

    dbPath: /data/mongodb/27001/

    journal:

    enabled: true

    processManagement:

    fork: true

    net:

    port: 27001

    bindIp: 0.0.0.0

    replication:

    replSetName: data1

    #name三台一致,副本集。不同的shard名称不同,如:data2、data3

    sharding:

    clusterRole: shardsvr

    #配置副本集

    启动,进入到任意一台分片实例,进行副本集配置。

    config = { _id:"data1",

    members:[

    {_id:0,host:"192.168.1.182:27001"},

    {_id:1,host:"192.168.1.186:27001"},

    {_id:2,host:"192.168.1.122:27001"}

    ]

    }

    rs.initiate(config)

    rs.status() #查看状态

    #注意:_id为副本集名称

    5.1.4 将数据角色添加到分片集群中

    进入到路由角色实例

    sh.addShard("data1/192.168.1.182:27001,192.168.1.186:27001,192.168.1.122:27001");

    sh.addShard("data2/192.168.1.182:27002,192.168.1.186:27002,192.168.1.122:27002");

    sh.addShard("data3/192.168.1.182:27003,192.168.1.186:27003,192.168.1.122:27003");

    sh.status()

    #三个shard分片。

    5.1.5 拆分Gridfs上传的文件

    #进入到路由服务器

    use admin

    #指定拆分的数据库test

    db.runCommand( { enablesharding :"test"});

    #指定拆分的files,test数据库中的test-file.files集合,利用_id字段

    db.runCommand( { shardcollection : "test.test-file.files",key : {_id: "hashed"} } )

    #指定拆分的chunks,test数据库中的test.test-file.chunks集合,利用files_id,字段

    db.runCommand( { shardcollection : "test.test-file.chunks",key : {files_id: "hashed"}})

    #命令行上传测试

    mongofiles -d test1 -h 127.0.0.1 --port 20000 --prefix test-file put 1553.png

    5.2 Nginx-gridfs搭建

    5.2.1 下载nginx包及依赖

    yum install -y zlib zlib-devel gcc-c++ pcre pcre-devel zlib zlib-devel openssl openssl-devel

    wget -c https://nginx.org/download/nginx-1.12.1.tar.gz

    tar -zxvf nginx-1.12.1.tar.gz -C /usr/local/nginx

    5.2.2 下载nginx-gridfs模块

    wget -c https://github.com/mdirolf/nginx-gridfs/archive/v0.8.tar.gz -O nginx-gridfs-0.8.tar.gz

    tar -xzvf ./nginx-gridfs-0.8.tar.gz

    5.2.3 下载nginx的mongodb驱动,并移动到nginx-gridfs模块下

    wget https://github.com/mongodb/mongo-c-driver/archive/v0.3.1.tar.gz

    tar -zxvf v0.3.1.tar.gz

    cd /root/mongo-c-driver-0.3.1

    mv ./* /root/nginx-gridfs-0.8/mongo-c-driver/

    5.2.4 编译安装nginx

    ./configure --user=nginx --group=nginx --prefix=/usr/local/nginx/ --with-http_v2_module --with-http_ssl_module --with-http_sub_module --with-http_stub_status_module --with-http_gzip_static_module --with-pcre --add-module=/root/nginx-gridfs-0.8/

    5.2.5 配置文件

    server{

    listen 80;

    server_name 192.168.60.235;

    #charset koi8-r;

    #access_log logs/host.access.log main;

    location /pics/ {

    gridfs test

    field=_id

    type=objectid;

    mongo 192.168.xx.2x7:27017;

    }

    }

    5.2.6 命令行测试。上传文件

    mongofiles put 1234.jpg --local ~/1234.jpg --host 172.0.0.1 --port 27017 --db testdb --type jpg

    展开全文
  • 阿里云直接由MongoDB的服务可以购买,买完过后可以直接使用的副本集。买服务的好处就是不用自己去搭建了。 mongodb&java&netty&rpc高性能学习交流群:876280300 高性能Mongodb的ORM框架zfoo开源地址 ...

    阿里云MongoDB的使用

    • 阿里云直接由MongoDB的服务可以购买,买完过后可以直接使用的副本集。买服务的好处就是不用自己去搭建了。
    • mongodb&java&netty&rpc高性能学习交流群:876280300
    • 高性能Mongodb的ORM框架zfoo开源地址

    在这里插入图片描述

    一、副本集的搭建

    1.MongoDB环境准备

    • 三台虚拟机的静态ip分别设置为
    192.168.1.30 mongodb0
    192.168.1.31 mongodb1
    192.168.1.32 mongodb2
    
    • 设置好ip后还需要把ip与主机名对应起来
    hostname        # 查看主机名使用命令
    
    
    vim /etc/sysconfig/network,修改主机名,在最后一行加上HOSTNAME=mongodb0,不同主机的对于关系如下
    192.168.1.30 -> HOSTNAME=mongodb0
    192.168.1.31 -> HOSTNAME=mongodb1
    192.168.1.32 -> HOSTNAME=mongodb2
    
    vim /etc/hosts,修改为我们设置的主机名,不同的主机对应不同的mongodb
    127.0.0.1   localhost mongodb0 localhost4 localhost4.localdomain4
    ::1         localhost mongodb0 localhost6 localhost6.localdomain6
    192.168.1.30 mongodb0
    192.168.1.31 mongodb1
    192.168.1.32 mongodb2
    
    
    • 重启服务器后生效,使用hostname命令验证主机名,使用ping命令验证三个虚拟机之间相互可以使用主机名ping通。
    • 开启防火墙端口。

    2.创建目录和修改配置文件

    • mongodb0,mongodb1,mongodb2使用命令
    mkdir -p /data/mongodb/db   # 存放数据的目录
    mkdir -p /data/mongodb/logs # 存放日记的目录
    mkdir -p /data/mongodb/key  # 存放密钥的目录
    
    • vim /usr/local/mongodb/mongodb.config,修改配置文件如下
    dbpath=/data/mongodb/db
    
    logpath=/data/mongodb/logs/mongodb.log
    logappend=true
    
    port=22400
    fork=true
    
    #keyFile默认会开启auth=true
    #auth=true
    #keyFile=/data/mongodb/key/myKey.txt
    replSet=myReplicaSet
    
    #生产环境需要设置ip:bind_ip=127.0.0.1,本机ip
    bind_ip=0.0.0.0
    

    3.初始化副本集

    • 清空一下目录的历史数据,因为可能以前是用的单机节点,集群部署会有不可预知问题,所以先清空数据
    /data/mongodb/db
    /data/mongodb/logs
    
    • 分别启动mongodb0,mongodb1,mongodb2
    systemctl restart mongodb
    
    • 创建副本集
    mongo --port 22400      # 进入mongodb0
    config = {_id: "myReplicaSet", members: [{_id: 0, host:"mongodb0:22400"}, {_id: 1, host:"mongodb1:22400"}, {_id: 2, host:"mongodb2:22400", arbiterOnly : true}]}
    rs.initiate(config)     # 初始化副本集
    
    • 观察副本集
    rs.conf()       # 副本集配置
    rs.status()     # 副本集状态
    

    4.副本集初始化后,需要给整个副本集创建帐户、密码

    • 创建Key,mongodb0,mongodb1,mongodb2使用命令
    echo "replicaSet key" > /data/mongodb/key/myKey.txt
    chmod 600 /data/mongodb/key/myKey.txt
    
    • 在主节点上,用客户端连接,创建用户权限(主节点,可以用 rs.status() 查看),创建用户请看mongodb-setup.md

    • 关闭副本集,分别关闭mongodb0,mongodb1,mongodb2

    systemctl stop mongodb
    
    • vim /usr/local/mongodb/mongodb.config,修改配置文件如下
    dbpath=/data/mongodb/db
    
    logpath=/data/mongodb/logs/mongodb.log
    logappend=true
    
    port=22400
    fork=true
    
    #keyFile默认会开启auth=true
    auth=true
    keyFile=/data/mongodb/key/myKey.txt
    replSet=myReplicaSet
    
    #生产环境需要设置ip:bind_ip=127.0.0.1,本机ip
    bind_ip=0.0.0.0
    
    • 重新启动副本集,分别启动mongodb0,mongodb1,mongodb2
    systemctl restart mongodb
    

    5.数据同步测试

    • 首先向PRIMARY(主节点)写入一条数据
    use test
    db.say.insert({"text":"Hello World"})
    db.say.find()
    
    • 进入SECONDARY(副节点)查看数据是否同步
    默认情况下SECONDARY节点不能读写,要设定slaveOk为true才可以从SECONDARY节点读取数据。
    replSet里只能有一个Primary节点,只能在Primary写数据,不能在SECONDARY写数据。
    首先需要在SECONDARY节点设置slaveOk为true
    
    db.getMongo().setSlaveOk();
    use test;
    db.say.find();
    

    6.故障切换测试

    • 把主节点关点,看看副集点是否能接替主节点进行工作

    二、原理解析

    1.副本集实现了数据库的数据同步,故障转移,读写分离

    副本集最少应该包含三个节点,其中有一个必须是主节点。

    数据同步:从节点会从主节点同步oplog到自己的节点,oplog有自己的大小,可以通过–oplogSize来设置。主从之间的读写对程序员是透明的。
    故障转移(容灾):主从节点两秒钟就会有一个心跳,如果发现主节点挂了就从新选取主节点,选取规则是从节点中数据最新的,权重最高的节点。 如果从节点挂了就直接选取从节点,再将主节点的数据同步给从节点。
    读写分离:可以设置是优先从主节点读数据,还是优先从从节点读数据。 注:在单个节点中,数据先被写到内存,操作被保存在内存的视图中,内存视图没100ms写到硬盘的journal日志中,mongodb每60s将内存中的数据同步到硬盘。

    三、副本集的管理

    1.诊断

    • 查看主数据库的复制的状态
    db.printReplicationInfo()
    
    configured oplog size:   990MB
    log length start to end: 174676secs (48.52hrs)
    oplog first event time:  Wed May 01 2019 13:29:38 GMT+0800
    oplog last event time:   Fri May 03 2019 14:00:54 GMT+0800
    now:                     Fri May 03 2019 14:00:56 GMT+0800
    
    输出信息oplog大小990MB
    log length start to end = oplog last event time - oplog first event time
    因为oplog是固定大小,有一个循环,所以必须等oplog循环几圈,oplog才和实际相符合。
    
    如果oplog太小,写入的数据太快,oplog中的日志可能会被顶掉,从节点想要同步时候发现找不到切入的oplog,已经跟不上主节点了,就会停止同步。
    如果log length start to end和下面的从节点behind the primary非常的接近,说明oplog可能太小了 
    
    • 查看从数据库的复制的状态
    db.printSlaveReplicationInfo()
    
    source: mongodb-config1:22400
    	syncedTo: Fri May 03 2019 13:56:31 GMT+0800
    	0 secs (0 hrs) behind the primary 
    source: mongodb-config2:22400
    	syncedTo: Fri May 03 2019 13:56:31 GMT+0800
    	0 secs (0 hrs) behind the primary 
    
    

    2.副本集回滚丢失的数据

    主节点故障后重新加入副本集时会回滚恢复写操作。
    只有在主节点接受了写请求并且从节点没有复制前主节点就故障的时候才需要回滚。
    当主节点作为从节点重新加入副本集,他恢复或回滚他的写操作来与其他成员保持数据库一致性。
    
    当回滚确实发生了,MongoDB把回滚数据写入数据库的dbPath的rollback文件夹下的BSON文件中,可以用bsondump读取回滚文件的内容。
    回滚文件名如下形式:
    <database>.<collection>.<timestamp>.bson
    
    展开全文
  • linux部署mongodb副本集

    2021-03-30 13:20:31
    mongodb副本集简介 MongoDB 副本集(Replica Set)包括主节点(primary)跟副本节点(Secondaries)。主节点只能有一个,所有的写操作请求都在主节点上面处理。副本节点可以有多个,通过同步主节点的操作日志(oplog...

    mongodb副本集简介

    MongoDB 副本集(Replica Set)包括主节点(primary)跟副本节点(Secondaries)。主节点只能有一个,所有的写操作请求都在主节点上面处理。副本节点可以有多个,通过同步主节点的操作日志(oplog)来备份主节点数据。

    在主节点挂掉后,有选举权限的副本节点会自动发起选举,并从中选举出新的主节点。副本节点可以通过配置,指定其具体的属性,比如选举、隐藏、延迟同步等,最多可以有50个副本节点,但只能有7个副本节点能参与选举。虽然副本节点不能处理写操作,但可以处理读请求。

    搭建一个副本集集群最少需要三个节点:一个主节点,两个备份节点,三个节点的架构如下图所示:
    在这里插入图片描述
    如果只有一个主节点,一个副本节点,且没有资源拿来当第二个副本节点,那就可以起一个仲裁者节点(arbiter),不存数据,只用来选举用,如下图所示:
    在这里插入图片描述
    当主节点挂掉后,那么两个副本节点会进行选举,从中选举出一个新的主节点,流程如下:
    在这里插入图片描述

    mongodb副本集部署

    参考:https://docs.mongodb.com/manual/tutorial/deploy-replica-set/

    搭建一套3节点副本集(1个 Primary 节点,2个 Secondary 节点),节点规划如下:

    主机名IP地址角色
    mongodb01192.168.92.80primary
    mongodb02192.168.92.81secondary
    mongodb03192.168.92.82secondary

    3个节点分别配置主机名

    hostnamectl set-hostname mongodb01
    hostnamectl set-hostname mongodb02
    hostnamectl set-hostname mongodb03
    

    3个节点分别配置主机名解析

    cat > /etc/hosts <<EOF
    192.168.92.80 mongodb01
    192.168.92.81 mongodb02
    192.168.92.82 mongodb03
    EOF
    

    关闭防火墙和selinux

    systemctl disable --now firewalld
    sed -i 's/^SELINUX=enforcing$/SELINUX=disabled/' /etc/selinux/config && setenforce 0
    

    配置时间同步

    yum install -y chrony
    systemctl enable --now  chronyd
    

    配置国内yum源

    cat > /etc/yum.repos.d/mongodb.repo <<'EOF'
    [mongodb-org]
    name=MongoDB Repository
    baseurl=https://mirrors.tuna.tsinghua.edu.cn/mongodb/yum/el$releasever/
    gpgcheck=0
    enabled=1
    EOF
    

    3个节点安装mongodb

    yum install -y mongodb-org
    

    修改mongodb配置文件,增加以下配置

    # cat /etc/mongod.conf
    ...
    replication:
       replSetName: "rs0"
    net:
       bindIp: 0.0.0.0
    ...
    

    启动mongodb服务

    systemctl enable --now mongod
    

    使用 mongo 进入第一个实例mongodb01:

    [root@mongodb01 ~]# mongo
    

    使用 rs.initiate() 进行初始化

    rs.initiate( {
       _id : "rs0",
       members: [
          { _id: 0, host: "mongodb01:27017" },
          { _id: 1, host: "mongodb02:27017" },
          { _id: 2, host: "mongodb03:27017" }
       ]
    })
    

    以上就已经完成了一个副本集的搭建,在 mongo shell 中执行 rs.conf() 可以看到每个节点中 host、arbiterOnly、hidden、priority、 votes、slaveDelay等属性。

    rs0:PRIMARY> rs.conf()
    {
            "_id" : "rs0",
            "version" : 1,
            "term" : 1,
            "protocolVersion" : NumberLong(1),
            "writeConcernMajorityJournalDefault" : true,
            "members" : [
                    {
                            "_id" : 0,
                            "host" : "mongodb01:27017",
                            "arbiterOnly" : false,
                            "buildIndexes" : true,
                            "hidden" : false,
                            "priority" : 1,
                            "tags" : {
    
                            },
                            "slaveDelay" : NumberLong(0),
                            "votes" : 1
                    },
                    {
                            "_id" : 1,
                            "host" : "mongodb02:27017",
                            "arbiterOnly" : false,
                            "buildIndexes" : true,
                            "hidden" : false,
                            "priority" : 1,
                            "tags" : {
    
                            },
                            "slaveDelay" : NumberLong(0),
                            "votes" : 1
                    },
                    {
                            "_id" : 2,
                            "host" : "mongodb03:27017",
                            "arbiterOnly" : false,
                            "buildIndexes" : true,
                            "hidden" : false,
                            "priority" : 1,
                            "tags" : {
    
                            },
                            "slaveDelay" : NumberLong(0),
                            "votes" : 1
                    }
            ],
            "settings" : {
                    "chainingAllowed" : true,
                    "heartbeatIntervalMillis" : 2000,
                    "heartbeatTimeoutSecs" : 10,
                    "electionTimeoutMillis" : 10000,
                    "catchUpTimeoutMillis" : -1,
                    "catchUpTakeoverDelayMillis" : 30000,
                    "getLastErrorModes" : {
    
                    },
                    "getLastErrorDefaults" : {
                            "w" : 1,
                            "wtimeout" : 0
                    },
                    "replicaSetId" : ObjectId("6062b2aa526a897f92fa34bc")
            }
    }
    

    或者使用以下命令确认primary节点:

    db.isMaster()
    

    确保副本集具有主副本集,使用rs.status()来识别副本集的主。

    rs0:PRIMARY> rs.status()
    ......
            "members" : [
                    {
                            "_id" : 0,
                            "name" : "mongodb01:27017",
                            "health" : 1,
                            "state" : 1,
                            "stateStr" : "PRIMARY",
                            "uptime" : 938,
                            "optime" : {
                                    "ts" : Timestamp(1617081783, 1),
                                    "t" : NumberLong(1)
                            },
                            "optimeDate" : ISODate("2021-03-30T05:23:03Z"),
                            "syncSourceHost" : "",
                            "syncSourceId" : -1,
                            "infoMessage" : "",
                            "electionTime" : Timestamp(1617081013, 1),
                            "electionDate" : ISODate("2021-03-30T05:10:13Z"),
                            "configVersion" : 1,
                            "configTerm" : 1,
                            "self" : true,
                            "lastHeartbeatMessage" : ""
                    },
                    {
                            "_id" : 1,
                            "name" : "mongodb02:27017",
                            "health" : 1,
                            "state" : 2,
                            "stateStr" : "SECONDARY",
                            "uptime" : 781,
                            "optime" : {
                                    "ts" : Timestamp(1617081783, 1),
                                    "t" : NumberLong(1)
                            },
                            "optimeDurable" : {
                                    "ts" : Timestamp(1617081783, 1),
                                    "t" : NumberLong(1)
                            },
                            "optimeDate" : ISODate("2021-03-30T05:23:03Z"),
                            "optimeDurableDate" : ISODate("2021-03-30T05:23:03Z"),
                            "lastHeartbeat" : ISODate("2021-03-30T05:23:04.172Z"),
                            "lastHeartbeatRecv" : ISODate("2021-03-30T05:23:03.059Z"),
                            "pingMs" : NumberLong(2),
                            "lastHeartbeatMessage" : "",
                            "syncSourceHost" : "mongodb01:27017",
                            "syncSourceId" : 0,
                            "infoMessage" : "",
                            "configVersion" : 1,
                            "configTerm" : 1
                    },
                    {
                            "_id" : 2,
                            "name" : "mongodb03:27017",
                            "health" : 1,
                            "state" : 2,
                            "stateStr" : "SECONDARY",
                            "uptime" : 781,
                            "optime" : {
                                    "ts" : Timestamp(1617081783, 1),
                                    "t" : NumberLong(1)
                            },
                            "optimeDurable" : {
                                    "ts" : Timestamp(1617081783, 1),
                                    "t" : NumberLong(1)
                            },
                            "optimeDate" : ISODate("2021-03-30T05:23:03Z"),
                            "optimeDurableDate" : ISODate("2021-03-30T05:23:03Z"),
                            "lastHeartbeat" : ISODate("2021-03-30T05:23:04.167Z"),
                            "lastHeartbeatRecv" : ISODate("2021-03-30T05:23:03.215Z"),
                            "pingMs" : NumberLong(2),
                            "lastHeartbeatMessage" : "",
                            "syncSourceHost" : "mongodb01:27017",
                            "syncSourceId" : 0,
                            "infoMessage" : "",
                            "configVersion" : 1,
                            "configTerm" : 1
                    }
            ],
    ......
    

    mongodb副本集故障转移

    可以直接停掉主节点mongodb01来测试下主节点挂掉后,副本节点重新选举出新的主节点,即自动故障转移(Automatic Failover)。

    [root@mongodb01 ~]# systemctl stop mongod
    

    杀掉主节点 mongodb01后,可以看到 mongodb02 的输出日志里面选举部分,已经发起选举,并成功参选成为主节点:

    [root@mongodb02 ~]# cat /var/log/mongodb/mongod.log |grep PRIMARY
    {"t":{"$date":"2021-03-30T13:10:13.173+08:00"},"s":"I",  "c":"REPL",     "id":21215,   "ctx":"ReplCoord-0","msg":"Member is in new state","attr":{"hostAndPort":"mongodb01:27017","newState":"PRIMARY"}}
    {"t":{"$date":"2021-03-30T13:27:51.523+08:00"},"s":"I",  "c":"REPL",     "id":21358,   "ctx":"ReplCoord-11","msg":"Replica set state transition","attr":{"newState":"PRIMARY","oldState":"SECONDARY"}}
    

    然后执行 rs.status() 查看当前副本集情况

    rs.status().members.forEach( 
        function(z){ 
                printjson(z.name);
                printjson(z.stateStr);
        } 
    )
    

    可以看到mongodb02变为主节点,mongodb01显示已挂掉。

    "mongodb01:27017"
    "(not reachable/healthy)"
    "mongodb02:27017"
    "PRIMARY"
    "mongodb03:27017"
    "SECONDARY"
    

    再次启动mongodb01:

    [root@mongodb01 ~]# systemctl start mongod
    

    可以看到已检测到 mongodb01,并且已变为副本节点,通过rs.status 查看结果也是如此。

    "mongodb01:27017"
    "SECONDARY"
    "mongodb02:27017"
    "PRIMARY"
    "mongodb03:27017"
    "SECONDARY"
    

    从副本集删除成员

    有2种方法从副本集中删除成员,使用rs.remove()或rs.reconfig()。

    使用rs.remove()删除成员

    1、关闭您要删除的mongod成员的实例,以删除mongodb03成员为例:

    [root@mongodb03 ~]# mongo
    
    rs0:SECONDARY> use admin;
    
    rs0:SECONDARY> db.shutdownServer()
    

    2、连接到副本集的当前primary,可以连接到任意副本集成员使用db.isMaster()确定当前的主数据库。使用rs.remove()以下两种形式之一删除成员:

    [root@mongodb02 ~]# mongo
    
    rs0:PRIMARY> rs.remove("mongodb03:27017")
    
    rs0:PRIMARY> rs.remove("mongodb03")
    

    3、使用以下命令查看集群信息

    rs.status().members.forEach( 
        function(z){ 
                printjson(z.name);
                printjson(z.stateStr);
        } 
    )
    

    确认成功移除mongodb03节点

    "mongodb01:27017"
    "SECONDARY"
    "mongodb02:27017"
    "PRIMARY"
    

    使用rs.reconfig()删除成员

    使用rs.conf() 确定要删除的节点位置

    [root@mongodb02 ~]# mongo
    
    rs0:PRIMARY> rs.conf()
    

    删除成员

    rs0:PRIMARY> cfg = rs.conf()
    
    rs0:PRIMARY> cfg.members.splice(2,1)
    
    rs0:PRIMARY> rs.reconfig(cfg)
    

    将成员添加到副本集

    1、启动新mongod实例,启动时需要在命令行指定副本集名称,这里通过在配置文件中配置:

    # cat /etc/mongod.conf
    ...
    replication:
       replSetName: "rs0"
    ...
    

    清空数据并重新启动

    [root@mongodb03 ~]# rm -rf /var/lib/mongo/*
    [root@mongodb03 ~]# systemctl restart mongod
    

    2、添加成员到副本集

    连接到副本集的主数据库,您只能在连接到主要成员时添加成员:

    [root@mongodb02 ~]# mongo
    
    rs0:PRIMARY> rs.add( { host: "mongodb03:27017", priority: 0, votes: 0 } )
    

    3、重新配置优先级

    一旦新加入的成员已经过渡到 SECONDARY状态,如果需要的话,使用rs.reconfig()更新新添加的成员priority和votes。

    使用rs.conf()查看新成员id,则将其priority和votes更新为 1,请使用以下操作序列:

    var cfg = rs.conf();
    cfg.members[2].priority = 1
    cfg.members[2].votes = 1
    rs.reconfig(cfg)
    
    展开全文
  • 一,简介 Mongodb复制集由一组Mongod实例(进程)组成,包含一个Primary节点和多个Secondary节点。 Mongodb Driver(客户端)的所有数据都写入Primary,Secondary从Primary...二,副本集角色 主节点(Primary) 接收
  • MongoDB之副本集与Oplog

    2021-07-20 21:11:26
    1、Oplog简介。Oplog即操作日志(operation log)是用于保存Mongodb数据库所有数据操作记录(实际上只记录改动数据库数据的操作记录,即增/删/改)的固定大小集合(Capped Collections)。...2、副本集数据.
  • Mongodb副本集具备自动故障转移的高可用特性,通常所说副本集是1主2从的架构,当主节点出现故障时,剩下2个节点会自动进行选出新主节点,提供对外服务.也可以进行主动维护,将主节点降级为从节点,将从节点提升为主节点....
  • 1. replica set每个副本集需要设置副本集名称。在启动MongoDB时指定。2. 搭建步骤2.1 启动首先启动MongoDB启动时设置为副本集模式,并设置名称。两种方式,通过配置文件,或命令行模式。配置文件:01.# mongodb.conf...
  • 如果近期你有登录MongoDB Atlas,入门级是免费的, 你可能会注意到在3.6 版本下连接字符串的一个新的语法。...你会想起客户端使用MongoDB副本集进行连接的时候, 必须指定至少一个副本集成员(也可能指定副...
  • MongoDB副本集(Java)

    2021-04-18 07:01:34
    import java.util.Arrays;...277) at com.djhu.mongodb.test.ReplTest.testInsert(ReplTest.java:28) at com.djhu.mongodb.test.ReplTest.main(ReplTest.java:33) Share the post "MongoDB副本集(Java)
  • 副本集节点介绍 1)数据节点-------主节点 主节点负责数据的读写操作,并把写的操作记录到OpLog中(mongo隐藏的库local的oplog集合) 2)数据节点-------从节点 复制主节点的数据,备份容灾用,主节点挂掉,会...
  • MongoDB副本集

    2021-04-22 16:23:28
    MongoDB的副本集(Replica Set)是一组维护相同数据集的mongod服务,副本集可提供冗余和高可用性,是所有生产部署的基础。 也就是说,副本集类似于有自动故障恢复功能的主从集群,通俗的讲就是用多台集群进行同一...
  • MongoDB副本集配置方法

    2021-05-14 10:21:05
    ​ 本文是简述MongoDB在Ubuntu18.04上配置副本集的方法,为学习环境版本,旨在了解如何安装配置MongoDB副本集的方法。 ​ 本次安装是直接在一台机器上启动3个Mongo服务来实现集群的效果。 环境准备 ​ 系统:Ubuntu...
  • MongoDb副本集详解及搭建

    千次阅读 2021-02-23 22:35:04
    mongodb副本集Mongodb副本集一. 副本集成员(1) 主节点(Primary)(2) 次节点(Secondary)(3) 仲裁节点(Arbiter)二. 副本Oplog(1) Oplog简介(2) Oplog大小(3) Oplog日志解析 Mongodb副本集 一. 副本集...
  • mongodb 副本集搭建

    2021-07-15 12:14:55
    mongodb是nosql的数据库,与mysql的关系型数据库在底层构造上面有差异。mogodb的的一个collection对于mysql的一个数据表。mongodb的数据表的格式是:_id: uuid,_id就是这条数据的...一、搭建mongodb 副本集(Replica .
  • Windows 系统 MongoDB副本集的建立 (由于设备限制,选择在一台widonws系统下的一台电脑中建立集群) 1.主节点的创建 文件名:myrs_27018 内含文件:conf——存储该节点配置文件(建立文本文件,然后改后缀名) log...
  • 针对mongodb的内部机制提出以下几个引导性的问题:副本集故障转移,主节点是如何选举的?能否手动干涉下架某一台主节点。官方说副本集数量最好是奇数,为什么?mongodb副本集是如何同步的?如果同步不及时会出现什么...
  • 问题描述 线上mongodb启动正常 ...解决方法:当副本集所有节点都正常,强制修改副本集的host 修改master.conf及其他配置端口 启动mongodb副本集 ./mongod -f master.conf 进入mongo,修改副本集host mongo --p.
  • MongoDB 搭建副本集

    2021-05-18 06:50:33
    副本集(Replica Set)是一组MongoDB实例组成的集群,由一个主(Primary)服务器和多个备份(Secondary)服务器构成。通过Replication,将数据的更新由Primary推送到其他实例上,在一定的延迟之后,每个MongoDB实例维护...
  • MongoDB副本集搭建及在springboot中使用 一、mongoDB副本集的搭建 原则就是一台master(主),一台salve(从),一台arbiter(仲裁) 1、下载mongoDB ... 2、上传到准备好的三台服务器135、136、137,并解压 ...
  • 这里写目录标题简介副本集的三个角色读写分离,负载均衡与高可用MongoDB 复制主从复制和副本集区别副本集架构副本集的创建创建主节点启动主节点服务创建副本节点创建仲裁节点初始化配置副本集和主节点使用客户端命令...
  • Mongodb修改副本集

    2021-04-20 19:55:38
    1、逐个停止所有副本集的mo'n'go'd'b服务 2、使用非副本集方式启动服务,即删除--replSet参数 mongod --dbpath /var/lib/mongo --logpath /var/log/mongodb/mongod.log --bind_ip 0.0.0.0--fork 3、本地模式操作 ...
  • MongoDB 副本集成员

    2021-09-18 11:20:48
    MongoDB 的副本集是一组提供冗余和高可用性的 mongod 进程。一个副本集的成员有: 主节点 主节点接受所有的写操作 从节点 从节点通过复制主节点的操作来维护一个相同的数据集。从节点为特殊用途的配置文件提供了...
  • Docker部署MongoDB副本集

    2021-08-01 18:50:20
    安装mongo副本集 配置及端口号配置信息,启动三个以上mongo服务,节点指向一个"rs" docker run -itd --name m0 -p 27000:27017 mongo --replSet "rs" docker run -itd --name m1 -p 27001:27017 mongo --...
  • Replica Set 副本集模式 Replica Set 模式角色 Replica Set 是 MongoDB 的实例集合,包含三类节点角色: Primary (主节点) 只有 Primary 是可读可写的,Primary接受的所有的写请求,然后把数据同步到所有的 ...
  • mongo修改副本集名称

    2021-07-21 16:25:01
    副本集名称以业务命名,为了和业务保持一致,修改副本集名。 最后新的副本集自己添加节点即可。 修改副本集名称过程: 原来replicset name是dba var newId = 'dba_new' var doc = db.getSiblingDB("...
  • 在Docker中搭建mongodb副本集 拉取 Mongodb 镜像 docker pull mongo 创建要挂载的文件夹 mkdir -p mongodb-cluster/data/master mkdir -p mongodb-cluster/data/secondary mkdir -p mongodb-cluster/data/arbiter ...
  • 副本集模式:相当于是自带故障转移功能的主从复制 分片集群:(将数据子集分散在集群中,每个分片维护着一个数据集合的子集。与副本集相比,使用集群架构可以使应用程序具有更强大的数据处理能力。) 分片服务器...
  • 介绍了Mongodb的安装使用,在 MongoDB 中,有两种数据冗余方式,一种 是 Master-Slave 模式(主从复制),一种是 Replica Sets 模式(副本集)。一、先说说mongodb主从复制配置主从复制是MongoDB最常用的复制方式,也是一个...
  • 主从同步操作===================================...所有只能使用副本集,以下是副本集的一些配置信息,特此记录。 mongo 安装并启动后: 1.进入mongodb cli管理 mongo> mongo 2.查看库 mongo> show dbs;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,903
精华内容 45,561
关键字:

副本集