Linux下Mongodb的分布式分片群集(sharding cluster)配置

生产MongoDB 分片与集群方案【编者的话】Mongo DB 是目前在IT行业非常流行的一种非关系型数据库(NoSql),其灵活的数据存储方式备受当前IT从业人员的青睐。

Mongo DB很好的实现了面向对象的思想(OO思想),在Mongo DB中每一条记录都是一个Document对象。

本文介绍了一则生产环境下MongoDB实现分片与集群方案的操作实例。

一、mongodb分片与集群拓扑图二、分片与集群的部署1.Mongodb的安装分别在以上3台服务器安装好mongodb安装方法见安装脚本。

2.Mongod 创建单个分片的副本集10.68.4.209①建立数据文件夹和日志文件夹mdkir /data/{master,slave,arbiter}mkdir /data/log/mongodb/{master,slave,arbiter} -p②建立配置文件#master.confdbpath=/data/masterlogpath=/data/log/mongodb/master/mongodb.logpidfilepath=/var/run/mongo_master.pid#directoryperdb=truelogappend=truereplSet=policydbport=10002oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#slave.confdbpath=/data/slavelogpath=/data/log/mongodb/slave/mongodb.log pidfilepath=/var/run/mongo_slave.pid#directoryperdb=truelogappend=truereplSet=policydbport=10001oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#arbiter.confdbpath=/data/arbiterlogpath=/data/log/mongodb/arbiter/mongodb.logpidfilepath=/var/run/mongo_arbiter.pid#directoryperdb=truelogappend=truereplSet=policydbport=10000oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200③启动mongodb/etc/init.d/mongodb_master start/etc/init.d/mongodb_slave start/etc/init.d/mongodb_arbiter start④配置主、备、仲裁节点主节点:# /usr/local/mongodb/bin/mongo 10.68.4.209:10002MongoDB shell version: 2.4.9connecting to: 10.68.4.209:10002/test> use adminswitched to db admin>config={ _id:"policydb", members:[ {_id:0,host:'10.68.4.209:1000 2',priority:2}, {_id:1,host:'10.68.4.209:10001',priority:1},... {_id:2,host:'10.68.4.209:10000',arbiterOnly:true}] }; {"_id" : "policydb","members" : [{"_id" : 0,"host" : "10.68.4.209:10002","priority" : 2},{"_id" : 1,"host" : "10.68.4.209:10001","priority" : 1},{"_id" : 2,"host" : "10.68.4.209:10000","arbiterOnly" : true}]}rs.initiate(config) #初始化rs.status() #查看集群状态10.68.4.29①建立数据文件夹和日志文件夹mdkir /data/{master,slave,arbiter}mkdir /data/log/mongodb/{master,slave,arbiter} -p②建立配置文件#master.confdbpath=/data/masterlogpath=/data/log/mongodb/master/mongodb.log pidfilepath=/var/run/mongo_master.pid#directoryperdb=truelogappend=truereplSet=policydb2port=10002oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#slave.confdbpath=/data/slavelogpath=/data/log/mongodb/slave/mongodb.log pidfilepath=/var/run/mongo_slave.pid#directoryperdb=truelogappend=truereplSet=policydb2port=10001oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#arbiter.confdbpath=/data/arbiterlogpath=/data/log/mongodb/arbiter/mongodb.log pidfilepath=/var/run/mongo_arbiter.pid#directoryperdb=truelogappend=truereplSet=policydb2port=10000oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200③启动mongodb/etc/init.d/mongodb_master start/etc/init.d/mongodb_slave start/etc/init.d/mongodb_arbiter start④配置主、备、仲裁节点主节点:# /usr/local/mongodb/bin/mongo 10.68.4.209:10002MongoDB shell version: 2.4.9connecting to: 10.68.4.209:10002/test> use adminswitched to db admin> config={ _id:"policydb2", members:[ {_id:0,host:'10.68.4.29:100 02',priority:2}, {_id:1,host:'10.68.4.29:10001',priority:1},... {_id:2,host:'10.68.4.209:10000',arbiterOnly:true}] };{"_id" : "policydb","members" : [{"_id" : 0,"host" : "10.68.4.29:10002","priority" : 2},{"_id" : 1,"host" : "10.68.4.29:10001","priority" : 1},{"_id" : 2,"host" : "10.68.4.29:10000", "arbiterOnly" : true}]}rs.initiate(config) #初始化rs.status() #查看集群状态10.68.4.30①建立数据文件夹和日志文件夹mdkir /data/{master,slave,arbiter}mkdir /data/log/mongodb/{master,slave,arbiter} -p②建立配置文件#master.confdbpath=/data/masterlogpath=/data/log/mongodb/master/mongodb.log pidfilepath=/var/run/mongo_master.pid#directoryperdb=truelogappend=truereplSet=policydb3port=10002oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#slave.confdbpath=/data/slavelogpath=/data/log/mongodb/slave/mongodb.log pidfilepath=/var/run/mongo_slave.pid#directoryperdb=truelogappend=truereplSet=policydb3port=10001oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200#arbiter.confdbpath=/data/arbiterlogpath=/data/log/mongodb/arbiter/mongodb.log pidfilepath=/var/run/mongo_arbiter.pid#directoryperdb=truelogappend=truereplSet=policydb3port=10000oplogSize=10000fork=truenoprealloc=trueprofile=1slowms=200③启动mongodb/etc/init.d/mongodb_master start/etc/init.d/mongodb_slave start/etc/init.d/mongodb_arbiter start④配置主、备、仲裁节点主节点:# /usr/local/mongodb/bin/mongo 10.68.4.209:10002MongoDB shell version: 2.4.9connecting to: 10.68.4.209:10002/test> use adminswitched to db admin> config={ _id:"policydb3", members:[ {_id:0,host:'10.68.4.30:100 02',priority:2}, {_id:1,host:'10.68.4.30:10001',priority:1},... {_id:2,host:'10.68.4.30:10000',arbiterOnly:true}] };{"_id" : "policydb","members" : [{"_id" : 0,"host" : "10.68.4.30:10002","priority" : 2},{"_id" : 1,"host" : "10.68.4.30:10001","priority" : 1},{"_id" : 2,"host" : "10.68.4.30:10000","arbiterOnly" : true}]}rs.initiate(config) #初始化rs.status() #查看集群状态2.Mongod 创建单个分片的配置服务器①创建配置目录10.68.4.209 mkdir /data/config10.68.4.29 mkdir /data/config10.68.4.30 mkdir /data/config②准备配置服务器的配置文件3个服务器的配置服务器的配置文件一致#config.confdbpath=/data/configlogpath=/data/log/mongodb/config/mongodb.logpidfilepath=/var/run/mongo_config.piddirectoryperdb=truelogappend=trueport=10003fork=trueconfigsvr=true③启动配置服务器/etc/init.d/mongodb_config start3.Mongod 创建并配置mongos和开启分片模式①创建日志目录Mkdir -p /data/log/mongodb/mongos/②准备mongos的配置文件#mongos.conflogpath=/data/log/mongodb/mongos/mongodb.logpidfilepath=/var/run/mongo_mongos.pidlogappend=trueport=10004fork=trueconfigdb=10.68.4.209:10003,10.68.4.29:10003,10.68.4.30:1000③启动mongos/etc/init.d/mongodb_mongos start④配置分片sh.addShard("policydb/10.68.4.209:10002")sh.addShard("policydb2/10.68.4.29:10002")sh.addShard("policydb3/10.68.4.30:10002")sh.enableSharding("policydb")db.runCommand({"shardcollection":"policydb.fullPolicyTextInfo_his tory", "key":{"key":1}})db.printShardingStatus() #查看分片状态sh.status({verbose:true})sh.status()3.快速创建副本集和配置服务脚本上图1.图12.图2 config.conf配置文件3.图3附mongodb一键安装脚本:/s/1c0zvP7M附mongodb副本集和配置服务器一键配置脚本:/s/1GuQ0A博文出处：/pwd/blog/411439【编辑推荐】为什么选择使用NoSQL数据库开发如此困难？软件公司为何要放弃MongoDB？NoSQL详解：如何找到对的技术为什么需要选用NoSQL？谷歌新款高性能NoSQL数据库支持HBase接口。

Mongodb集群配置(sharding with replica set)长期以来我就对分布式系统原理与实践非常感兴趣，对于Mongodb我一直很好奇，最近终于有时间能动手实验一把！我在一台Windows机器下搭建了一个Replica Sets + Sharding 测试集群环境，以此作为我后续对于Mongodb更进一步学习的实验平台。

只有一台windows机器，配置方案：1、3个分片sharding2、每一个分片由3个节点构成1主2备的Replica Sets3、3个配置节点Configsever4、1个路由节点Mongos分片复制集A（三个分片节点构成一个复制集）：127.0.0.1:10000 127.0.0.1:10001 127.0.0.1:10002分片复制集B（三个分片节点构成一个复制集）：127.0.0.1:20000 127.0.0.1:20001 127.0.0.1:20002分片复制集C（三个分片节点构成一个复制集）：127.0.0.1:30000 127.0.0.1:30001 127.0.0.1:30002Configsvc（三个配置服务器节点）:127.0.0.1:40000 127.0.0.1:40001 127.0.0.1:4002 mongos（一个路由节点）:127.0.0.1:50000详细操作步骤如下：（1）下载mongodb-win32-i386-1.8.0下载mongodb-win32-i386-1.8.0版本的Mongodb，放置在d:/mongodb-win32-i386-1.8.0目录下。

（2）创建数据和日志文件目录进入d:/mongodb-win32-i386-1.8.0目录下创建如下目录创建数据文件目录：data/a/r0data/a/r1data/a/r2data/b/r0data/b/r1data/b/r2data/c/r0data/c/r1data/c/r2data/configsvr/r0data/configsvr/r1data/configsvr/r2创建日志文件目录:logs/alogs/blogs/clogs/configsvr（3）创建分片和复制集配置第一组：从命令行进入d:/mongodb-win32-i386-1.8.0/bin目录，分别执行如下命令！mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/a/r0.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/a/r0 --port 10000 --shardsvr--replSet setA --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/a/r1.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/a/r1 --port 10001 --shardsvr--replSet setA --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/a/r2.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/a/r2 --port 10002 --shardsvr--replSet setA --rest --oplogSize 64启动上述分片节点之后，再使用mongo的命令行来初始化复制集D:/mongodb-win32-i386-1.8.0/bin>call mongo.exe 127.0.0.1:10000/admin MongoDB shell version: 1.8.0connecting to: 127.0.0.1:10000/admin> config={_id: 'setA', members:[{_id:0,host:'127.0.0.1:10000'},{_id:1,host:'127.0.0.1:10001'},{_id:2,host:'127.0.0.1:10002'}]}{"_id" : "setA","members" : [{"_id" : 0,"host" : "127.0.0.1:10000"},{"_id" : 1,"host" : "127.0.0.1:10001"},{"_id" : 2,"host" : "127.0.0.1:10002"}]}setA> rs.initiate(config);配置第二组：从命令行进入d:/mongodb-win32-i386-1.8.0/bin目录，分别执行如下命令！mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/b/r0.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/b/r0 --port 20000 --shardsvr--replSet setB --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/b/r1.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/b/r1 --port 20001 --shardsvr--replSet setB --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/b/r2.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/b/r2 --port 20002 --shardsvr--replSet setB --rest --oplogSize 64启动上述分片节点之后，再使用mongo的命令行来初始化复制集D:/mongodb-win32-i386-1.8.0/bin>call mongo.exe 127.0.0.1:20000/admin MongoDB shell version: 1.8.0connecting to: 127.0.0.1:20000/admin> config={_id: 'setB', members:[{_id:0,host:'127.0.0.1:20000'},{_id:1,host:'127.0.0.1:20001'},{_id:2,host:'127.0.0.1:20002'}]}{"_id" : "setB","members" : [{"_id" : 0,"host" : "127.0.0.1:20000"},{"_id" : 1,"host" : "127.0.0.1:20001"},{"_id" : 2,"host" : "127.0.0.1:20002"}]}> rs.initiate(config);配置第三组：从命令行进入d:/mongodb-win32-i386-1.8.0/bin目录，分别执行如下命令！mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/c/r0.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/c/r0 --port 30000 --shardsvr--replSet setC --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/c/r1.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/c/r1 --port 30001 --shardsvr--replSet setC --rest --oplogSize 64mongod.exe --logpath d:/mongodb-win32-i386-1.8.0/logs/c/r2.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/c/r2 --port 30002 --shardsvr--replSet setC --rest --oplogSize 64D:/mongodb-win32-i386-1.8.0/bin>call mongo.exe 127.0.0.1:30000/admin MongoDB shell version: 1.8.0connecting to: 127.0.0.1:30000/admin> config={_id: 'setC', members:[{_id:0,host:'127.0.0.1:30000'},{_id:1,host:'127.0.0.1:30001'},{_id:2,host:'127.0.0.1:30002'}]}{"_id" : "setC","members" : [{"_id" : 0,"host" : "127.0.0.1:30000"},{"_id" : 1,"host" : "127.0.0.1:30001"},{"_id" : 2,"host" : "127.0.0.1:30002"}]}> rs.initiate(config);（4）启动三个配置服务节点Configsvr从命令行分别执行如下命令，配置三个Configsvr cd d:/mongodb-win32-i386-1.8.0/bincall mongod.exe --configsvr --logpathd:/mongodb-win32-i386-1.8.0/logs/configsvr/r0.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/configsvr/r0 --port 40000 --shardsvrcd d:/mongodb-win32-i386-1.8.0/bincall mongod.exe --configsvr --logpathd:/mongodb-win32-i386-1.8.0/logs/configsvr/r1.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/configsvr/r1 --port 40001 --shardsvrcd d:/mongodb-win32-i386-1.8.0/bincall mongod.exe --configsvr --logpathd:/mongodb-win32-i386-1.8.0/logs/configsvr/r2.log --logappend --dbpath d:/mongodb-win32-i386-1.8.0/data/configsvr/r2 --port 40002 --shardsvr （5）启动一个路由节点mongoscd d:/mongodb-win32-i386-1.8.0/bincall mongos.exe --configdb 127.0.0.1:40000,127.0.0.1:40001,127.0.0.1:40002 --logpath d:/mongodb-win32-i386-1.8.0/logs/mongos.log --logappend --port 50000（6）配置分片D:/mongodb-win32-i386-1.8.0/cmd>cd d:/mongodb-win32-i386-1.8.0/bin D:/mongodb-win32-i386-1.8.0/bin>call mongo.exe 127.0.0.1:50000 MongoDB shell version: 1.8.0connecting to: 127.0.0.1:50000/test> use adminswitched to db admin>db.runCommand({addshard:"setA/127.0.0.1:10000,127.0.0.1:10001,127.0.0.1:10002 ",name:"ShardSetA"}){ "shardAdded" : "ShardSetA", "ok" : 1 }>db.runCommand({addshard:"setB/127.0.0.1:20000,127.0.0.1:20001,127.0.0.1:20002 ",name:"ShardSetB"}){ "shardAdded" : "ShardSetB", "ok" : 1 }>db.runCommand({addshard:"setC/127.0.0.1:30000,127.0.0.1:30001,127.0.0.1:30002 ",name:"ShardSetC"}){ "shardAdded" : "ShardSetC", "ok" : 1 }> printShardingStatus()--- Sharding Status ---sharding version: { "_id" : 1, "version" : 3 }shards:{"_id" : "ShardSetA","host" : "setA/127.0.0.1:10000,127.0.0.1:10001,127.0.0.1:10002"标准实用文案}{"_id" : "ShardSetB","host" : "setB/127.0.0.1:20000,127.0.0.1:20001,127.0.0.1:20002"}{"_id" : "ShardSetC","host" : "setC/127.0.0.1:30000,127.0.0.1:30001,127.0.0.1:30002"}databases:{ "_id" : "admin", "partitioned" : false, "primary" : "config" }配置到这里，集群搭建完毕了！在完成了集群的搭建工作之后，需要做的就是建立一个数据库，建立表，设置分片主键来初始化数据了！文档。

mongodb 分片原理MongoDB 分片是一种用于处理大量数据的横向扩展方法，允许将数据分布到多个服务器上。

分片可以在MongoDB 中实现水平扩展，提高系统的容量和性能。

以下是MongoDB 分片的基本原理：1. 分片键（Shard Key）：-在MongoDB 中，数据根据一个称为分片键（Shard Key）的字段进行分片。

分片键的选择非常关键，它应该能够确保数据均匀分布，避免热点（hotspot）问题。

-分片键通常是在文档中的一个字段，MongoDB 根据这个字段的值来决定将文档存储在哪个分片上。

2. 分片集合（Sharded Collection）：-分片集合是一个普通的MongoDB 集合，但被配置为进行分片。

这样的集合存储在多个分片服务器上，每个分片负责存储数据的一部分。

3. Config 服务器：-MongoDB 使用Config 服务器来跟踪每个分片中数据的范围和位置。

Config 服务器存储了分片集合的元数据，包括分片键的范围和分片的位置信息。

4. Mongos 路由器：-Mongos 是一个路由器，它位于应用程序和MongoDB 分片集群之间。

应用程序通过Mongos 与整个集群交互，Mongos 负责将请求路由到适当的分片上。

5. 数据迁移：-当有新的分片加入集群或现有的分片移除时，MongoDB 会自动进行数据迁移。

数据迁移确保分片集合中的数据保持均匀分布。

6. 均衡器（Balancer）：- MongoDB 集群中有一个均衡器，它会监视每个分片上的数据量，并在需要时触发数据迁移以保持均衡。

均衡器可以手动启动或自动运行。

MongoDB 分片的主要优势在于它允许数据库在数据量增加时水平扩展，通过添加更多的分片来处理更多的负载。

分片键的选择和分片集群的规划是关键的设计决策，因为它们直接影响了系统的性能和可扩展性。

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.分片服务器的数量应该足够，否则可能无法满足应用程序的需求。

mongodb分片规则MongoDB的分片技术是一种数据的分布式存储技术，它可以将大量的数据分散到不同的物理节点上，实现高效的数据扩展和高可用性的运作方式。

MongoDB的分片机制主要包括3个部分：集群架构、分片选举和数据的分散存储。

一、集群架构MongoDB 的分片模式下，会有三类节点：客户端、mongos路由器和数据节点。

其中，mongos和数据节点是实际的服务器节点。

客户端和 mongos 之间的交互属于应用层面，而mongos 和数据节点之间则属于 MongoDB 的内部数据传输。

mongos作为路由器，对外提供统一的 MongoDB 服务，它负责接收客户端连接请求、路由请求到正确的数据节点、处理Mongos 查询请求（如脚本处理)等。

数据节点存储数据，每个数据节点可以有多个分片，每个分片存储一部分的数据。

二、分片选举MongoDB提供了多种分片选举算法，通过它们可以灵活地决定分片的划分方式，从而更好地负载数据节点。

下面介绍一下 MongoDB 中的两种分片选举算法。

1.哈希分片（Hash Sharding）哈希分片是一种将数据划分到不同节点的算法，它将每个数据进行哈希，然后根据哈希值对数据进行分散。

在Mongos端可以调整哈希函数，以实现请求的均衡路由。

2.范围分片（Range Sharding）范围分片是一种将数据划分到不同物理节点上的方法，它通过设置切分的字段和值来划分数据。

例如可以按时间、ID等。

三、数据的分散存储为了保证数据在不同的数据节点上存储，并且在查询时可以高效的定位到数据所在节点，MongoDB采用了一种类似于哈希表的存储方式——mongod数据分片。

mongod 数据分片包含以下组件：1.元数据服务元数据服务负责存储集群的元数据信息，包括数据的分片信息、分片键等。

2.块服服务块服服务负责存储和管理数据，每个块对应一个数据分片，块服服务还通过心跳和版本号等机制保证数据的一致性。

mongodb 高可用方案MongoDB高可用方案MongoDB是一款开源的NoSQL数据库，因其灵活的数据模型和强大的横向扩展能力而备受欢迎。

在应用中，高可用性是非常重要的，因此本文将介绍一些MongoDB的高可用方案。

一、复制集（Replica Set）复制集是MongoDB中实现高可用的基本组件。

复制集由多个MongoDB实例组成，其中包括一个主节点（Primary）和多个从节点（Secondary），以及一个仲裁节点（Arbiter）。

主节点处理所有的写操作和客户端的读操作，从节点通过复制主节点的数据实现数据备份和读操作的负载均衡。

仲裁节点用于选举主节点。

在复制集中，当主节点发生故障时，从节点会自动发起选举，选举出新的主节点。

这种方式保证了数据的持久性和高可用性。

同时，MongoDB还支持自动故障转移，当主节点恢复后，自动切换为主节点。

二、分片集群（Sharded Cluster）分片集群是MongoDB的横向扩展方案，用于处理大量数据和高并发访问的场景。

分片集群由多个分片（Shard）组成，每个分片存储一部分数据。

客户端将数据按照一定的规则分发到各个分片中进行存储和查询。

在分片集群中，还需要使用一个配置服务器（Config Server）来存储分片集群的元数据信息，如分片映射规则等。

配置服务器的高可用性也是非常重要的，通常采用多副本部署，保证数据的可靠性和一致性。

三、副本集和分片集群的结合应用在实际的应用场景中，可以将副本集和分片集群结合起来使用，从而实现高可用和横向扩展的双重优势。

通常将每个分片部署为一个副本集，每个副本集包含一个主节点和多个从节点。

这样既保证了每个分片的高可用性，又实现了分片集群的横向扩展能力。

在这种方案中，主节点对外提供读写操作，从节点负责数据备份和读操作的负载均衡。

当某个分片的主节点发生故障时，从节点会自动发起选举，选举出新的主节点。

同时，其他分片仍然可以正常工作，确保了整个分片集群的高可用性。

linux mongodb基本操作MongoDB一个基于分布式文件存储的开源数据库系统，可以在Linux操作系统上运行。

MongoDB可以使用集群、多服务器架构和复制集处理任何规模的数据，并支持多种编程语言。

它可以在多种系统上，用于构建可靠的、可扩展的和高性能的应用程序。

本文将介绍MongoDB在Linux操作系统中的安装、配置和基本操作。

一、安装1.装软件包要在Linux系统上安装MongoDB，首先需要下载MongoDB软件包。

您可以从官方网站上下载最新版本的MongoDB，然后使用工具安装它（例如RPM、Yum或Apt-get）。

2.动服务安装完成后，您可以使用MongoDB命令行界面或MongoDB服务器管理控制台启动MongoDB服务。

一旦MongoDB服务启动，就可以开始对MongoDB进行基本操作了。

二、配置1.建数据库安装完成后，您可以在 MongoDB务器上创建数据库。

要创建数据库，您需要登录MongoDB服务器，然后使用mongo命令行客户端创建一个新数据库。

2.建用户在创建数据库之后，您需要创建一个用户，以便可以对数据库进行管理操作。

您可以使用createUser命令创建一个新用户，并给予其相应的访问权限。

三、基本操作1.本命令MongoDB为每个集合提供了多种基本操作，可以帮助用户完成各种操作。

例如，您可以使用find命令查找所需的记录，使用update 命令更新记录，使用delete命令删除记录，使用insert命令插入记录，使用aggregate命令汇总集合数据，等等。

2.合函数MongoDB提供了多种内置的内置函数，可以用来对集合中的数据进行分析和处理。

主要的聚合函数有sum，count，avg，max，min和group。

您可以根据实际需要使用这些函数进行数据分析和处理。

3.询语言MongoDB还提供了强大的查询语言，支持多种查询操作，可以方便地从集合中检索数据。

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()”命令在路由服务器上检查分片集群的状态。

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

MongoDB分布式集群架构（3种模式）Sharding 模式追求的是⾼性能，⽽且是三种集群中最复杂的。

在实际⽣产环境中，通常将 Replica Set 和 Sharding 两种技术结合使⽤。

主从复制虽然 MongoDB 官⽅建议⽤副本集替代主从复制，但是本节还是从主从复制⼊⼿，让⼤家了解 MongoDB 的复制机制。

主从复制是 MongoDB 中最简单的数据库同步备份的集群技术，其基本的设置⽅式是建⽴⼀个主节点（Primary）和⼀个或多个从节点（Secondary），如下图所⽰。

这种⽅式⽐单节点的可⽤性好很多，可⽤于备份、故障恢复、读扩展等。

集群中的主从节点均运⾏ MongoDB 实例，完成数据的存储、查询与修改操作。

主从复制模式的集群中只能有⼀个主节点，主节点提供所有的增、删、查、改服务，从节点不提供任何服务，但是可以通过设置使从节点提供查询服务，这样可以减少主节点的压⼒。

另外，每个从节点要知道主节点的地址，主节点记录在其上的所有操作，从节点定期轮询主节点获取这些操作，然后对⾃⼰的数据副本执⾏这些操作，从⽽保证从节点的数据与主节点⼀致。

在主从复制的集群中，当主节点出现故障时，只能⼈⼯介⼊，指定新的主节点，从节点不会⾃动升级为主节点。

同时，在这段时间内，该集群架构只能处于只读状态。

副本集副本集的集群架构如下图所⽰。

此集群拥有⼀个主节点和多个从节点，这⼀点与主从复制模式类似，且主从节点所负责的⼯作也类似，但是副本集与主从复制的区别在于：当集群中主节点发⽣故障时，副本集可以⾃动投票，选举出新的主节点，并引导其余的从节点连接新的主节点，⽽且这个过程对应⽤是透明的。

可以说，MongoDB 的副本集是⾃带故障转移功能的主从复制。

MongoDB 副本集使⽤的是 N 个 mongod 节点构建的具备⾃动容错功能、⾃动恢复功能的⾼可⽤⽅案。

在副本集中，任何节点都可作为主节点，但为了维持数据⼀致性，只能有⼀个主节点。

MongoDB分布式高可用集群一、分布式集群搭建方案运用MongoDB的复制集（Replica Sets）+分片（Sharding）就能实现MongoDB分布式高可用的集群。

分片（sharding）能够增加更多的机器来应对不断增加的负载和数据，也不影响应用。

复制集（Replica Sets）能确保每个分片节点都具有自动备份、自动故障恢复能力。

二、MongoDB的高可用集群配置高可用集群，即High Availability Cluster，简称HA Cluster。

集群（cluster）就是一组计算机，它们作为一个整体向用户提供一组网络资源。

这些单个的计算机系统就是集群的节点（node）。

搭建高可用集群需要合理的配置多台计算机之间的角色，数据恢复，一致性等，主要有以下几种方式：（1）、主从方式（2）、双机双工方式（3）、集群工作方式（多服务器互备方式）MongoDB集群配置的实践也遵循了这几个方案，主要有主从结构，副本集方式和Sharding分片方式。

三、Master-Slave主从结构主从架构一般用于备份或者读写分离，一般有一主一从和一主多从设计。

由两种角色构成：（1）、Master可读可写，当数据有修改的时候，会将oplog同步到所有Slave上。

（2）、Slave只读不可写，自动从Master同步数据。

特别的，对于Mongodb来说，并不推荐使用Master-Slave架构，因为Master-Slave其中Master宕机后不能自动恢复，除非Replica的节点数超过50，才需要使用Master-Slave架构，正常情况是不可能用那么多节点的。

还有一点，Master-Slave不支持链式结构，Slave只能直接连接Master。

Redis的Master-Slave支持链式结构，Slave可以连接Slave，成为Slave的Slave。

四、Relica Set副本集方式Mongodb的Replica Set即副本集方式主要有两个目的，一个是数据冗余做故障恢复使用，当发生硬件故障或者其它原因造成的宕机时，可以使用副本进行恢复。

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 中,有两种数据冗余⽅式,⼀种是 Master-Slave 模式（主从复制）,⼀种是 Replica Sets 模式（副本集）。

12 3 4 5 6 7 8 9 10 11 12 13Mongodb⼀共有三种集群搭建的⽅式：Replica Set（副本集）、Sharding（切⽚）Master-Slaver（主从）【⽬前已不推荐使⽤了】其中，Sharding集群也是三种集群中最复杂的。

副本集⽐起主从可以实现故障转移！！⾮常使⽤！mongoDB⽬前已不推荐使⽤主从模式，取⽽代之的是副本集模式。

副本集其实⼀种互为主从的关系，可理解为主主。

副本集指将数据复制，多份保存，不同服务器保存同⼀份数据，在出现故障时⾃动切换。

对应的是数据冗余、备份、镜像、读写分离、⾼可⽤性等关键词；⽽分⽚则指为处理⼤量数据，将数据分开存储，不同服务器保存不同的数据，它们的数据总和即为整个数据集。

追求的是⾼性能。

在⽣产环境中，通常是这两种技术结合使⽤，分⽚+副本集。

⼀、先说说mongodb主从复制配置主从复制是最常⽤的复制⽅式,也是⼀个简单的同步备份的集群技术,这种⽅式很灵活.可⽤于备份,故障恢复,读扩展等.最基本的设置⽅式就是建⽴⼀个主节点和⼀个或多个从节点,每个从节点要知道主节点的地址。

采⽤双机备份后主节点挂掉了后从节点可以接替主机继续服务。

所以这种模式⽐单节点的⾼可⽤性要好很多。

配置主从复制的注意点1 2 31）在数据库集群中要明确的知道谁是主服务器,主服务器只有⼀台. 2）从服务器要知道⾃⼰的数据源也就是对应的主服务是谁.3）--master⽤来确定主服务器,--slave 和 --source来控制从服务器可以在mongodb.conf配置⽂件⾥指明主从关系，这样启动mongodb的时候只要跟上配置⽂件就⾏，就不需要通过--master和--slave来指明主从了。

实现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个路由服务与之交互，配置服务和分⽚服务对客户端是透明的。

MongoDB分布式部署之分片配置【学习笔记】MongoDB分布式部署之分片配置2010-04-07 14:27这里介绍的是Mongodb的分片配置，如果想配置主主或主从对，以实现数据备份，可见mongodb分布式之数据复制。

1、启动相关进程在shard server上启动mongod，使用--shardsvr 命令行参数。

对于主从对，使用--pairwith命令行选项。

建议一个shard server只运行一个mongod进程。

在config server上启动mongod，使用--configsvr命令行参数。

如果config server不是一台独立的服务器，为其分配一个独立的dbpath，--dbpath命令行参数。

启动mongos，使用--configdb参数指明配置的数据库地址。

2、shell配置分片在启动好的mongos服务器上运行这些命令，然后通过它运行所有的配置命令。

注：应该使用特定的admin数据库来存储这些命令，尽管通过mongos运行时，数据会存储在config server上，所以在集群的生命周期内这些命令只需运行一次即可。

./mongo <mongos-hostname>:<mongos-port>/admin> dbadmin>3、增加一个分片，每个分片包括两台服务器（一对主从）或单机（Alpha 2只支持单机）。

> db.runCommand( { addshard : "<serverhostname>[:<port>]" } );{"ok" : 1 , "added" : ...}多台配置用逗号分隔（alpha3及以上版本）。

可选参数maxSize可用户设置该分片可使用的磁盘空间，默认为整个磁盘。

该参数目前1.4及1.4以前的版本是无效的，1.5版本及以后才会有效。

mongodb分片集群原理
MongoDB分片集群是一种分布式数据库架构，用于处理大量数据和高负载的应用程序。

其原理主要包括数据分片、分片策略、数据路由和副本集。

具体如下：
1. 数据分片：将数据库中的数据按照特定的规则分散到多个节点上，每个节点被称为一个分片。

分片的规则可以基于范围、散列等策略进行选择。

2. 分片策略：分片策略决定了数据分片的方式。

MongoDB提供了一个默认的范围分片策略，即按照数据范围将数据划分到不同分片上。

用户也可以通过自定义的方式进行数据分片，例如按照散列方式进行分片。

3. 数据路由：MongoDB通过一个路由进程(mongos)进行数据路由，该进程以及客户端只需要知道分片集群的入口点，其会根据分片集群的元数据信息知道哪个分片包含了请求的数据，并将请求路由到对应的分片上。

4. 副本集：每个分片都可以由多个副本组成，以提高高可用性。

副本集的成员有一个主节点和多个从节点，主节点负责写入操作，从节点负责读取操作。

在主节点出现故障的情况下，从节点会自动选举出一个新的主节点，保证分片集群的可用性。

mongodb3.6集群搭建：分⽚+副本集mongodb是最常⽤的nosql数据库，在数据库排名中已经上升到了前六。

这篇⽂章介绍如何搭建⾼可⽤的mongodb（分⽚+副本）集群。

在搭建集群之前，需要⾸先了解⼏个概念：路由，分⽚、副本集、配置服务器等相关概念。

先来看⼀张图：从图中可以看到有四个组件：mongos、config server、shard、replica set。

mongos，数据库集群请求的⼊⼝，所有的请求都通过mongos进⾏协调，不需要在应⽤程序添加⼀个路由选择器，mongos⾃⼰就是⼀个请求分发中⼼，它负责把对应的数据请求请求转发到对应的shard服务器上。

在⽣产环境通常有多mongos作为请求的⼊⼝，防⽌其中⼀个挂掉所有的mongodb请求都没有办法操作。

config server，顾名思义为配置服务器，存储所有数据库元信息（路由、分⽚）的配置。

mongos本⾝没有物理存储分⽚服务器和数据路由信息，只是缓存在内存⾥，配置服务器则实际存储这些数据。

mongos第⼀次启动或者关掉重启就会从 config server 加载配置信息，以后如果配置服务器信息变化会通知到所有的 mongos 更新⾃⼰的状态，这样 mongos 就能继续准确路由。

在⽣产环境通常有多个 config server 配置服务器，因为它存储了分⽚路由的元数据，防⽌数据丢失！shard，分⽚（sharding）是指将数据库拆分，将其分散在不同的机器上的过程。

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

基本思想就是将集合切成⼩块，这些块分散到若⼲⽚⾥，每个⽚只负责总数据的⼀部分，最后通过⼀个均衡器来对各个分⽚进⾏均衡（数据迁移）。

replica set，中⽂翻译副本集，其实就是shard的备份，防⽌shard挂掉之后数据丢失。

复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提⾼了数据的可⽤性，并可以保证数据的安全性。

Mongodb副本集＋分⽚集群环境部署记录前⾯详细介绍了mongodb的副本集和分⽚的原理，这⾥就不赘述了。

下⾯记录Mongodb副本集＋分⽚集群环境部署过程：MongoDB Sharding Cluster，需要三种⾓⾊：Shard Server: mongod 实例，⽤于存储实际的数据块，实际⽣产环境中⼀个shard server⾓⾊可由⼏台机器组个⼀个relica set承担，防⽌主机单点故障Config Server: mongod 实例，存储了整个 Cluster Metadata，其中包括 chunk 信息。

Route Server: mongos 实例，前端路由，客户端由此接⼊，且让整个集群看上去像单⼀数据库，前端应⽤可以透明使⽤。

机器信息：分别在3台机器运⾏⼀个mongod实例（称为mongod shard11，mongod shard12，mongod shard13）组织replica set1，作为cluster的shard1分别在3台机器运⾏⼀个mongod实例（称为mongod shard21，mongod shard22，mongod shard23）组织replica set2，作为cluster的shard2每台机器运⾏⼀个mongod实例，作为3个config server每台机器运⾏⼀个mongos进程，⽤于客户端连接1）安装mongodb (3台机器都要操作)下载地址：https:///s/1hsoVcpQ 提取密码：6zp4[root@slave1 src]# cd[root@slave1 ~]# cd /usr/local/src/[root@slave1 src]# ll mongodb-linux-x86_64-rhel62-3.0.6.tgz[root@slave1 src]# tar -zvxf mongodb-linux-x86_64-rhel62-3.0.6.tgz[root@slave1 src]# mv mongodb-linux-x86_64-rhel62-3.0.6 mongodb2)创建sharding数据⽬录根据本例sharding架构图所⽰，在各台sever上创建shard数据⽂件⽬录slave1[root@slave1 src]# mkdir /home/services/[root@slave1 src]# mv mongodb /home/services/[root@slave1 src]# cd /home/services/mongodb/[root@slave1 mongodb]# mkdir -p data/shard11[root@slave1 mongodb]# mkdir -p data/shard21slave2[root@slave2 src]# mkdir /home/services/[root@slave2 src]# mv mongodb /home/services/[root@slave2 src]# cd /home/services/mongodb/[root@slave2 mongodb]# mkdir -p data/shard12[root@slave2 mongodb]# mkdir -p data/shard22slave3[root@slave3 src]# mkdir /home/services/[root@slave3 src]# mv mongodb /home/services/[root@slave3 src]# cd /home/services/mongodb/[root@slave3 mongodb]# mkdir -p data/shard13[root@slave3 mongodb]# mkdir -p data/shard233）配置relica sets3.1）配置shard1所⽤到的replica sets 1:slave1[root@slave1 ~]# /home/services/mongodb/bin/mongod --shardsvr --replSet shard1 --port 27018 --dbpath /home/services/mongodb/data/shard11 --oplogSize 100 --logpath /home/services/mongodb/data/shard11.log --logappend --fork slave2[root@slave2 ~]# /home/services/mongodb/bin/mongod --shardsvr --replSet shard1 --port 27018 --dbpath /home/services/mongodb/data/shard12 --oplogSize 100 --logpath /home/services/mongodb/data/shard12.log --logappend --fork slave3[root@slave3 ~]# /home/services/mongodb/bin/mongod --shardsvr --replSet shard1 --port 27018 --dbpath /home/services/mongodb/data/shard13 --oplogSize 100 --logpath /home/services/mongodb/data/shard13.log --logappend --fork 检车各个机器上的mongod进程是否正常起来了（ps -ef|grep mongod），27018端⼝是否正常起来了3.2）初始化replica set 1从3台机器中任意找⼀台，连接mongod[root@slave1 ~]# /home/services/mongodb/bin/mongo --port 27018......> config = {"_id" : "shard1","members" : [{"_id" : 0,"host" : "182.48.115.236:27018"},{"_id" : 1,"host" : "182.48.115.237:27018"},{"_id" : 2,"host" : "182.48.115.238:27018"}]}{"_id" : "shard1","members" : [{"_id" : 0,"host" : "182.48.115.236:27018"},{"_id" : 1,"host" : "182.48.115.237:27018"},{"_id" : 2,"host" : "182.48.115.238:27018"}]}> rs.initiate(config);{ "ok" : 1 }3.3）配置shard2所⽤到的replica sets 2:slave1[root@slave1 ~]# /home/services/mongodb//bin/mongod --shardsvr --replSet shard2 --port 27019 --dbpath /home/services/mongodb/data/shard21 --oplogSize 100 --logpath /home/services/mongodb/data/shard21.log --logappend --fork slave2[root@slave2 ~]# /home/services/mongodb//bin/mongod --shardsvr --replSet shard2 --port 27019 --dbpath /home/services/mongodb/data/shard22 --oplogSize 100 --logpath /home/services/mongodb/data/shard22.log --logappend --fork slave3[root@slave3 ~]# /home/services/mongodb//bin/mongod --shardsvr --replSet shard2 --port 27019 --dbpath /home/services/mongodb/data/shard23 --oplogSize 100 --logpath /home/services/mongodb/data/shard23.log --logappend --fork 3.4）初始化replica set 2从3台机器中任意找⼀台，连接mongod[root@slave1 ~]# /home/services/mongodb/bin/mongo --port 27019......> config = {"_id" : "shard2","members" : [{"_id" : 0,"host" : "182.48.115.236:27019"},{"_id" : 1,"host" : "182.48.115.237:27019"},{"_id" : 2,"host" : "182.48.115.238:27019"}]}{"_id" : "shard2","members" : [{"_id" : 0,"host" : "182.48.115.236:27019"},{"_id" : 1,"host" : "182.48.115.237:27019"},{"_id" : 2,"host" : "182.48.115.238:27019"}]}> rs.initiate(config);{ "ok" : 1 }4）配置三台config serverslave1[root@slave1 ~]# mkdir -p /home/services/mongodb/data/config[root@slave1 ~]# /home/services/mongodb//bin/mongod --configsvr --dbpath /home/services/mongodb/data/config --port 20000 --logpath /home/services/mongodb/data/config.log --logappend --forkslave2[root@slave2 ~]# mkdir -p /home/services/mongodb/data/config[root@slave2 ~]# /home/services/mongodb//bin/mongod --configsvr --dbpath /home/services/mongodb/data/config --port 20000 --logpath /home/services/mongodb/data/config.log --logappend --forkslave3[root@slave3 ~]# mkdir -p /home/services/mongodb/data/config[root@slave3 ~]# /home/services/mongodb//bin/mongod --configsvr --dbpath /home/services/mongodb/data/config --port 20000 --logpath /home/services/mongodb/data/config.log --logappend --fork5）配置mongs在三台机器上分别执⾏：slave1[root@slave1 ~]# /home/services/mongodb/bin/mongos --configdb 182.48.115.236:20000,182.48.115.237:20000,182.48.115.238:20000 --port 27017 --chunkSize 5 --logpath /home/services/mongodb/data/mongos.log --logappend --fork slave2[root@slave2 ~]# /home/services/mongodb/bin/mongos --configdb 182.48.115.236:20000,182.48.115.237:20000,182.48.115.238:20000 --port 27017 --chunkSize 5 --logpath /home/services/mongodb/data/mongos.log --logappend --fork slave3[root@slave3 ~]# /home/services/mongodb/bin/mongos --configdb 182.48.115.236:20000,182.48.115.237:20000,182.48.115.238:20000 --port 27017 --chunkSize 5 --logpath /home/services/mongodb/data/mongos.log --logappend --fork 注意：新版版的mongodb的mongos命令⾥就不识别--chunkSize参数了6）配置分⽚集群（Configuring the Shard Cluster）从3台机器中任意找⼀台，连接mongod，并切换到admin数据库做以下配置6.1）连接到mongs，并切换到admin[root@slave1 ~]# /home/services/mongodb/bin/mongo 182.48.115.236:27017/admin......mongos> dbadminmongos>6.2）加⼊shards分区如⾥shard是单台服务器，⽤"db.runCommand( { addshard : “[:]” } )"这样的命令加⼊如果shard是replica sets，⽤"replicaSetName/[:port][,serverhostname2[:port],…]"这样的格式表⽰，例如本例执⾏：mongos> db.runCommand( { addshard:"shard1/182.48.115.236:27018,182.48.115.237:27018,182.48.115.238:27018",name:"s1",maxsize:20480});{ "shardAdded" : "s1", "ok" : 1 }mongos> db.runCommand( { addshard:"shard2/182.48.115.236:27019,182.48.115.237:27019,182.48.115.238:27019",name:"s2",maxsize:20480});{ "shardAdded" : "s2", "ok" : 1 }注意：可选参数Name:⽤于指定每个shard的名字，不指定的话系统将⾃动分配maxSize:指定各个shard可使⽤的最⼤磁盘空间，单位megabytes6.3）Listing shardsmongos> db.runCommand( { listshards : 1 } ){"shards" : [{"_id" : "s1","host" : "shard1/182.48.115.236:27018,182.48.115.237:27018,182.48.115.238:27018"},{"_id" : "s2","host" : "shard2/182.48.115.236:27019,182.48.115.237:27019,182.48.115.238:27019"}],"ok" : 1}mongos>上⾯命令列出了以上⼆个添加的shards，表⽰shards已经配置成功6.4）激活数据库分⽚命令：db.runCommand( { enablesharding : “” } );通过执⾏以上命令，可以让数据库跨shard，如果不执⾏这步，数据库只会存放在⼀个shard，⼀旦激活数据库分⽚，数据库中不同的collection将被存放在不同的shard上，但⼀个collection仍旧存放在同⼀个shard上，要使单个collection也分⽚，还需单独对collection作些操作Collecton分⽚要使单个collection也分⽚存储，需要给collection指定⼀个分⽚key，通过以下命令操作：db.runCommand( { shardcollection : “”,key : });注意：a）分⽚的collection系统会⾃动创建⼀个索引（也可⽤户提前创建好）b）分⽚的collection只能有⼀个在分⽚key上的唯⼀索引，其它唯⼀索引不被允许本案例：mongos> db.runCommand({enablesharding:"test2"});{ "ok" : 1 }mongos> db.runCommand( { shardcollection : "test2.books", key : { id : 1 } } );{ "collectionsharded" : "test2.books", "ok" : 1 }mongos> use test2switched to db test2mongos> db.stats();{"raw" : {"shard1/182.48.115.236:27018,182.48.115.237:27018,182.48.115.238:27018" : {"db" : "test2","collections" : 3,"objects" : 6,"avgObjSize" : 69.33333333333333,"dataSize" : 416,"storageSize" : 20480,"numExtents" : 3,"indexes" : 2,"indexSize" : 16352,"fileSize" : 67108864,"nsSizeMB" : 16,"extentFreeList" : {"num" : 0,"totalSize" : 0},"dataFileVersion" : {"major" : 4,"minor" : 22},"ok" : 1,"$gleStats" : {"lastOpTime" : Timestamp(0, 0),"electionId" : ObjectId("586286596422d63aa9f9f000")}},"shard2/182.48.115.236:27019,182.48.115.237:27019,182.48.115.238:27019" : {"db" : "test2","collections" : 0,"objects" : 0,"avgObjSize" : 0,"dataSize" : 0,"storageSize" : 0,"numExtents" : 0,"indexes" : 0,"indexSize" : 0,"fileSize" : 0,"ok" : 1}},"objects" : 6,"avgObjSize" : 69,"dataSize" : 416,"storageSize" : 20480,"numExtents" : 3,"indexes" : 2,"indexSize" : 16352,"fileSize" : 67108864,"extentFreeList" : {"num" : 0,"totalSize" : 0},"ok" : 1}mongos> db.books.stats();{"sharded" : true,"paddingFactorNote" : "paddingFactor is unused and unmaintained in 3.0. It remains hard coded to 1.0 for c ompatibility only.","userFlags" : 1,"capped" : false,"ns" : "test2.books","count" : 0,"numExtents" : 1,"size" : 0,"storageSize" : 8192,"totalIndexSize" : 16352,"indexSizes" : {"_id_" : 8176,"id_1" : 8176},"avgObjSize" : 0,"nindexes" : 2,"nchunks" : 1,"shards" : {"s1" : {"ns" : "test2.books","count" : 0,"size" : 0,"numExtents" : 1,"storageSize" : 8192,"lastExtentSize" : 8192,"paddingFactor" : 1,"paddingFactorNote" : "paddingFactor is unused and unmaintained in 3.0. It remains hard co ded to 1.0 for compatibility only.", "userFlags" : 1,"capped" : false,"nindexes" : 2,"totalIndexSize" : 16352,"indexSizes" : {"_id_" : 8176,"id_1" : 8176},"ok" : 1,"$gleStats" : {"lastOpTime" : Timestamp(0, 0),"electionId" : ObjectId("586286596422d63aa9f9f000")}}},"ok" : 1}7）测试mongos> for (var i = 1; i <= 20000; i++) db.books.save({id:i,name:"12345678",sex:"male",age:27,value:"test"});WriteResult({ "nInserted" : 1 })mongos> db.books.stats();{"sharded" : true,"paddingFactorNote" : "paddingFactor is unused and unmaintained in 3.0. It remains hard coded to 1.0 for compatibility only.","userFlags" : 1,"capped" : false,"ns" : "test2.books","count" : 20000,"numExtents" : 10,"size" : 2240000,"storageSize" : 5586944,"totalIndexSize" : 1250928,"indexSizes" : {"_id_" : 670432,"id_1" : 580496},"avgObjSize" : 112,"nindexes" : 2,"nchunks" : 5,"shards" : {"s1" : {"ns" : "test2.books","count" : 12300,"size" : 1377600,"avgObjSize" : 112,"numExtents" : 5,"storageSize" : 2793472,"lastExtentSize" : 2097152,"paddingFactor" : 1,"paddingFactorNote" : "paddingFactor is unused and unmaintained in 3.0. It remains hard coded to 1.0 for compatibility only.", "userFlags" : 1,"capped" : false,"nindexes" : 2,"totalIndexSize" : 760368,"indexSizes" : {"_id_" : 408800,"id_1" : 351568},"ok" : 1,"$gleStats" : {"lastOpTime" : Timestamp(0, 0),"electionId" : ObjectId("586286596422d63aa9f9f000")}},"s2" : {"ns" : "test2.books","count" : 7700,"size" : 862400,"avgObjSize" : 112,"numExtents" : 5,"storageSize" : 2793472,"lastExtentSize" : 2097152,"paddingFactor" : 1,"paddingFactorNote" : "paddingFactor is unused and unmaintained in 3.0. It remains hard coded to 1.0 for compatibility only.", "userFlags" : 1,"capped" : false,"nindexes" : 2,"totalIndexSize" : 490560,"indexSizes" : {"_id_" : 261632,"id_1" : 228928},"ok" : 1,"$gleStats" : {"lastOpTime" : Timestamp(0, 0),"electionId" : ObjectId("58628704f916bb05014c5ea7")}}},"ok" : 1}。

mongodb分布式集群搭建⼿记⼀、架构简介⽬标单机搭建mongodb分布式集群(副本集 + 分⽚集群)，演⽰mongodb分布式集群的安装部署、简单操作。

说明在同⼀个vm启动由两个分⽚组成的分布式集群，每个分⽚都是⼀个PSS(Primary-Secondary-Secondary)模式的数据副本集；Config副本集采⽤PSS(Primary-Secondary-Secondary)模式。

⼆、配置说明端⼝通讯当前集群中存在shard、config、mongos共12个进程节点，端⼝矩阵编排如下：|编号|实例类型|监听端⼝||-|-||1|mongos|25001||2|mongos|25002||3|mongos|25003||4|config|26001||5|config|26002||6|config|26003||7|shard1|27001||8|shard1|27002||9|shard1|27003||10|shard2|27004||11|shard2|27005||12|shard2|27006|内部鉴权节点间鉴权采⽤keyfile⽅式实现鉴权，mongos与分⽚之间、副本集节点之间共享同⼀套keyfile⽂件。

账户设置管理员账户：admin/Admin@01，具有集群及所有库的管理权限应⽤账号：appuser/AppUser@01，具有appdb的owner权限关于初始化权限keyfile⽅式默认会开启鉴权，⽽针对初始化安装的场景，Mongodb提供了，可以在⾸次安装时通过本机创建⽤户、⾓⾊，以及副本集初始操作。

三、准备⼯作1. 下载安装包wget https:///linux/mongodb-linux-x86_64-rhel70-3.6.3.tgz2. 部署⽬录解压压缩⽂件，将bin⽬录拷贝到⽬标路径/opt/local/mongo-cluster，参考以下命令：tar -xzvf mongodb-linux-x86_64-rhel70-3.6.3.tgzmkdir -p /opt/local/mongo-clustercp -r mongodb-linux-x86_64-rhel70-3.6.3/bin /opt/local/mongo-cluster3. 创建配置⽂件cd /opt/local/mongo-clustermkdir confA. mongod 配置⽂件 mongo_node.confmongo_node.conf 作为mongod实例共享的配置⽂件，内容如下：storage:engine: wiredTigerdirectoryPerDB: truejournal:enabled: truesystemLog:destination: filelogAppend: trueoperationProfiling:slowOpThresholdMs: 10000replication:oplogSizeMB: 10240processManagement:fork: truenet:http:enabled: falsesecurity:authorization: "enabled"选项说明可B. mongos 配置⽂件 mongos.confsystemLog:destination: filelogAppend: trueprocessManagement:fork: truenet:http:enabled: false4. 创建keyfile⽂件cd /opt/local/mongo-clustermkdir keyfileopenssl rand -base64 756 > mongo.keychmod 400 mongo.keymv mongo.key keyfilemongo.key 采⽤随机算法⽣成，⽤作节点内部通讯的密钥⽂件5. 创建节点⽬录WORK_DIR=/opt/local/mongo-clustermkdir -p $WORK_DIR/nodes/config/n1/datamkdir -p $WORK_DIR/nodes/config/n2/datamkdir -p $WORK_DIR/nodes/config/n3/datamkdir -p $WORK_DIR/nodes/shard1/n1/datamkdir -p $WORK_DIR/nodes/shard1/n2/datamkdir -p $WORK_DIR/nodes/shard1/n3/datamkdir -p $WORK_DIR/nodes/shard2/n1/datamkdir -p $WORK_DIR/nodes/shard2/n2/datamkdir -p $WORK_DIR/nodes/shard2/n3/datamkdir -p $WORK_DIR/nodes/mongos/n1mkdir -p $WORK_DIR/nodes/mongos/n2mkdir -p $WORK_DIR/nodes/mongos/n3以config 节点1 为例，nodes/config/n1/data是数据⽬录，⽽pid⽂件、⽇志⽂件都存放于n1⽬录以mongos 节点1 为例，nodes/mongos/n1 存放了pid⽂件和⽇志⽂件四、搭建集群1. Config副本集按以下脚本启动3个Config实例WORK_DIR=/opt/local/mongo-clusterKEYFILE=$WORK_DIR/keyfile/mongo.keyCONFFILE=$WORK_DIR/conf/mongo_node.confMONGOD=$WORK_DIR/bin/mongod$MONGOD --port 26001 --configsvr --replSet configReplSet --keyFile $KEYFILE --dbpath $WORK_DIR/nodes/config/n1/data --pidfilepath $WORK_DIR/nodes/config/n1/db.pid --logpath $WORK_DIR/nodes/config/n1/db.log --config $CONFFILE $MONGOD --port 26002 --configsvr --replSet configReplSet --keyFile $KEYFILE --dbpath $WORK_DIR/nodes/config/n2/data --pidfilepath $WORK_DIR/nodes/config/n2/db.pid --logpath $WORK_DIR/nodes/config/n2/db.log --config $CONFFILE $MONGOD --port 26003 --configsvr --replSet configReplSet --keyFile $KEYFILE --dbpath $WORK_DIR/nodes/config/n3/data --pidfilepath $WORK_DIR/nodes/config/n3/db.pid --logpath $WORK_DIR/nodes/config/n3/db.log --config $CONFFILE 待成功启动后，输出⽇志如下：about to fork child process, waiting until server is ready for connections.forked process: 4976child process started successfully, parent exiting此时通过ps 命令也可以看到3个启动的进程实例。

mongodb安装--linux--集群注：因为服务器紧张，所以这里我的集群服务是安装在一个服务器上的，通过多端口部署多服务1、下载mongodb的linux安装包/downloads我下载的是mongodb-linux-x86_64-2.6.4.tgz2、mongodb集群介绍（摘录：/luonanqin/article/details/8497860）注：上面链接的教程，在启动mongodb时和replset配置时，有文档，始终不成功，不怎么是什么原因，后来换了一种启动方式Mongodb(master)表示主节点，Mongodb(slaver)表示备节点，Mongodb(arbiter)表示仲裁节点。

主备节点存储数据，仲裁节点不存储数据。

客户端同时连接主节点与备节点，不连接仲裁节点。

默认设置下，主节点提供所有增删查改服务，备节点不提供任何服务。

但是可以通过设置使备节点提供查询服务，这样就可以减少主节点的压力，当客户端进行数据查询时，请求自动转到备节点上。

这个设置叫做Read Preference Modes，同时Java 客户端提供了简单的配置方式，可以不必直接对数据库进行操作。

仲裁节点是一种特殊的节点，它本身并不存储数据，主要的作用是决定哪一个备节点在主节点挂掉之后提升为主节点，所以客户端不需要连接此节点。

这里虽然只有一个备节点，但是仍然需要一个仲裁节点来提升备节点级别。

我开始也不相信必须要有仲裁节点，但是自己也试过没仲裁节点的话，主节点挂了备节点还是备节点，所以咱们还是需要它的。

介绍完了集群方案，那么现在就开始搭建了。

3、建立数据文件夹我在199服务器的mongodb账户的home目录下，创建了一个“mongodata”目录，然后再mongodata 目录创建各个节点的目录—— arbiter master slaver创建mongodb数据目录[mongodb@trekizdell ~]$ mkdir -p mongodata[mongodb@trekizdell ~]$ cd mongodata/[mongodb@trekizdell mongodata]$ mkdir -p master[mongodb@trekizdell mongodata]$ mkdir -p slaver[mongodb@trekizdell mongodata]$ mkdir -p arbiter4、解压mongodb软件包，并重命名到各个节点的安装目录我在199服务器的mongodb账户的home目录下，各个节点的安装目录—— mongodbarbiter mongodbmaster mongodbslaver创建mongodb数据目录[mongodb@trekizdell ~]$ tar -zxvf mongodb-linux-x86_64-2.6.4.tgz[mongodb@trekizdell ~]$ mv mongodb-linux-x86_64-2.6.4/ mongodbmaster[mongodb@trekizdell ~]$ tar -zxvf mongodb-linux-x86_64-2.6.4.tgz[mongodb@trekizdell ~]$ mv mongodb-linux-x86_64-2.6.4/ mongodbslaver[mongodb@trekizdell ~]$ mv mongodb-linux-x86_64-2.6.4/ mongodbarbiter[mongodb@trekizdell ~]$ lsmongodata mongodbarbiter mongodb-linux-x86_64-2.6.4.tgz mongodbmaster mongodbslaver5、给各个节点创建日志目录文件(下面命令以master节点为例)注：我原本以为目录创建好了就行了，不需要创建日志文件，后来启动发现报错了，说找不到日志文件，所以还是需要手动创建日志文件创建日志目录[mongodb@trekizdell ~]$ cd mongodbmaster/[mongodb@trekizdell mongodbmaster]$ mkdir -p logs[mongodb@trekizdell mongodbmaster]$ lsbin GNU-AGPL-3.0 logs README THIRD-PARTY-NOTICES[mongodb@trekizdell mongodbmaster]$ cd logs[mongodb@trekizdell mongodbmaster]$ touch master.log6、给各个节点创建存储进程id的目录文件(下面命令以master节点为例)注：我原本以为目录创建好了就行了，不需要pid文件，后来启动发现报错了，说找不到日志文件，所以还是需要手动创建pid文件（就是一个空文本）创建日志目录[mongodb@trekizdell ~]$ cd mongodbmaster/[mongodb@trekizdell mongodbmaster]$ mkdir -p workpid[mongodb@trekizdell mongodbmaster]$ lsbin GNU-AGPL-3.0 logs README THIRD-PARTY-NOTICES workpid[mongodb@trekizdell mongodbmaster]$ cd workpid[mongodb@trekizdell mongodbmaster]$ touch pid7、依次启动 master slaver arbiter各个节点（下面命令以master节点为主例）创建日志目录[mongodb@trekizdell ~]$ cd mongodbmaster/[mongodb@trekizdell mongodbmaster]$ cd bin[mongodb@trekizdell mongodbmaster]$ ./mongod --replSet trekizlogs --port 27017 --dbpath /home/mongodb/mongodata/master --logpath/home/mongodb/mongodbmaster/logs/master.log --pidfilepath/home/mongodb/mongodbmaster/workpid/pid --logappend --fork --rest启动命令依次是：./mongod --replSet trekizlogs --port 27017 --dbpath/home/mongodb/mongodata/master --logpath/home/mongodb/mongodbmaster/logs/master.log --pidfilepath/home/mongodb/mongodbmaster/workpid/pid --logappend --fork --rest./mongod --replSet trekizlogs --port 27018 --dbpath/home/mongodb/mongodata/slaver --logpath/home/mongodb/mongodbslaver/logs/slaver.log --pidfilepath/home/mongodb/mongodbslaver/workpid/pid --logappend --fork --rest./mongod --replSet trekizlogs --port 27028 --dbpath/home/mongodb/mongodata/arbiter --logpath/home/mongodb/mongodbarbiter/logs/arbiter.log --pidfilepath/home/mongodb/mongodbarbiter/workpid/pid --logappend --fork --rest其中一些参数说明：dbpath：数据存放目录logpath：日志存放路径pidfilepath：进程文件，方便停止mongodbdirectoryperdb：为每一个数据库按照数据库名建立文件夹存放logappend：以追加的方式记录日志replSet：replica set的名字bind_ip：mongodb所绑定的ip地址port：mongodb进程所使用的端口号，默认为27017oplogSize：mongodb操作日志文件的最大大小。