生产MongoDB 分片与集群方案

MongoDB分⽚集群搭建及扩容### 实验：分⽚集群搭建及扩容#### 实验⽬标及流程* ⽬标：学习如何搭建⼀个两分⽚的分⽚集群* 环境：3台Linux虚拟机器，4Core 8GB* 步骤：* 配置域名解析* 准备分⽚⽬录* 创建第⼀个分⽚复制集并初始化* 初始化分⽚集群，加⼊第⼀个分⽚* 创建分⽚表* 加⼊第⼆个分⽚#### 实验架构```demo1 shard1(Primary|27017) shard2(Primary|27011) Config1(27019) mongos(27017)``````demo2 Secondary|27010 Secondary|27011 Config2(27019)``````demo3 Secondary|27010 Secondary|27011 Config3(27019)```| | member1 | member2 | member3 | member4 | member5 | member6 ||-------|---------|---------|---------|---------|---------|---------|| shard1 | ● | | ● | | ● | || shard2 | | ● | | ● | | ● || config | ● | | ● | | ● | || mongos | | ● | | ● | | ● |demo1 demo2 demo3 1. 配置域名解析在3台虚拟器上分别执⾏以下3条命令，注意替换实际IP地址```echo "192.168.1.1 demo1 " >> /etc/hostsecho "192.168.1.2 demo2 " >> /etc/hostsecho "192.168.1.3 demo3 " >> /etc/hosts```2. 准备分⽚⽬录在各服务器上创建数据⽬录，我们⽤`/data`,请按⾃⼰需要修改为其他⽬录：- 在member1/member3/member5上执⾏以下命令：mkdir -p /data/shard1/mkdir -p /data/config/_ 在member2/member4/member6上执⾏以下命令：mkdir -p /data/shard2/mkdir -p /data/mongos/3. 创建第⼀个分⽚⽤的复制集在member1/member3/member5上执⾏以下命令```mongod --bind_id 0.0.0.0 --replSet shard1 --dbpath /data/shard1 --logpath/data/shard1/mongod.lgo --port 27010 --fork --shardsvr --wiredTigerCacheSizeGB 1```4. 初始化第⼀个分⽚复制集```mongo --host :27010rs.initiate({_id : "shard1","members": [{"_id": 0,"host": ":27010"},{"_id": 1,"host": ":27010"},{"_id": 2,"host": ":27010"},]})```5. 创建config server复制集在member1/member3/member5上执⾏以下命令```mongod --bind_id 0.0.0.0 --replSet shard1 --dbpath /data/shard1 --logpath/data/shard1/mongod.lgo --port 27010 --fork --shardsvr --wiredTigerCacheSizeGB 1```6. 初始化config server复制集```mongo --host :27010rs.initiate({_id : "shard1","members": [{"_id": 0,"host": ":27010"},{"_id": 1,"host": ":27010"},{"_id": 2,"host": ":27010"},]})```7. 在第⼀台机器上搭建mongos```# mongos --bind_ip 0.0.0.0 --logpath /data/mongos/mongos.log --port 27017 --fork-- configdb config/:27019,:27019,:27019# 连接到mongos,添加分⽚# mongo --host :27017mongos>sh.addShard("shard1/:27010,:27010,:27010"); ```8. 创建分⽚表```# 连接到mongos,创建分⽚集合# mongo --host :27017mongos > sh.status();mongos > sh.enableSharding("foo");mongos > sh.shardCollection("foo.bar", {_id:'hashed'});mongos > sh.status();插⼊测试数据use foofor (var i = 0; i < 10000; i++) {db.bar.insert({i:i});}```9. 创建第2个分⽚复制集在 member2/member4/member6上执⾏以下命令```mongod --bind_id 0.0.0.0 --replSet shard2 --dbpath /data/shard2--logpath /data/shard2/mongod.log --port 27011 --fork --shardsvr --wiredTigerCacheSizeGB 1```10. 初始化第⼆个分⽚的复制集```# mongo --host :27011rs.initiate({_id : "shard2","members": [{"_id": 0,"host": ":27011"},{"_id": 1,"host": ":27011"},{"_id": 2,"host": ":27011"},]})```11. 加⼊第2个分⽚```# 连接到mongos,添加分⽚# mongo --host :27017mongos>sh.addShard("shard2/:27011,:27011,:27011"); mongos>sh.status()```。

mongodb分片集群（shardingwithreplicaset）配置一共有4台机器，各自挂接一个存储，希望实现：1.尽量节约存储2.高可用性3.存储大量数据配置方案：1.每一台机器做一个分片的主数据库2.每一台机器做一个分片的后备数据库3.每一台机器做一个分片的仲裁服务4.两个两个一组交叉作对方的后备5.有三台机器开配置服务6.有一台机器开路由服务（生产环境可以在每一台Windows App服务器上开路由服务，App服务器集群做负载均衡）这样的话，任何一台服务器完全离线（或者交叉的两台服务器离线），都能保证整个系统正常运行。

不过在服务器和服务器起来之后需要：1.在升级成为主数据库的那个后备数据库上运行rs.StepDown(100)来让它让出主数据库的位置，因为每一个分片的活动数据库都应该由独立服务器担当，以获得最好的性能2.配置服务和后备数据库起来之后不需要做任何调整192.168.129.142mkdir -p /usr/data/shard1mkdir -p /usr/data/shard2mkdir -p /usr/data/shard3mkdir -p /usr/data/config1/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10001 --dbpath /usr/data/shard1/ --logpath /usr/data/shard1/log.log --replSet shard1 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10002 --dbpath /usr/data/shard2/ --logpath /usr/data/shard2/log.log --replSet shard2 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10003 --dbpath /usr/data/shard3/ --logpath /usr/data/shard3/log.log --replSet shard3 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --configsvr --port 20001 --dbpath /usr/data/config1/ --logpath /usr/data/config1/log.log --restps aux | grep mongodb | grep -v grep/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongo --port 10001config = {_id: 'shard1', members: [{_id: 0, host: '192.168.129.142:10001'},{_id: 1, host: '192.168.129.172:10001'},{_id: 2, host: '192.168.129.173:10001', arbiterOnly: true}]}rs.initiate(config)rs.status()192.168.129.172mkdir -p /usr/data/shard2mkdir -p /usr/data/shard1mkdir -p /usr/data/shard4mkdir -p /usr/data/config2/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10002 --dbpath /usr/data/shard2/ --logpath /usr/data/shard2/log.log --replSet shard2 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10001 --dbpath /usr/data/shard1/ --logpath/usr/data/shard1/log.log --replSet shard1 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10004 --dbpath /usr/data/shard4/ --logpath /usr/data/shard4/log.log --replSet shard4 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --configsvr --port 20002 --dbpath /usr/data/config2/ --logpath /usr/data/config2/log.log --restps aux | grep mongodb | grep -v grep/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongo --port 10002config = {_id: 'shard2', members: [{_id: 0, host: '192.168.129.172:10002'},{_id: 1, host: '192.168.129.142:10002'},{_id: 2, host: '192.168.129.175:10002', arbiterOnly: true}]}rs.initiate(config)rs.status()192.168.129.173mkdir -p /usr/data/shard3mkdir -p /usr/data/shard4mkdir -p /usr/data/shard1mkdir -p /usr/data/config3/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10003 --dbpath /usr/data/shard3/ --logpath /usr/data/shard3/log.log --replSet shard3 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10004 --dbpath /usr/data/shard4/ --logpath /usr/data/shard4/log.log --replSet shard4 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork--shardsvr --port 10001 --dbpath /usr/data/shard1/ --logpath /usr/data/shard1/log.log --replSet shard1 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --configsvr --port 20003 --dbpath /usr/data/config3/ --logpath /usr/data/config3/log.log --restps aux | grep mongodb | grep -v grep/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongo --port 10003config = {_id: 'shard3', members: [{_id: 0, host: '192.168.129.173:10003'},{_id: 1, host: '192.168.129.175:10003'},{_id: 2, host: '192.168.129.142:10003', arbiterOnly: true}]}rs.initiate(config)rs.status()192.168.129.175mkdir -p /usr/data/shard4mkdir -p /usr/data/shard3mkdir -p /usr/data/shard2mkdir -p /usr/data/master/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10004 --dbpath /usr/data/shard4/ --logpath /usr/data/shard4/log.log --replSet shard4 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10003 --dbpath /usr/data/shard3/ --logpath /usr/data/shard3/log.log --replSet shard3 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongod --fork --shardsvr --port 10002 --dbpath /usr/data/shard2/ --logpath /usr/data/shard2/log.log --replSet shard2 --rest/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongos --fork --port 40000 --logpath /usr/data/master/log.log --chunkSize 1 "192.168.129.142:20001,192.168.129.172:20002,192.168.129 .173:20003"ps aux | grep mongodb | grep -v grep/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongo --port 10004config = {_id: 'shard4', members: [{_id: 0, host: '192.168.129.175:10004'},{_id: 1, host: '192.168.129.173:10004'},{_id: 2, host: '192.168.129.172:10004', arbiterOnly: true}]}rs.initiate(config)rs.status()/usr/local/mongodb-linux-x86_64-1.6.4/bin/mongo --port 40000use admindb.runCommand({ addshard:'shard1/192.168.129.142:10001 ,192.168.129.172:10001' })db.runCommand({ addshard:'shard2/192.168.129.172:10002 ,192.168.129.142:10002' })db.runCommand({ addshard:'shard3/192.168.129.173:10003 ,192.168.129.175:10003' })db.runCommand({ addshard:'shard4/192.168.129.175:10004 ,192.168.129.173:10004' })db.runCommand({ listshards:1 })db.runCommand({ enablesharding:'test' })db.runCommand({ shardcollection:'test.data', key:{_id:1} }) printShardingStatus()插入大量数据后的结果：db.data.stats(){"sharded" : true,"ns" : "test.data","count" : 1992002,"size" : 2103555152, "avgObjSize" : 1056.0005220878293, "storageSize" : 2464232960, "nindexes" : 1, "nchunks" : 23,"shards" : {"shard1" : {"ns" : "test.data","count" : 1271788,"size" : 1343008448, "avgObjSize" : 1056.0002516142627, "storageSize" : 1568785152, "numExtents" : 25, "nindexes" : 1, "lastExtentSize" : 267987712, "paddingFactor" : 1, "flags" : 1, "totalIndexSize" : 52658176, "indexSizes" : {"_id_" : 52658176},"ok" : 1},"shard2" : {"ns" : "test.data", "count" : 98494,"size" : 104009808, "avgObjSize" : 1056.001462017991, "storageSize" : 111137536, "numExtents" : 12, "nindexes" : 1, "lastExtentSize" : 25047552, "paddingFactor" : 1, "flags" : 1, "totalIndexSize" : 4087808, "indexSizes" : {"_id_" : 4087808},"ok" : 1},"shard3" : {"ns" : "test.data", "count" : 487410,"size" : 514705248, "avgObjSize" : 1056.000590878316, "storageSize" : 607047424, "numExtents" : 20, "nindexes" : 1, "lastExtentSize" : 107698688, "paddingFactor" : 1, "flags" : 1, "totalIndexSize" : 20250624, "indexSizes" : {"_id_" : 20250624},"ok" : 1},"shard4" : {"ns" : "test.data","count" : 134310,"size" : 141831648, "avgObjSize" : 1056.0021442930533, "storageSize" : 177262848, "numExtents" : 14, "nindexes" : 1, "lastExtentSize" : 36068352, "paddingFactor" : 1,"flags" : 1, "totalIndexSize" : 5570560, "indexSizes" : {"_id_" : 5570560},"ok" : 1}},"ok" : 1}printShardingStatus()--- Sharding Status ---sharding version: { "_id" : 1, "version" : 3 } shards:{"_id" : "shard1","host" : "shard1/192.168.129.142:10001,192.168.129.172:10001"}{"_id" : "shard2","host" : "shard2/192.168.129.172:10002,192.168.129.142:10002"}{"_id" : "shard3","host" : "shard3/192.168.129.173:10003,192.168.129.175:10003"}{"_id" : "shard4","host" : "shard4/192.168.129.175:10004,192.168.129.173:10004"}databases:{ "_id" : "admin", "partitioned" : false, "primary" : "config" }{ "_id" : "test", "partitioned" : true, "primary" : "shard1" }test.data chunks:{ "_id" : { $minKey : 1 } } -->> { "_id" : ObjectId("4d01c5bc926adb17b8000001") } on : shard2 { "t" : 8000, "i" : 0 }{ "_id" : ObjectId("4d01c5bc926adb17b8000001") } -->> { "_id" : ObjectId("4d01c620926adb17b800d1dd") } on : shard2 { "t" : 10000, "i" : 0 }{ "_id" : ObjectId("4d01c620926adb17b800d1dd") } -->> { "_id" : ObjectId("4d01c669926adb17b80180bf") } on : shard4{ "t" : 9000, "i" : 0 }{ "_id" : ObjectId("4d01c669926adb17b80180bf") } -->> { "_id" : ObjectId("4d01c6b6926adb17b8022fa1") } on : shard2 { "t" : 12000, "i" : 0 }{ "_id" : ObjectId("4d01c6b6926adb17b8022fa1") } -->> { "_id" : ObjectId("4d01c6fd926adb17b802de83") } on : shard1 { "t" : 5000, "i" : 1 }{ "_id" : ObjectId("4d01c6fd926adb17b802de83") } -->> { "_id" : ObjectId("4d01c74c926adb17b8038d65") } on : shard4 { "t" : 11000, "i" : 0 }{ "_id" : ObjectId("4d01c74c926adb17b8038d65") } -->> { "_id" : ObjectId("4d01c795926adb17b8043c47") } on : shard4 { "t" : 13000, "i" : 0 }{ "_id" : ObjectId("4d01c795926adb17b8043c47") } -->> { "_id" : ObjectId("4d01c7e6926adb17b804eb29") } on : shard1 { "t" : 6000, "i" : 2 }{ "_id" : ObjectId("4d01c7e6926adb17b804eb29") } -->> { "_id" : ObjectId("4d01c82f926adb17b8059a0b") } on : shard1 { "t" : 6000, "i" : 4 }{ "_id" : ObjectId("4d01c82f926adb17b8059a0b") } -->> { "_id" : ObjectId("4d01c8d4926adb17b806f7cf") } on : shard1 { "t" : 12000, "i" : 1 }{ "_id" : ObjectId("4d01c8d4926adb17b806f7cf") } -->> { "_id" : ObjectId("4d01c963926adb17b8085593") } on : shard3 { "t" : 7000, "i" : 2 }{ "_id" : ObjectId("4d01c963926adb17b8085593") } -->> { "_id" : ObjectId("4d01ca1c926adb17b809b357") } on : shard3 { "t" : 7000, "i" : 4 }{ "_id" : ObjectId("4d01ca1c926adb17b809b357") } -->> { "_id" : ObjectId("4d01caf7926adb17b80b306a") } on : shard3{ "t" : 7000, "i" : 6 }{ "_id" : ObjectId("4d01caf7926adb17b80b306a") } -->> { "_id" : ObjectId("4d01cbc2926adb17b80d09fd") } on : shard3 { "t" : 13000, "i" : 2 }{ "_id" : ObjectId("4d01cbc2926adb17b80d09fd") } -->> { "_id" : ObjectId("4d01cc54926adb17b80e67c1") } on : shard3 { "t" : 14000, "i" : 1 }{ "_id" : ObjectId("4d01cc54926adb17b80e67c1") } -->> { "_id" : ObjectId("4d01cec7926adb125c00d1dc") } on : shard1 { "t" : 14000, "i" : 2 }{ "_id" : ObjectId("4d01cec7926adb125c00d1dc") } -->> { "_id" : ObjectId("4d01ced2926adb125c022fa0") } on : shard1 { "t" : 14000, "i" : 4 }{ "_id" : ObjectId("4d01ced2926adb125c022fa0") } -->> { "_id" : ObjectId("4d01cedf926adb125c038d64") } on : shard1 { "t" : 14000, "i" : 6 }{ "_id" : ObjectId("4d01cedf926adb125c038d64") } -->> { "_id" : ObjectId("4d01ceeb926adb125c04eb28") } on : shard1 { "t" : 14000, "i" : 8 }{ "_id" : ObjectId("4d01ceeb926adb125c04eb28") } -->> { "_id" : ObjectId("4d01cf1a926adb125c07a6ab") } on : shard1 { "t" : 14000, "i" : 10 }{ "_id" : ObjectId("4d01cf1a926adb125c07a6ab") } -->> { "_id" : ObjectId("4d01cf3c926adb125c0a622e") } on : shard1 { "t" : 14000, "i" : 12 }{ "_id" : ObjectId("4d01cf3c926adb125c0a622e") } -->> { "_id" : ObjectId("4d01cf52926adb125c0d1db1") } on : shard1 { "t" : 14000, "i" : 14 }{ "_id" : ObjectId("4d01cf52926adb125c0d1db1") } -->> { "_id" : ObjectId("4d01d58c926adb16480096f4") } on : shard1{ "t" : 14000, "i" : 16 }{ "_id" : ObjectId("4d01d58c926adb16480096f4") } -->> { "_id" : { $maxKey : 1 } } on : shard1 { "t" : 14000, "i" : 17 }另，这套配置插入1万条1KB数据的时间大约在1.4秒，如果使用最简单单进程配置的话速度稍快，在1.2秒，性能下降不是很厉害，可以接受。

实现MongoDB的复制集与分⽚介绍Mongodb复制集（replica set）由⼀组Mongod实例（进程）组成，包含⼀个Primary节点和多个Secondary节点，Mongodb Driver（客户端）的所有数据都写⼊Primary，Secondary通过oplog来同步Primary的数据，保证主从节点数据的⼀致性；复制集在完成主从复制的基础上，通过⼼跳机制，⼀旦Primary节点出现宕机，则触发选举⼀个新的主节点，剩下的secondary节点指向新的Primary，时间应该在10-30s 内完成感知Primary节点故障，实现⾼可⽤数据库集群分⽚（sharding）是指将数据库拆分，将其分散在不同的机器上的过程。

分⽚集群（sharded cluster）是⼀种⽔平扩展数据库系统性能的⽅法，能够将数据集分布式存储在不同的分⽚（shard）上，每个分⽚只保存数据集的⼀部分，MongoDB保证各个分⽚之间不会有重复的数据，所有分⽚保存的数据之和就是完整的数据集。

分⽚集群将数据集分布式存储，能够将负载分摊到多个分⽚上，每个分⽚只负责读写⼀部分数据，充分利⽤了各个shard的系统资源，提⾼数据库系统的吞吐量⼀、系统环境Centos MongoDB 关闭防⽕墙192.168.174.131192.168.174.132192.168.174.133mongos mongos mongosconfig server config server config servershard server1 主节点shard server1 副节点shard server1 仲裁shard server2 仲裁shard server2 主节点shard server2 副节点shard server3 副节点shard server3 仲裁shard server3 主节点端⼝分配：mongos：20000config：21000shard1：27001shard2：27002shard3：27003三台机器的配置服务(21000)形成复制集，分⽚1、2、3也在各机器都部署⼀个实例，它们之间形成复制集，客户端直接连接3个路由服务与之交互，配置服务和分⽚服务对客户端是透明的。

linux下Mongodb集群搭建：分⽚+副本集三台服务器 192.168.1.40/41/42安装包 mongodb-linux-x86_64-amazon2-4.0.1.tgz服务规划服务器40服务器41服务器42mongos mongos mongosconfig server config server config servershard server1 主节点 shard server1副节点 shard server1仲裁shard server2 仲裁 shard server2 主节点 shard server2 副节点shard server3副节点 shard server3仲裁 shard server3主节点端⼝分配：mongos：28000config:28001shard1:28011shard2:28012shard3:28013主要模块以及配置⽂件1、config server 配置服务器vi /usr/local/mongodb/conf/config.conf40服务器配置⽂件pidfilepath = /usr/local/mongodb/config/log/configsrv.piddbpath = /mydata/mongodb/config/datalogpath = /usr/local/mongodb/config/log/congigsrv.loglogappend = truebind_ip = 192.168.29.40port = 28001fork = true #以守护进程的⽅式运⾏MongoDB，创建服务器进程#declare this is a config db of a cluster;configsvr = true#副本集名称replSet=configs#设置最⼤连接数maxConns=2000041服务器配置⽂件pidfilepath = /usr/local/mongodb/config/log/configsrv.piddbpath = /mydata/mongodb/config/datalogpath = /usr/local/mongodb/config/log/congigsrv.loglogappend = truebind_ip = 192.168.29.41port = 28001fork = true #以守护进程的⽅式运⾏MongoDB，创建服务器进程#declare this is a config db of a cluster;configsvr = true#副本集名称replSet=configs#设置最⼤连接数maxConns=2000042服务器配置⽂件pidfilepath = /usr/local/mongodb/config/log/configsrv.piddbpath = /mydata/mongodb/config/datalogpath = /usr/local/mongodb/config/log/congigsrv.loglogappend = truebind_ip = 192.168.29.42port = 28001fork = true #以守护进程的⽅式运⾏MongoDB，创建服务器进程#declare this is a config db of a cluster;configsvr = true#副本集名称replSet=configs#设置最⼤连接数maxConns=20000启动三台服务器的config servermongod -f /usr/local/mongodb/conf/config.conf登录任意⼀台配置服务器，初始化配置副本集#连接mongo --port 21000#config变量config = {... _id : "configs",... members : [... {_id : 0, host : "192.168.1.40:28001" },... {_id : 1, host : "192.168.1.41:28001" },... {_id : 2, host : "192.168.1.42:28001" }... ]... }#初始化副本集rs.initiate(config)2 配置分⽚副本集(三台机器)配置⽂件vi /usr/local/mongodb/conf/shard1.conf#配置⽂件内容#——————————————–pidfilepath = /usr/local/mongodb/shard1/log/shard1.piddbpath = /mydata/mongodb/shard1/datalogpath = /usr/local/mongodb/shard1/log/shard1.log logappend = truebind_ip = 192.168.29.40port = 28011fork = true#打开web监控#httpinterface=true#rest=true#副本集名称replSet=shard1#declare this is a shard db of a cluster;shardsvr = true#设置最⼤连接数maxConns=20000#配置⽂件内容#——————————————–pidfilepath = /usr/local/mongodb/shard1/log/shard1.piddbpath = /mydata/mongodb/shard1/datalogpath = /usr/local/mongodb/shard1/log/shard1.log logappend = truebind_ip = 192.168.29.41port = 28011fork = true#打开web监控#httpinterface=true#rest=true#副本集名称replSet=shard1#declare this is a shard db of a cluster;shardsvr = true#设置最⼤连接数maxConns=20000#配置⽂件内容#——————————————–pidfilepath = /usr/local/mongodb/shard1/log/shard1.piddbpath = /mydata/mongodb/shard1/datalogpath = /usr/local/mongodb/shard1/log/shard1.log logappend = truebind_ip = 192.168.29.42port = 28011fork = true#打开web监控#httpinterface=true#rest=true#副本集名称replSet=shard1#declare this is a shard db of a cluster;shardsvr = true#设置最⼤连接数maxConns=20000vi /usr/local/mongodb/conf/shard2.confvi /usr/local/mongodb/conf/shard2.conf （shard2和shard3就是上⾯配置⽂件相应地⽅改为2和3就可以了）3、配置路由服务器 mongos先启动配置服务器和分⽚服务器,后启动路由实例:（三台机器）vi /usr/local/mongodb/conf/mongos.conf#内容pidfilepath = /usr/local/mongodb/mongos/log/mongos.pidlogpath = /usr/local/mongodb/mongos/log/mongos.loglogappend = truebind_ip = 0.0.0.0port = 28000fork = true#监听的配置服务器,只能有1个或者3个 configs为配置服务器的副本集名字configdb = configs/192.168.1.40:28001,192.168.1.41:28001,192.168.1.42:28001#设置最⼤连接数maxConns=20000启动三台服务器的mongos servermongos -f /usr/local/mongodb/conf/mongos.conf4、启⽤分⽚⽬前搭建了mongodb配置服务器、路由服务器，各个分⽚服务器，不过应⽤程序连接到mongos路由服务器并不能使⽤分⽚机制，还需要在程序⾥设置分⽚配置，让分⽚⽣效。

mongodb分片集群的组件及搭建分片集群的流程(一)MongoDB分片集群的组件及搭建分片集群的流程MongoDB分片集群是面向大规模、高并发的应用程序而设计的可扩展性技术，可以实现数据水平扩展，在数据量增长时增加硬件资源以满足应用程序的需求。

MongoDB分片集群的组件1.分片服务器：负责将数据划分为多个分片存储在多个分片服务器上。

2.路由服务器：负责将客户端的请求转发到正确的分片服务器。

3.配置服务器：保存分片集群的元数据信息，包括分片服务器信息、数据分片信息等。

4.客户端：向路由服务器发送请求，并从分片服务器获得响应。

搭建分片集群的流程1.配置服务器：首先设置至少3个配置服务器，每个配置服务器都是一个单独的MongoDB实例，运行在不同的机器上。

–安装MongoDB–配置配置服务器副本集–启动配置服务器副本集2.分片服务器：将MongoDB实例部署在多个机器上，然后将每个MongoDB实例配置为一个分片服务器。

–安装MongoDB–启动MongoDB实例–将MongoDB实例添加到分片集群3.路由服务器：在一个单独的MongoDB实例上启动mongos进程。

–安装MongoDB–启动mongos进程–将路由服务器添加到分片集群4.分片数据管理：配置数据分片，将数据分散到多个分片服务器上。

–创建分片键–启动分片功能–添加分片到分片集群–将集合分片到多个分片服务器上5.测试分片集群：使用客户端向路由服务器发送请求，测试分片集群的可用性。

以上为MongoDB分片集群搭建流程的简化版，具体步骤与细节请参考MongoDB官方文档。

总结MongoDB分片集群适用于需要处理大量数据的应用程序，可以帮助应用程序水平扩展以满足业务需求。

由于MongoDB分片集群由多个组件组成，搭建过程较为复杂，需要根据具体业务需求进行配置。

注意事项在搭建MongoDB分片集群时，需要注意以下事项：1.分片服务器的数量应该足够，否则可能无法满足应用程序的需求。

111传媒技术⒈软件版本64位操作系统CentOS6.5+；mongodb3.6社区版；⒉副本集规则和特性2.1 副本集的成员角色、数量副本集由1个主节点P（Primary）、若干个从节点S （Secondary）、仲裁节点A（Arbiter，根据实际情况设定）构成。

每个副本集的节点总数不超过50，最少有3个节点（分片集群排除单节点、主从双节点的情况），如图1所示的2种情况：1主2从，1主1从1仲裁，单箭头表示主从复制，双箭头表示心跳。

图 1 三个节点的副本集结构2.2 副本集选举的大多数选举主节点，需得到大多数成员的支持，这里的大多数，是具有投票权的节点的半数以上， 不一定是副本集节点总数的大多数。

图2 副本集选举的大多数2.3 有投票权的节点总数一个副本集中，有投票权的节点总数不超过7个； 若副本集的节点总数不超过7，默认每个节点都有投票权；若副本集节点总数多于7个，超出7个之外的差额数量的节点，必须设成没有投票权。

比如：副本集节点总数为9，必须设定2个节点没有投票权。

即：若投票节点数量少于副本集节点总数，需要设定差额数量的节点没有投票权。

图2中的容错数，指在能正常选举出主节点的情况下，投票节点失效的最大数量。

只要失效的投票节点不超过容错数，就能正常选举出主节点。

副本集节点总数、有投票权的节点总数，一般都设定为奇数，但不是强制性的。

关于节点数量设成奇数还是偶数，有一种观点认为：如果设成偶数，选举的时候可能出现2个节点得票数一样多的情况，从而选不出主节点。

我们假设这种情况成立，如：节点总数为4，可用节点数为4，可能选不出主节点；再考虑一下节点总数为5，投票节点数量为5，对1个节点停机维护，剩下4个节点可用，也可能选不出主节点。

这显然是个悖论，和mongodb高可用架构的特性不符。

经实验验证，设定为偶数个，只要选举超过半数，同样能选出主节点。

但是，从图2中可以看出，奇数个投票节点，再增加一个成为偶数个，不能提高容错数，反而降低了副本集的稳定性。

MongoDB分⽚技术原理和⾼可⽤集群配置⽅案⼀、Sharding分⽚技术1、分⽚概述当数据量⽐较⼤的时候，我们需要把数分⽚运⾏在不同的机器中，以降低CPU、内存和Io的压⼒，Sharding就是数据库分⽚技术。

MongoDB分⽚技术类似MySQL的⽔平切分和垂直切分，数据库主要由俩种⽅式做Sharding：垂直扩展和横向切分。

垂直扩展的⽅式就是进⾏集群扩展，添加更多的CPU，内存，磁盘空间等。

横向切分则是通过数据分⽚的⽅式，通过集群统⼀提供服务：⼆、MongoDB分⽚架构原理（1）MongoDB的Sharding架构其中，Router负责接受访问，然后去config服务器中查询元数据，将数据存储信息返回给Router，Router服务器根据元数据的存储信息在分⽚服务器上读取或者写⼊数据。

（2）MongoDB分⽚架构中的⾓⾊a、数据分⽚（Shards）⽤来保存数据，保证数据的⾼可⽤性和⼀致性。

可以是⼀个单独的mongod实例，也可以是⼀个副本集。

在⽣产环境下Shard⼀般是⼀个Replica Set，以防⽌该数据⽚的单点故障。

所有Shard中有⼀个PrimaryShard，⾥⾯包含未进⾏划分的数据集合：b、查询路由（Query Routers）路由就是mongos的实例，客户端直接连接mongos，由mongos把读写请求路由到指定的Shard上去。

⼀个Sharding集群，可以有⼀个mongos，也可以有多个mongos以减轻客户端请求的压⼒。

c、配置服务器（Config servers）保存集群的元数据（metadata），包含各个Shard的路由规则。

Sharding分⽚技术（混合模式）⾼可⽤⽅案的架构图如下：1）Sharding分⽚技术（混合模式）⾼可⽤架构下MongoDB数据写⼊流程第⼀步：客户端访问路由服务器（Mongos），路由服务器接收到请求。

第⼆步：路由服务器将客户端访问配置服务器，配置服务器（Config）根据根据请求信息将数据信息写⼊到元数据中。

mongodb分片集群的组件及搭建分片集群的流程MongoDB是一个流行的非关系型数据库，它支持分布式存储和处理大量结构化和非结构化数据。

为了支持高可用性和扩展性，MongoDB提供了分片集群的功能。

分片集群可以将一个巨大的MongoDB数据库分拆成多个分片，并将这些分片分布在多台服务器上。

下面让我们了解一下MongoDB分片集群的组件以及搭建分片集群的流程。

组件1.分片服务器（Shard Server）：分片服务器是MongoDB分片集群的核心。

它们存储数据并根据数据的主键将其分发到不同的分片上。

2.配置服务器（Config Server）：配置服务器维护着分片集群的元数据信息，例如配置信息和分片信息。

每个分片集群需要至少三个配置服务器。

3.路由服务器（Router Server）：路由服务器充当负载均衡器的角色，将客户端请求路由到正确的分片服务器上。

搭建分片集群的流程1.安装并启动分片服务器：在每台分片服务器上安装MongoDB，并启动分片服务器服务。

2.安装并启动配置服务器：在三台以上的不同服务器上安装MongoDB，配置为配置服务器，并启动配置服务器服务。

3.添加分片服务器到分片集群中：在路由服务器上执行“sh.addShard()”命令，并指定分片服务器的IP地址及端口号。

可重复执行该命令，添加多个分片服务器到分片集群中。

4.启动路由服务器：在一台服务器上配置为路由服务器，并启动路由服务器服务。

5.启用分片集群模式：在路由服务器上执行“sh.enableSharding()”命令，启用分片集群模式。

6.为分片集群的集合启用分片：使用路由服务器上的“sh.shardCollection()”命令将集合分片。

指定集合所在的数据库、集合名称以及用于分片的键。

7.检查分片集群状态：使用“sh.status()”命令在路由服务器上检查分片集群的状态。

在这里可以看到分片的状态信息以及集群的可用性和负载情况。

mongo 设置集合分片规则MongoDB是一种非关系型数据库，它以文档的形式存储数据。

在MongoDB中，数据存储在集合（Collection）中，而集合可以根据一定的规则进行分片（Sharding），以实现数据的分布式存储和查询。

在MongoDB中，集合分片是将一个集合的数据分散存储在多个服务器上的过程。

这样做的好处是可以增加数据的存储容量和查询性能。

下面将介绍一些关于MongoDB集合分片的规则和注意事项。

1. 集合分片的原则集合分片的原则是根据数据的某个字段（通常是主键）进行划分，确保相同数据被分配到同一个分片上。

这样可以保证数据在分布式环境中的一致性和可查询性。

2. 分片键的选择分片键的选择非常重要，它直接影响到分片的效果和查询性能。

一般来说，分片键应该是唯一的、均匀分布的，并且与查询的频率高相关。

例如，如果一个集合中的数据按照用户ID进行查询频繁，那么可以选择用户ID作为分片键。

3. 分片策略MongoDB提供了多种分片策略，可以根据不同的需求选择合适的策略。

常用的分片策略有范围分片、哈希分片和标签分片。

- 范围分片：根据分片键的范围进行划分，例如按照时间范围进行划分，将数据按照时间段存储在不同的分片上。

- 哈希分片：根据分片键的哈希值进行划分，将数据均匀地存储在多个分片上。

- 标签分片：根据用户自定义的标签进行划分，可以实现数据的灵活存储和查询。

4. 分片集群的部署分片集群的部署需要考虑多个因素，包括分片数量、复制因子、硬件配置等。

一般来说，分片数量应该和数据量保持一定的比例，复制因子应该根据数据的可用性要求进行设置，硬件配置应该满足查询性能的要求。

5. 分片的动态调整在实际应用中，数据的分布会随着时间的推移发生变化，因此需要对分片进行动态调整。

MongoDB提供了动态迁移和重平衡机制，可以在运行时对分片进行增加、删除和移动。

总结起来，MongoDB的集合分片是一种实现数据分布式存储和查询的重要机制。

MongoDB搭建⾼可⽤集群的完整步骤（3个分⽚+3个副本）配置脚本以及⽬录下载：⼀、规划好端⼝ip架构图如下，任意抽取每个副本集中的⼀个分⽚（⾮仲裁节点）可以组成⼀份完整的数据。

1. 第⼀个副本集rs1share1 10.0.0.7:30011:/data/share_rs/share_rs1/share1/data/share2 10.0.0.7:40011:/data/share_rs/share_rs1/share2/data/share3 10.0.0.7:50011:/data/share_rs/share_rs1/share3/data/2. 第⼆个副本集rs2share1 10.0.0.7:30012:/data/share_rs/share_rs2/share1/data/share2 10.0.0.7:40012:/data/share_rs/share_rs2/share2/data/share3 10.0.0.7:50012:/data/share_rs/share_rs2/share3/data/3. 第三个副本集rs3share1 10.0.0.7:30013:/data/share_rs/share_rs3/share1/data/share2 10.0.0.7:40013:/data/share_rs/share_rs3/share2/data/share3 10.0.0.7:50013:/data/share_rs/share_rs3/share3/data/4.config serverconfig1 10.0.0.7:30002:/data/share_rs/config/config1/data/config2 10.0.0.7:30002:/data/share_rs/config/config2/data/config3 10.0.0.7:30002:/data/share_rs/config/config3/data/5. mongosmongos1 10.0.0.7:30001:/data/share_rs/mongos/mongos1/data/mongos2 10.0.0.7:30001:/data/share_rs/mongos/mongos2/data/mongos3 10.0.0.7:30001:/data/share_rs/mongos/mongos3/data/⼆、创建相应的⽬录mkdir -p /data/share_rs/{share_rs1,share_rs2,share_rs3}/{share1,share2,share3}/{data,log}mkdir -p /data/share_rs/mongos/{mongos1,mongos2,mongos3}/{data,log}mkdir -p /data/share_rs/config/{config1,config2,config3}/{data,log}三、配置mongs和config的配置⽂件（其他副本参考修改端⼝以及ip）[mongo@mongo config1]$ cat mongo.confdbpath=/data/share_rs/config/config1/data/logpath=/data/share_rs/config/config1/log/mongo.loglogappend=trueport=30002fork=truerest=truehttpinterface=trueconfigsvr=true[mongo@mongo mongs1]$ cat mongo.conflogpath=/data/share_rs/mongos/mongos1/log/mongo.loglogappend=trueport=30001fork=trueconfigdb=10.0.0.7:30002,10.0.0.7:40002,10.0.0.7:50002chunkSize=1四、依次启动三个副本上的config服务器以及mongs服务器mongod -f /data/share_rs/config/config1/mongo.confmongod -f /data/share_rs/config/config2/mongo.confmongod -f /data/share_rs/config/config3/mongo.confmongos -f /data/share_rs/mongos/mongos1/mongo.confmongos -f /data/share_rs/mongos/mongos2/mongo.confmongos -f /data/share_rs/mongos/mongos3/mongo.conf五、配置mong分⽚的的配置⽂件（其他副本参考修改端⼝以及ip），同⼀个分⽚的副本集名称⼀样，即replSet。