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

合集下载

生产MongoDB 分片与集群方案

生产MongoDB 分片与集群方案

生产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集群配置

Mongodb集群配置

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 分片是一种用于处理大量数据的横向扩展方法,允许将数据分布到多个服务器上。

分片可以在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分片集群部署

17 replSetName: shard3
18 sharding: 19 clusterRole: shardsvr
20
8. 启动三台服务器的shard3 server(三台都要启动)
1 shell> numactl ‐‐interleave=all mongod ‐f /opt/mongodb/conf/shard3.conf
8 dbPath: /opt/mongodb/data/shard2 9 journal:
10
enabled: true
11 processManagement:
12 fork: true 13 net:
14 port: 29018 15 bindIp: "0.0.0.0"
16 replication:
2.配置数据目录和日志目录(三台机器都需要配置)
1 shell> cd /opt/mongodb 2 shell> mkdir ‐pv {conf,log,data/configsvr,data/shard1,data/shard2,,data/s hard3}
3. 配置环境变量(三台机器都需要配置)
17 replSetName: shard2
18 sharding: 19 clusterRole: shardsvr
20
5. 启动三台服务器的shard1 server(三台都要启动)
1 shell> numactl ‐‐interleave=all mongod ‐f /opt/mongodb/conf/shard2.conf
2 about to fork child process, waiting until server is ready for connection s.

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分片规则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 高可用方案MongoDB高可用方案MongoDB是一款开源的NoSQL数据库,因其灵活的数据模型和强大的横向扩展能力而备受欢迎。

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

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

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

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

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

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

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

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

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

分片集群由多个分片(Shard)组成,每个分片存储一部分数据。

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

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

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

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

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

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

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

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

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

linux mongodb基本操作

linux mongodb基本操作

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提供了分片集群的功能。

分片集群可以将一个巨大的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种模式)

MongoDB分布式集群架构(3种模式)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MongoDB分布式高可用集群

MongoDB分布式高可用集群

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集群搭建:分片+副本集

linux下Mongodb集群搭建:分片+副本集

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的安装使⽤,在 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的复制集与分片

实现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分布式部署之分片配置

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分片集群原理

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

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

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

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

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

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

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

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

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

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

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

mongodb3.6集群搭建:分片+副本集

mongodb3.6集群搭建:分片+副本集

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的副本集和分⽚的原理,这⾥就不赘述了。

下⾯记录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分布式集群搭建⼿记⼀、架构简介⽬标单机搭建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--集群

mongodb安装--linux--集群

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操作日志文件的最大大小。

相关主题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Sharding cluster介绍这是一种可以水平扩展的模式,在数据量很大时特给力,实际大规模应用一般会采用这种架构去构建monodb系统。

要构建一个MongoDBSharding Cluster,需要三种角色:Shard Server: mongod实例,用于存储实际的数据块,实际生产环境中一个shard server角色可由几台机器组个一个replica set承担,防止主机单点故障Config Server: mongod实例,存储了整个Cluster Metadata,其中包括chunk 信息。

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

机器分配和配置本例架构示例图:1.分别在3台机器运行一个mongod实例(称为mongod shard11,m ongod shard12,mongod shard13)组织replica set1,作为cluster的shard12.分别在3台机器运行一个mongod实例(称为mongod shard21,m ongod shard22,mongod shard23)组织replica set2,作为cluster的shard23.每台机器运行一个mongod实例,作为3个config server4.每台机器运行一个mongs进程,用于客户端连接软件准备1. 创建用户groupaddmongodbuseradd -gmongodbmongodbpasswdm ongodb (123@)2. 安装monodb软件chown -R mongodb:mongodb /data/ -- 这里需要把安装文件的权限赋给mongodb su – mongodbtar zxvfmongodb-linux-x86_64-1.8.2.tar3. 创建数据目录根据本例sharding架构图所示,在各台sever上创建shard数据文件目录Server1:su – monodbcd /usr/local/server/monodbmkdir–p data/shard11mkdir–p data/shard21touch data/shard11.logtouch data/shard21.logServer2:su – monodbcd /usr/local/server/monodbmkdir datamkdir -p data/shard12mkdir -p data/shard22touch data/shard12.logtouch data/shard22.logServer3:su – monodbcd /usr/local/server/monodbmkdir -p data/shard13mkdir -p data/shard23touch data/shard13.logtouch data/shard23.log配置relica sets1. 配置shard1所用到的replica sets:Server1:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard1 --port 27017 --dbpath/usr/local/server/mongodb/data/shard11 --oplogSize2048--logpath/usr/local/server/mongodb/data/shard11.log --logappend--forkServer2:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard1 --port 27017--dbpath/usr/local/server/mongodb/data/shard12 --oplogSize 2048--logpath /usr/local/server/mongodb/data/shard12.log --logappend--forkServer3:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard1 --port 27017 --dbpath/usr/local/server/mongodb/data/shard13 --oplogSize 2048--logpath/usr/local/server/mongodb/data/shard13.log --logappend--fork初始化replica set用mongo连接其中一个mongod,执行:./bin/mongo --port 27017>config = {_id: 'shard1', members: [{_id: 0, host: '172.16.101.244:27017'},{_id: 1, host: '172.16.101.242:27017'},{_id: 2, host: '172.16.101.241:27017'}]}>rs.initiate(config);同样方法,配置shard2用到的replica sets:server1:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard2 --port 27018 --dbpath/usr/local/server/mongodb/data/shard21 --oplogSize 2048--logpath/usr/local/server/mongodb/data/shard21.log --logappend--forkserver2:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard2 --port 27018 --dbpath/usr/local/server/mongodb/data/shard22 --oplogSize 2048--logpath/usr/local/server/mongodb/data/shard22.log --logappend--forkserver3:cd /usr/local/server/mongodb/bin./bin/mongod--shardsvr--replSet shard2 --port 27018 --dbpath/usr/local/server/mongodb/data/shard23 --oplogSize 2048--logpath/usr/local/server/mongodb/data/shard23.log --logappend--fork初始化replica set用mongo连接其中一个mongod,执行:./bin/mongo --port 27018>config = {_id: 'shard2', members: [{_id: 0, host: '172.16.101.244:27018'},{_id: 1, host: '172.16.101.242:27018'},{_id: 2, host: '172.16.101.241:27018'}]}>rs.initiate(config);到此就配置好了二个replica sets,也就是准备好了二个shards配置三台config serverServer1:cd /usr/local/server/mongodb/mkdir -p data/configtouch data/config.log./bin/mongod--configsvr--dbpath /usr/local/server/mongodb/data/config--port 20000 --logpath /usr/local/server/mongodb/data/config.log --logappend--fork#config server也需要dbpathServer2:cd /usr/local/server/mongodb/mkdir -p /usr/local/server/mongodb/data/configtouch data/config.log./bin/mongod--configsvr--dbpath /usr/local/server/mongodb/data/config--port 20000 --logpath /usr/local/server/mongodb/data/config.log --logappend--forkServer3:cd /usr/local/server/mongodb/mkdir-p /usr/local/server/mongodb/data/configtouch data/config.log./bin/mongod--configsvr--dbpath /usr/local/server/mongodb/data/config--port 20000 --logpath /usr/local/server/mongodb/data/config.log --logappend--fork配置mongs在server1,server2,server3上分别执行:touch data/mongos.log./bin/mongos --configdb172.16.101.244:20000,172.16.101.242:20000,172.16.101.241:20000 --port 30000 --chunkSize64--logpath/usr/local/server/mongodb/data/mongos.log --logappend--fork #mongs不需要dbpathConfiguring the Shard Cluster连接到其中一个mongos进程,并切换到admin数据库做以下配置1. 连接到mongs,并切换到admin./bin/mongo 172.16.101.244:30000/admin>dbAdmin2. 加入shards如里shard是单台服务器,用>db.runCommand( { addshard : “<serverhostnam e>[:<port>]” } )这样的命令加入,如果shard是replica sets,用replicaSetName/<serverhostname>[:port][,serverhostname2[:port],…]这样的格式表示,例如本例执行:>db.runCommand({addshard:"shard1/172.16.101.244:27017,172.16.101.242:27017,172 .16.101.241:27017", name:"s1", maxsize:20480});>db.runCommand({addshard:"shard2/172.16.101.244:27018,172.16.101.242:27018,172 .16.101.241:27018", name:"s2", maxsize:20480});注意:在添加第二个shard时,出现error:test database 已经存在的错误,这里用mongo命令连接到第二个replica set,用db.dropDatabase()命令把test数据库给删除然后就可加入3. 可选参数Name:用于指定每个shard的名字,不指定的话系统将自动分配maxSize:指定各个shard可使用的最大磁盘空间,单位megabytes4. Listing shards>db.runCommand( { listshards : 1 } )如果列出了以上二个你加的shards,表示shards已经配置成功5. 激活数据库分片命令:>db.runCommand({enablesharding : “<dbname>”});通过执行以上命令,可以让数据库跨shard,如果不执行这步,数据库只会存放在一个shard,一旦激活数据库分片,数据库中不同的collection将被存放在不同的shard上,但一个collection仍旧存放在同一个shard上,要使单个collection也分片,还需单独对collection作些操作Collecton分片要使单个collection也分片存储,需要给collection指定一个分片key,通过以下命令操作:>db.runCommand( { shardcollection : “<namespace>”,key : <shardkeypatternobject> });db.runCommand({shardcollection: "test.c1", key: {id: 1}}););{ "collectionsharded" : "test.c1", "ok" : 1 }注:a. 分片的collection系统会自动创建一个索引(也可用户提前创建好)b. 分片的collection只能有一个在分片key上的唯一索引,其它唯一索引不被允许One note: a sharded collection can have only one unique inde x, which must exist on the shard key. No other unique indexes can exist on the collection.分片collection例子>db.runCommand({shardcollection: "test.c1", key: {id: 1}}););>for (var i=0; i<=2000000; i++) {db.c1.save({id: i, value1: "1234567890", value2: "1234567890", value3: "1234567890", value4: "1234567890"}); };> db.c1.stats(){“sharded” : true,“ns” : “test.c1″,“count” : 200003,“size” : 25600384,“avgObjSize” : 128,“storageSize” : 44509696,“nindexes” : 2,“nchunks” : 15,“shards” : {“s1″ : {“ns” : “test.c1″,“count” : 141941,“size” : 18168448,“avgObjSize” : 128,“storageSize” : 33327616,“numExtents” : 8,“nindexes” : 2,“lastExtentSize” : 12079360,“paddingFactor” : 1,“flags” : 1,“totalIndexSize” : 11157504,“indexSizes” : {“_id_” : 5898240,“id_1″ : 5259264},“ok” : 1},“s2″ : {“ns” : “test.c1″,“count” : 58062,“size” : 7431936,“avgObjSize” : 128,“storageSize” : 11182080,“numExtents” : 6,“nindexes” : 2,“lastExtentSize” : 8388608,“paddingFactor” : 1,“flags” : 1,“totalIndexSize” : 4579328,“indexSizes” : {“_id_” : 2416640,“id_1″ : 2162688},“ok” : 1}},“ok” : 1}。

相关文档
最新文档