Mongodb集群搭建的三种方式

合集下载

mongodb 集群搭建手册

一、介绍随着互联网和大数据技术的不断发展，数据存储和管理的需求也越来越迫切。

在这样的背景下，NoSQL（Not Only SQL）数据库成为了一个备受关注的技术方向。

MongoDB作为NoSQL数据库中的一员，以其高性能、扩展性强、灵活的数据模型等特点，受到了业界的广泛关注和应用。

在实际应用中，随着数据量的增加，单机部署的MongoDB系统已经无法满足高可用、高并发的需求。

构建MongoDB集群已经成为了一种常见的做法，来保证数据的安全性、可靠性和性能。

本文将从零开始，详细介绍如何搭建一个MongoDB集群环境，以满足大规模数据存储和访问的需求。

在本文中，我们将介绍搭建MongoDB集群的前期准备工作、集群架构的设计、搭建过程中的注意事项以及搭建完成后的验证工作。

希望本文能对需要搭建MongoDB集群的读者提供一些帮助。

二、前期准备1. 硬件准备：在搭建MongoDB集群之前，需要做好硬件的准备工作。

包括选择适当配置的服务器、网络设备、磁盘空间等。

根据实际需要和预算，选择性能和可靠性较好的硬件设备。

2. 软件准备：除了硬件设备以外，还需要准备好操作系统、MongoDB数据库软件等。

选择稳定的操作系统版本，并安装MongoDB数据库软件的最新版本。

3. 网络规划：在搭建MongoDB集群之前，需要进行网络规划，包括IP位置区域的规划、子网划分、网络拓扑结构的设计等。

保证所有节点可以互相通信，并且保证数据在集群内的快速传输。

4. 安全性规划：在搭建MongoDB集群时，要考虑数据的安全性。

建议在搭建集群之前，设置好访问控制、认证授权等安全策略，以确保数据不被未授权的访问。

三、集群架构设计1. 架构选择：MongoDB集群可以采用不同的架构，包括副本集、分片集群等。

在设计集群架构时，需要根据实际需要选择合适的架构。

副本集适用于数据量较小，需要高可用的场景；分片集群适用于数据量较大，需要水平扩展的场景。

mongodb集群部署

mongodb集群部署集群配置最少要开启7个mongodb服务：其中configserver不管有多少个复制集都需要3个，sharding最少要有1个（1个也能进⾏分⽚，⽅便以后扩展；每个sharding都有三个mongodb 服务，⼀个主节点，⼀个从节点，⼀个仲裁节点），mongos最少要有1个（mongos可以有⽆限多个，每个都可以访问到mongodb分⽚数据中）；扩展时，只需要扩展sharding即可。

每个服务器只需要解压⼀个mongodb安装包即可。

启动mongodb服务时，区分不同的端⼝进⾏启动即可。

集群配置最少需要两台物理服务器和⼀台应⽤服务器：其中两台物理服务器分别安装sharding的主节点和从节点，三个configserver可以安装到任意⼀个或多个服务器上；应⽤服务器安装sharding的仲裁节点和路由节点mongos，还可以安装其他应⽤服务；扩展时每次最少要扩展两台物理服务器，每两个物理服务器分别安装sharding的主节点和从节点，仲裁节点放到别的地⽅，加⼊分⽚即可。

配置启动⽂件如下：config server1:# /usr/local/mongodb/conf/mongo-configsvr.confport = 20000 #端⼝只要相同物理机上不重复即可configsvr=true #说明这是configserverlogpath=/ronglian_data/mongo-configsvr/logs/mongo-configsvr.log #⽇志⽂件位置，不能重复logappend=true #⽇志追加fork = true #后台运⾏dbpath=/ronglian_data/mongo-configsvr/db #数据⽂件位置，不能重复keyFile=/usr/local/mongodb/conf/key.cr #mongdb节点之间的认证，内容随意pidfilepath = /var/run/mongod1.pid #存放进⾏ID的⽂件，不能重复config server2:# /usr/local/mongodb/conf/mongo-configsvr.confport = 20001configsvr=truelogpath=/ronglian_data/mongo-configsvr/logs/mongo-configsvr1.loglogappend=truefork = truedbpath=/ronglian_data/mongo-configsvr/db1keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod2.pidconfig server3:# /usr/local/mongodb/conf/mongo-configsvr.confport = 20002configsvr=truelogpath=/ronglian_data/mongo-configsvr/logs/mongo-configsvr2.log logappend=truefork = truedbpath=/ronglian_data/mongo-configsvr/db2keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod3.pidsharding1-1:# /usr/local/mongodb/conf/mongo-shard01.confport = 10000replSet = rs01 #说明是哪个复制集shardsvr=true #说明是复制集服务logpath=/ronglian_data/mongo-shard01/logs/mongo-shard01.log logappend=true fork = truedbpath=/ronglian_data/mongo-shard01/dbkeyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod4.pidsharding1-2:# /usr/local/mongodb/conf/mongo-shard01.confport = 10001replSet = rs01shardsvr=truelogpath=/ronglian_data/mongo-shard01/logs/mongo-shard01-1.log logappend=true fork = truedbpath=/ronglian_data/mongo-shard01/db1keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod5.pidsharding1-3:# /usr/local/mongodb/conf/mongo-shard01.confport = 10002replSet = rs01shardsvr=truelogpath=/ronglian_data/mongo-shard01/logs/mongo-shard01-2.log logappend=true fork = truedbpath=/ronglian_data/mongo-shard01/db2keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod6.pidsharding2-1:# /usr/local/mongodb/conf/mongo-shard02.confport = 10003replSet = rs02 # 复制集标识shardsvr= true # 启动为Shard服务logpath=/ronglian_data/mongo-shard02/logs/mongo-shard02.log logappend=truefork = true # 后台运⾏dbpath=/ronglian_data/mongo-shard02/dbkeyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod7.pidsharding2-2:# /usr/local/mongodb/conf/mongo-shard02.confport = 10004replSet = rs02 # 复制集标识shardsvr= true # 启动为Shard服务logpath=/ronglian_data/mongo-shard02/logs/mongo-shard02-1.log logappend=truefork = true # 后台运⾏dbpath=/ronglian_data/mongo-shard02/db1keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod8.pidsharding2-3:# /usr/local/mongodb/conf/mongo-shard02.confport = 10005replSet = rs02 # 复制集标识shardsvr= true # 启动为Shard服务logpath=/ronglian_data/mongo-shard02/logs/mongo-shard02-2.log logappend=truefork = true # 后台运⾏dbpath=/ronglian_data/mongo-shard02/db2keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongod9.pidmongos1:# /usr/local/mongodb/conf/mongos.confconfigdb=192.168.137.2:20000,192.168.137.2:20001,192.168.137.2:20002 # configserver的地址port = 30000 logpath=/ronglian_data/mongos/logs/mongos.loglogappend=truefork = true # 后台运⾏keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongos10.pidmongos2:# /usr/local/mongodb/conf/mongos.confconfigdb=192.168.137.2:20000,192.168.137.2:20001,192.168.137.2:20002port = 30001logpath=/ronglian_data/mongos/logs/mongos1.loglogappend=truefork = true # 后台运⾏keyFile=/usr/local/mongodb/conf/key.crpidfilepath = /var/run/mongos11.pid启动每个mongodb:configserver:/usr/local/mongodb/bin/mongod –f /usr/local/mongodb/conf/mongo-configsvr.confsharding:/usr/local/mongodb/bin/mongod –f /usr/local/mongodb/conf/mongo-shard01.confmongos:/usr/local/mongodb/bin/mongos –f /usr/local/mongodb/conf/mongos.conf配置复制集成员：> /usr/local/mongodb/bin/mongo -port 10000在mongo终端中输⼊以下命令：>config={_id:'rs01',members:[{_id:0,host:'10.9.47.173:10000'},{_id:1,host:'10.9.47.174:10000'},{_id:2,host:'10.9.47.175:10000',arbiterOnly:true}]}; # 配置参数> rs.initiate(config);#使⽤配置参数初始化Replica Set> rs.status();#查看Replica Set的状态。

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分⽚实战（⼀）：集群搭建环境准备Linux环境主机OS备注192.168.32.13　CentOS6.3 64位　普通PC192.168.71.43　CentOS6.2 64位　服务器，NUMA CPU架构MongoDB版本：mongodb-linux-x86_64-2.4.1，下载地址：.MongoDB安装：分别在两台机器上安装好mongodb 2.4.1，安装路径都为/url/local/mongodb-2.4.1/cd /usr/local/src/wget /linux/mongodb-linux-x86_64-2.4.1.tgztar -zxvf mongodb-linux-x86_64-2.4.1.tgzcp -r mongodb-linux-x86_64-2.4.1 /usr/local/mongodb-2.4.1cd /usr/local/mongodb-2.4.1/bin/ll可以看到mongodb安装成功有如下模块：mongodb启动和关闭等在后⾯集群搭建中有详细说明，在此不再赘述。

Sharding集群搭建Mongodb⼀共有三种集群搭建的⽅式：Replica Set（副本集）、Sharding（切⽚）和Master-Slaver（主从）。

下⾯要搭建的是Sharding，Sharding集群也是三种集群中最复杂的。

配置服务器启动(192.168.32.13:10000)：1. ./bin/mongod --fork --dbpath data/config/ --logpath log/config.log –port 10000路由服务器启动(192.168.32.13:20000)：1. ./bin/mongos --port 20000 --configdb 192.168.32.13:10000 --logpath log/mongos.log --fork注意1：配置--conigdb的时候ip地址不能填localhost或127.0.0.1否则添加分⽚时会返回如下错误信息：1. {2. "ok" : 0,3. "errmsg" : "can't use localhost as a shard since all shards need to communicate. either use all shards and configdbs in localhost or all in actual IPs host: 192.168.71.43:27017 isLocalHost:0"4. }启动分⽚1(192.168.32.13:27019)：1. ./bin/mongod --dbpath data/shard3/ --logpath log/shard3.log --fork --port 27019启动分⽚2(192.168.32.13:27020)：1. ./bin/mongod --dbpath data/shard3/ --logpath log/shard3.log --fork --port 27020启动分⽚3(192.168.71.43:27017)：1. numactl --interleave=all ./bin/mongod --dbpath data/shard1/ --logpath log/shard1.log --fork --port 27017启动分⽚4(192.168.71.43:27018)：1. numactl --interleave=all ./bin/mongod --dbpath data/shard2/ --logpath log/shard2.log --fork --port 27018说明：关于这⾥为什么加numactl --interleave=all，后⾯有详细说明。

Mongodb3.2集群搭建

说明1、集群的组件A、mongos(query routers):查询路由，负责client的连接，并把任务分给shards，然后收集结果。

一个集群可以有多个query routers(replica sets)，以分担客户端请求(负载均衡)。

B、config server:配置服务器。

保存了集群的元数据(比如数据放在哪个shards上)，query router通过config server中的配置信息决定把任务分配到哪个shards上。

从3.2开始，config servers可以做成replica sets。

C、shards:分片，即数据结点，存储数据和执行计算。

为了保证高可用和数据一致性，生产环境中shards应该做成replicasets(防止丢失数据)。

2、IP及端口规划3、linux目录规划一、准备工作1、下载mongodb软件https:///download-center?jmp=nav#community2、服务器IP设置[root@node1]$vi /etc/sysconfig/network-scripts/ifcfg-eth0 将BOOTPROTO=dhcp修改成=static，将ONBOOT=no 改成=yes在文件末添加:IPADDR=192.168.75.10NETMASK=255.255.255.0GATEWAY=192.168.75.1[root@node1]$service network restart3、新建用户组及用户[root@node1]$groupadd minstall[root@node1]$groupadd dba[root@node1]$useradd -g minstall -G dba -m mongo[root@node1]$passwd mongo4、开放端口根据上面端口的规划，将相应的端口开放。

[root@node1]$vi /etc/sysconfig/iptables-A INPUT -m state --state NEW -m tcp -p tcp --dport 17017 -j ACCEPT-A INPUT -m state --state NEW -m tcp -p tcp --dport 27017 -j ACCEPT-A INPUT -m state --state NEW -m tcp -p tcp --dport 37017 -j ACCEPT-A INPUT -m state --state NEW -m tcp -p tcp --dport 47017 -j ACCEPT-A INPUT -m state --state NEW -m tcp -p tcp --dport 57017 -j ACCEPT5、重启服务器，以mongo用户登录系统[root@node1]$reboot6、建立相应的目录[mongo@node1]$mkdir -p /home/mongo/dbs/{config,router,shard}[mongo@node1]$mkdir -p /home/mongo/dbs/config/{data,logs}[mongo@node1]$mkdir -p /home/mongo/dbs/router/logs[mongo@node1]$mkdir -p /home/mongo/dbs/shard/{data,logs}[mongo@node1]$mkdir -p /home/mongo/dbs/shard/data/{shard1,shard2,shard3} 7、安装mongo实例在每台服务器上分别安装3个mongo实例：route、config、shard。

mongoDB集群部署文档

配置mongoDB分片集群说明Sharding cluster介绍：这是一种可以水平扩展的模式，在数据量很大时特给力，实际大规模应用一般会采用这种架构去构建monodb系统。

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

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

架构图：本系统环境架构图：注：mongoDB集群最好是奇数数个服务器，本例介绍的是三台服务器1、分别在3台机器上运行一个mongod实例（称为mongod shard11,mongod shard12,mongodshard13）组成replica set1 ,作为cluster的shard12、分别在3台机器上运行另一个mongod实例（称为mongod shard21,mongod shard22,mongodshard23）组成replica set2 ,作为cluster的shard23、分别在3台机器运行一个mongod实例，作为3个config server4、分别在每台机器运行一个mongos进程，用于客户连接软件准备部署前请先关闭防火墙，因为防火墙有时候会屏蔽1 安装mongoDB软件下载mongodb解压tar zxvf mongodb-linux-***.tar2 创建数据目录Server1:mkdir -p /data/shard11mkdir -p /data/shard21Server2:mkdir -p /data/shard12mkdir -p /data/shard22Server3:mkdir -p /data/shard13mkdir -p /data/shard23配置replice sets(副本集)：1、配置shard1所用到的replica sets:Server1：./mongod -shardsvr -replSet shard1 -port 27017 -dbpath /data/shard11/ -oplogSize 100 -logpath /data/shard11.log -logappend --forkServer2：./mongod -shardsvr -replSet shard1 -port 27017 -dbpath /data/shard12/ -oplogSize 100 -logpath /data/shard12.log -logappend --forkServer3：./mongod -shardsvr -replSet shard1 -port 27017 -dbpath /data/shard13/ -oplogSize 100 -logpath /data/shard13.log -logappend --fork初始化replica set用mongo连接其中一个mongod（例如：./mongo 192.168.10.207:27017）执行：>config ={_id:"shard1",members:[{_id:0,host:'192.168.110.111:27018'},{_id:1,host:'192.168.1 10.112:27018'},{_id:2,host:'192.168.110.113:27018'}]}>rs.initiate(config);2、同样的方法，配置shard2用到的replica sets:Server1：./mongod -shardsvr -replSet shard2 -port 27018 -dbpath /data/shard21/ -oplogSize 100 -logpath /data/shard21.log -logappend --forkServer2:./mongod -shardsvr -replSet shard2 -port 27018 -dbpath /data/shard22/ -oplogSize 100 -logpath /data/shard22.log -logappend --forkServer3:./mongod -shardsvr -replSet shard2 -port 27018 -dbpath /data/shard23/ -oplogSize 100 -logpath /data/shard23.log -logappend –fork初始化replica set用mongo连接其中一个mongod（例如：./mongo 192.168.10.207:27017）执行：>config ={_id:"shard2",members:[{_id:0,host:'192.168.110.111:27019'},{_id:1,host:'192.168.1 10.112:27019'},{_id:2,host:'192.168.110.113:27019'}]}>rs.initiate(config);配置三台config server：Server1：./mongod -configsvr -dbpath /data/config -port 20000 -logpath /data/config.log-logappend --forkServer2：./mongod -configsvr -dbpath /data/config -port 20000 -logpath /data/config.log-logappend --forkServer3:./mongod -configsvr -dbpath /data/config -port 20000 -logpath /data/config.log-logappend --fork配置mongos：Server1./mongos -configdb 192.168.110.111:20000,192.168.110.112:20000,192.168.110.113:20000 -port 30000 -chunkSize 5 -logpath /data/mongos.log -logappend --forkserver2./mongos -configdb192.168.110.111:20000,192.168.110.112:20000,192.168.110.113:20000 -port 30000-chunkSize 5 -logpath /data/mongos.log -logappend --forkserver3./mongos -configdb192.168.110.111:20000,192.168.110.112:20000,192.168.110.113:20000 -port 30000-chunkSize 5 -logpath /data/mongos.log -logappend –fork注释：mongos不需要dbpath配置分片：1、连接mongos,并切换到admin./mongo 192.168.10.207:30000/admin>dbadmin2、加入shards如果shard是单台服务器，用：>db.runCommand({ addshard : “<serverhostname>[:<port>]”})如果shard是replica sets,用：>db.runCommand({ addshard : “replicaSetName/<serverhostname>[:<port>]，<serverhostname>[:<port>]..”})如本机执行：>db.runCommand({addshard:"shard1/192.168.110.111:27018,192.168.110.112:27018,192.168.110.113:27018",name:"a",maxsize:20480})>db.runCommand({addshard:"shard2/192.168.110.111:27019,192.168.110.112:27019,192.168.110.113:27019",name:"b",maxsize:20480})注释：name为用于置顶shard的名字，不指定的话系统自动分配maxsize为指定各个shard可用的最大磁盘空间3、查看shard是否添加成功>db.runCommand({listshards:1})如果列出了以上两个你家的shards，表示添加成功4、激活数据库分片>db.runCommand({enablesharding:”<dbname>”})通过执行以上命令，可以让数据库跨shard，如果不执行这步，数据库只会存放在一个shard，一旦激活数据库分片，数据库中不同的 collection将被存放在不同的shard上，但一个collection仍旧存放在同一个shard上，要使单个collection也分片，还需单独对collection作些操作如：>db.runCommand({enablesharding:"test"})查看数否生效：>db.printShardingStatus()sharding version: { "_id" : 1, "version" : 3 }shards:{ "_id" : "s1", "host" :"shard1/192.168.10.207:27017,192.168.10.208:27017,192.168.10.209:27017" } { "_id" : "s2", "host" :"shard2/192.168.10.207:27018,192.168.10.208:27018,192.168.10.209:27018" } databases:{ "_id" : "admin", "partitioned" : false, "primary" : "config" }{ "_id" : "test", "partitioned" : true, "primary" : "s1" }注释：一旦enable了个数据库，mongos将会把数据库里的不同数据集放在不同的分片上。

helm mongodb集群简书

helm mongodb集群简书
MongoDB集群是MongoDB数据库的高可用解决方案，它可以提高数据库的可用性、可扩展性和性能。

MongoDB集群有多种方式，包括主从复制、副本集和分片集群。

主从复制是MongoDB最早的集群方式，它采用一主多从的架构，主节点负责写操作，从节点负责读操作。

主节点将数据变更同步到从节点，保证数据的一致性。

但是主从复制存在单点故障的问题，如果主节点宕机，整个集群将无法写入数据。

副本集是MongoDB的官方推荐集群方式，它采用多节点复制的方式，保证数据的高可用性和一致性。

副本集可以自动进行故障转移和恢复，当主节点宕机时，副本集会选举一个新的主节点，保证集群的可用性。

副本集还支持读写分离，可以提高集群的读性能。

分片集群是MongoDB的可扩展性解决方案，它将数据分散到多个节点上，每个节点只负责部分数据。

通过水平扩展节点的方式，可以提高集群的存储和处理能力。

分片集群还支持自动均衡负载，保证每个节点的负载均衡。

MongoDB集群的搭建需要多个MongoDB实例和配置服务器。

配置服务器存储了分片路由的元数据，mongos作为路由服务器负责请求的转发和数据聚合。

在搭建MongoDB集群时，需要选择合适的架构和配置参数，以保证集群的高可用性和性能。

总之，MongoDB集群是MongoDB数据库的高可用解决方案，可以提高数据库的可用性、可扩展性和性能。

在搭建MongoDB集群时，需要选择合适的架构和配置参数，并进行充分的测试和调优。

阿里云上MongoDB服务集群部署

1.1 MongoDB服务集群部署1.1.1 M ongoDB集群架构图表 1 MongoDB集群部署架构图1、综合数据库自动维护、弹性伸缩、数据备份恢复、数据安全、数据库性能、监控报警、数据迁移、总体成本等多方面的因素考虑，使用阿里云的MongoDB集群服务比自建MongoDB集群更具有优势，故生产环境部署采用阿里云的MongoDB云服务。

2、整体采用三节点副本集+同城容灾+异地容灾方案，即数据中心内部三个节点分散于三个可用区，同时支持双数据中心异地灾备方案。

3、后续数据库集群可从异地主备平滑切换到两地双活，更贴近社交、通讯类应用的网络架构场景。

1.1.2 资源配置清单注：实际生产运营过程中根据真实需求可进行升降配置或扩缩容操作。

1.1.3 运行环境设置1.1.3.1 创建副本集实例1、登录MongoDB管理控制台。

2、在左侧导航栏，单击副本集实例列表。

3、在副本集实例列表页面，单击新建实例。

4、选择副本集（包年包月）或副本集（按量付费），参数信息参考3.2.2资源配置清单。

5、选择实例配置，参数信息参考3.2.2资源配置清单。

6、单击立即购买，进入订单确认页面。

7、在确认订单页面，阅读并勾选云数据库MongoDB版服务协议，根据提示完成支付流程。

1.1.3.2 创建云上灾备实例1、登录MongoDB管理控制台。

2、单击页面左侧导航栏的云上灾备，跳转至MongoDB云上灾备控制台。

3、单击页面右侧的创建灾备。

4、在创建灾备对话框中设置源实例和目标实例的信息，参数信息参考3.2.2资源配置清单。

5、单击确定。

6、勾选云数据库MongoDB版服务条款复选框，根据提示完成订单支付。

7、等待云上灾备实例初始化完成。

8、在页面左上角，选择实例所在的地域。

9、在左侧导航栏，单击副本集实例列表。

10、找到灾备目标实例，单击实例ID。

11、在左侧导航栏，单击账号管理。

12、单击重置密码，为目标实例设置密码。

13、后续可以通过MongoDB管理控制台->云上灾备，选择目标灾备ID或单击管理，查看灾备实例同步状态监控信息。

使用Docker部署MongoDB集群的步骤详解

使用Docker部署MongoDB集群的步骤详解今天我们来详细讲解一下使用Docker部署MongoDB集群的步骤。

MongoDB 是一个非关系型数据库，其灵活的数据模型和高可扩展性使其成为大数据应用的首选。

而Docker作为一个轻量级容器技术，能够快速部署和管理分布式应用，因此将它们结合起来，可以帮助我们更方便地搭建MongoDB集群。

第一步，我们需要在机器上安装Docker。

在Linux上，可以使用以下命令安装Docker：```sudo apt-get updatesudo apt-get install docker.io```在安装完成后，可以使用以下命令来验证Docker是否成功安装：```docker --version```第二步，我们需要准备MongoDB的镜像。

Docker Hub上提供了MongoDB的官方镜像，我们可以使用以下命令将其下载到本地：```docker pull mongo```下载完成后，我们可以使用以下命令来查看已经下载的镜像：docker images```第三步，我们可以开始配置MongoDB集群。

为了实现高可用性和数据复制，我们需要至少启动3个MongoDB实例。

可以使用以下命令来创建一个MongoDB 容器实例：```docker run -p 27017:27017 --name mongodb1 mongo```这个命令会创建一个名为mongodb1的容器，并将该容器的27017端口映射到主机的27017端口。

这样我们就可以通过主机的27017端口来连接和管理这个MongoDB实例。

接着，我们还需要创建其他两个MongoDB实例。

可以使用类似的命令，只需更改容器和主机的端口号即可：```docker run -p 27018:27017 --name mongodb2 mongodocker run -p 27019:27017 --name mongodb3 mongo```当我们启动完所有的MongoDB实例后，可以使用以下命令来查看容器的运行状态：```docker ps第四步，我们需要将这3个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集群搭建的原理是通过数据分片和复制来实现的。

数据分片是将数据分散存储在多个服务器上的过程。

在MongoDB 中，数据按照某种规则划分成多个片段，每个片段包含一部分数据。

这些片段被均匀地分布到不同的服务器上，以实现数据的负载均衡和横向扩展。

数据分片的过程包括以下几个步骤：1.选择分片键：在进行数据分片之前，需要选择一个适合的分片键。

分片键是用来划分数据的依据，通常选择一个常用的字段作为分片键，例如用户ID或时间戳。

2.创建分片集合：在选择了分片键之后，需要创建一个分片集合来存储数据。

分片集合是一个特殊的集合，其中包含了要分片的数据。

3.启用分片：在创建了分片集合之后，需要启用分片功能。

启用分片功能会将集群中的服务器划分为不同的角色，其中包括配置服务器、路由服务器和数据服务器。

4.添加分片：在启用了分片功能之后，需要将分片服务器添加到集群中。

添加分片服务器的过程包括创建分片服务器实例、配置分片服务器和启动分片服务器。

5.启动分片：在添加了分片服务器之后，需要启动分片功能。

启动分片功能会将分片集合中的数据按照分片键进行划分，并存储到不同的分片服务器中。

数据复制是指将数据复制到多个服务器上的过程。

通过数据复制，可以提高数据的可用性和容错能力，同时还可以实现读写分离和故障恢复等功能。

数据复制的过程包括以下几个步骤：1.选择复制集：在进行数据复制之前，需要选择一个复制集作为主节点。

复制集是由一个主节点和多个从节点组成的集合，主节点负责处理所有的写操作，从节点负责处理读操作。

2.配置复制集：在选择了复制集之后，需要配置复制集的参数。

mongodb集群搭建

关系型数据库术语/概念MongoDB 术语/概念解释/ 说明DatabaseDatabase 数据库T ableCollection 数据库表/集合RowDocument 数据记录⾏行行/⽂文档ColumnField 数据列列/数据字段IndexIndex 索引T able joins表关联/MongoDB 不不⽀支持Primary Key Object ID 主键/MongoDB ⾃自动将_id 设置为主键mongodb 集群搭建前⾔言阅读本⽂文的同学们需要⼀一定基础知识,对集群结构,主从结构(master-slave )需要有⼀一定的了了解,否则会晕⾸首先需要了了解认识NoSql , 即为Not Only Sql , 不不同于传统的关系型数据库的数据库管理理系统的统称. MongoDB 是⼀一个基于分布式⽂文件存储的数据库, 是⼀一个介于关系数据库和⾮非关系数据库之间的产品，是⾮非关系数据库当中功能最丰富，最像关系数据库的.MongoDB 的数据结构与关系型数据库数据结构对⽐比MongoDB 的应⽤用场景和不不适⽤用场景1、适⽤用场景a.⽹网站数据：mongo⾮非常适合实时的插⼊入，更更新与查询，并具备⽹网站实时数据存储所需的复制及⾼高度伸缩性。

b.缓存：由于性能很⾼高，mongo也适合作为信息基础设施的缓存层。

在系统重启之后，由mongo搭建的持久化缓存可以避免下层的数据源过载。

c.⼤大尺⼨寸、低价值的数据：使⽤用传统的关系数据库存储⼀一些数据时可能会⽐比较贵，在此之前，很多程序员往往会选择传统的⽂文件进⾏行行存储。

d.⾼高伸缩性的场景：mongo⾮非常适合由数⼗十或者数百台服务器器组成的数据库。

e.⽤用于对象及JSON数据的存储：mongo的BSON数据格式⾮非常适合⽂文档格式化的存储及查询。

2、不不适⽤用场景a.⾼高度事物性的系统：例例如银⾏行行或会计系统。

传统的关系型数据库⽬目前还是更更适⽤用于需要⼤大量量原⼦子性复杂事务的应⽤用程序。

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数据库创建集合步骤

mongodb数据库创建集合步骤以mongodb数据库创建集合步骤为标题，写一篇文章MongoDB是一个开源的、面向文档的数据库管理系统，它使用BSON（二进制JSON）格式来存储数据。

在MongoDB中，集合（Collection）是一组文档（Document）的容器，类似于关系型数据库中的表。

本文将介绍在MongoDB中创建集合的步骤。

1. 连接MongoDB数据库在创建集合之前，首先需要连接到MongoDB数据库。

可以使用MongoDB提供的驱动程序或者命令行工具来连接数据库。

连接数据库的方法有很多种，可以根据自己的需求选择合适的方式进行连接。

2. 选择数据库MongoDB可以同时管理多个数据库，因此在创建集合之前，需要选择要在哪个数据库中创建集合。

可以使用命令“use database_name”来选择数据库，其中“database_name”为数据库的名称。

3. 创建集合在选择了数据库之后，就可以开始创建集合了。

MongoDB提供了多种方式来创建集合，包括使用驱动程序提供的API、使用命令行工具或者使用MongoDB的图形界面工具等。

下面以使用MongoDB的命令行工具为例来创建集合。

使用命令“db.createCollection(name, options)”可以创建集合，其中“name”为集合的名称，可以是任意字符串，“options”为可选参数，用于指定集合的一些配置选项。

4. 验证集合是否创建成功创建集合之后，可以使用命令“show collections”来查看数据库中的所有集合，确认集合是否创建成功。

命令“show collections”会列出当前数据库中的所有集合名称。

5. 添加文档到集合集合创建成功之后，可以向集合中添加文档。

文档是MongoDB中最基本的数据单元，采用BSON格式存储。

可以使用命令“db.collection_name.insert(document)”来向集合中插入文档，其中“collection_name”为集合的名称，“document”为要插入的文档内容。

MongoDB搭建高可用集群的完整步骤（3个分片+3个副本）

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

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

MongoDB分布式集群架构（3种模式）

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MongoDB 3.4 高可用集群搭建

MongoDB3.4 高可用集群搭建一、MongoDB单实例这种配置只适合简易开发时使用，生产使用不行，因为单节点挂掉整个数据业务全挂（如下图。

），虽然不能生产使用，但这个模式可以快速搭建启动，并且能够用mongodb的命令操作数据库。

二、主从模式使用MySQL数据库时大家广泛用到，采用双机备份后主节点挂掉了后从节点可以接替主机继续服务。

所以这种模式比单节点的高可用性要好很多。

主从模式搭建准备2个虚拟机，一个作为master服务器（192.168.1.41），一个作为slave服务器（192.168.1.54），两个虚拟机都安装并配置好了MongoDB，并创建好了数据库存放文件夹；或者在一台机器上通过使用不同的端口启动2个MongoDB服务，也可以实现。

现在我们使用通过不同的端口启动2个实例的方式来演示。

1.MongoDB的安装配置目录如下我们启动master服务用的是node1/data作为数据库存放的文件夹，启动slave服务用的是node2/data作为数据库存放的文件夹；2.启动MongoDB Master服务命令：bogon:mongodb3.4.4 alvinsun$mongod -dbpath node1/data/ -master3.启动MongoDB Slave服务器命令：bogon:mongodb3.4.4 alvinsun$mongod -dbpath node2/data/ -slave -port 27018 -source 127.0.0.1:270174.测试打开一个客户端，并连接到主节点，在主节点插入一个文档。

再打开一个客户端，连接到slave节点，查询user集合，出现以下情况。

注意，客户端连上slave服务器后，要运行以下命令来打开读权限：rs.slaveOk()再向master服务器添加2条数据，然后查询slave服务器5.主从节点数据一致性测试首先停掉slave服务器，之后在master节点再新加一条文档，如下图。

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挂掉之后数据丢失。

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

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

Mongodb集群搭建的三种方式
MongoDB是一个基于分布式文件存储的数据库。

由C++语言编写。

旨在为WEB应用提供可扩展的高性能数据存储解决方案。

他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。

Mongo 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

Mongodb的存储方式是文档式存储，并不是Key-Value形式。

Mongodb的三种集群方式的搭建：Replica Set、Sharding、Master-Slaver。

1、Replica Set（副本集）
简单来说就是集群当中包含了多份数据，保证主节点挂掉了，备节点能继续提供数据服务，提供的前提就是数据需要和主节点一致。

如下图：
Mongodb(M)表示主节点，Mongodb(S)表示备节点，Mongodb(A)表示仲裁节点。

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

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

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

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

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

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

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

2、Sharding
和Replica Set类似，都需要一个仲裁节点，但是Sharding还需要配置节点和路由节点。

就三种集群搭建方式来说，这种是最复杂的。

部署图如下：
3、Master-Slaver
这个是最简答的集群搭建，不过准确说也不能算是集群，只能说是主备。

并且官方已经不推荐这种方式。

以上三种集群搭建方式首选Replica Set，只有真的是大数据，Sharding才能显现威力，毕竟备节点同步数据是需要时间的。

Sharding可以将多片数据集中到路由节点上进行一些对比，然后将数据返回给客户端，但是效率还是比较低的说。