mongodb集群有三种方式

    1，主从模式，类似mysql master slave方式。

    2，副本集模式，其实是一主多从，如果主节点挂掉，会重新在从节点选取一台为主节点。

    3，分片模式，针对大数据量，高负载情况。

mysql要做到自动扩展需要加一个数据访问层用程序去扩展，数据库的增加、删除、备份还需要程序去控制。一但数据库的节点一多，要维护起来也是非常头疼的。不过mongodb所有的这一切通过他自己的内部机制就可以搞定！顿时石化了，这么牛X！还是上图看看mongodb通过哪些机制实现路由、分片：

wKioL1UsvwCgUF0jAAG8apv8TOY057.jpg

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

mongos，数据库集群请求的入口，所有的请求都通过mongos进行协调，不需要在应用程序添加一个路由选择器，mongos自己就是一个请求分发中心，它负责把对应的数据请求请求转发到对应的shard服务器上。在生产环境通常有多mongos作为请求的入口，防止其中一个挂掉所有的mongodb请求都没有办法操作。

config server，顾名思义为配置服务器，存储所有数据库元信息(路由、分片)的配置。mongos本身没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据。mongos第一次启动或者关掉重启就会从 config server 加载配置信息，以后如果配置服务器信息变化会通知到所有的 mongos 更新自己的状态，这样 mongos 就能继续准确路由。在生产环境通常有多个 config server 配置服务器，因为它存储了分片路由的元数据，这个可不能丢失！就算挂掉其中一台，只要还有存货， mongodb集群就不会挂掉。

shard，这就是传说中的分片了。上面提到一个机器就算能力再大也有天花板，就像军队打仗一样，一个人再厉害喝血瓶也拼不过对方的一个师。俗话说三个臭皮匠顶个诸葛亮，这个时候团队的力量就凸显出来了。在互联网也是这样，一台普通的机器做不了的多台机器来做，如下图：

wKiom1UsviPDW-8HAAGzUzKmy3A693.jpg

一台机器的一个数据表 Collection1 存储了 1T 数据，压力太大了！在分给4个机器后，每个机器都是256G，则分摊了集中在一台机器的压力。也许有人问一台机器硬盘加大一点不就可以了，为什么要分给四台机器呢？不要光想到存储空间，实际运行的数据库还有硬盘的读写、网络的IO、CPU和内存的瓶颈。在mongodb集群只要设置好了分片规则，通过mongos操作数据库就能自动把对应的数据操作请求转发到对应的分片机器上。在生产环境中分片的片键可要好好设置，这个影响到了怎么把数据均匀分到多个分片机器上，不要出现其中一台机器分了1T，其他机器没有分到的情况，这样还不如不分片！

replica set，上两节已经详细讲过了这个东东，怎么这里又来凑热闹！其实上图4个分片如果没有 replica set 是个不完整架构，假设其中的一个分片挂掉那四分之一的数据就丢失了，所以在高可用性的分片架构还需要对于每一个分片构建 replica set 副本集保证分片的可靠性。生产环境通常是 2个副本 + 1个仲裁。

说了这么多，还是来实战一下如何搭建高可用的mongodb集群：

首先确定各个组件的数量，mongos 3个， config server 3个，数据分3片 shard server 3个，每个shard 有一个副本一个仲裁也就是 3 * 2 = 6 个，总共需要部署15个实例。这些实例可以部署在独立机器也可以部署在一台机器，我们这里测试资源有限，只准备了 3台机器，在同一台机器只要端口不同就可以，看一下物理部署图：

wKioL1UswCjgmYTwAAUnOHDR7OI538.jpg

下面是安装配置

1，准备三台机器

ip: 10.19.21.241 ,10.19.21.242 ,10.19.21.243

分别在每台机器上,同步时间服务器

yum install ntpdate -y
/usr/sbin/ntpdate cn.pool.ntp.org

顺便把硬件时间也同步下

hwclock --systohc
10.19.21.241 | success | rc=0 >>
10.19.21.243 | success | rc=0 >>
10.19.21.242 | success | rc=0 >>

2,在一台机器上，下载mongodb

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.2.8.tgz

3,解压安装mongodb

tar zxvf mongodb-linux-x86_64-rhel70-3.2.8.tgz
mv mongodb-linux-x86_64-rhel70-3.2.8 /usr/local/mongodb

 4,在一台机器上，创建mongos config shard1 shard2 shard3五个目录，因为mongos不存储数据，只需建立日志文件目录

建立mongos目录和日志目录

mkdir -p /usr/local/mongodb/mongos/log

建立config server数据目录

mkdir -p /usr/local/mongodb/config/data

建立config server日志目录

mkdir -p /usr/local/mongodb/config/log

建立shard1数据目录和日志目录

mkdir -p /usr/local/mongodb/shard1/data /usr/local/mongodb/shard1/log

建立shard2数据目录和日志目录

mkdir -p /usr/local/mongodb/shard2/data /usr/local/mongodb/shard2/log

建立shard3数据目录和日志目录

mkdir -p /usr/local/mongodb/shard2/data /usr/local/mongodb/shard2/log

5,规划5个组件对应的端口号，由于一个机器需要同时部署mongos, config server, shard1, shard2, shard3,所以需要用端口号进行区分

这个端口号可以自己定义，mongos:20000,config server:21000, shard1:22001, shard2:22002, shard3:22003

6,配置服务器的配置文件

cat /usr/local/mongodb/config/mongod-configsvr.conf
dbpath=/usr/local/mongodb/config/data
port=21000
logpath=/usr/local/mongodb/config/log/config.log
fork=true
configsvr=true
logappend=true

配置每台mongos服务器

cat /usr/local/mongodb/config/mongod-mongos.conf
configdb=10.19.21.241:21000,10.19.21.242:21000,10.19.21.243:21000
port=20000
logpath=/usr/local/mongodb/mongos/log/mongos.log
logappend=true
fork=true

配置各个分片的副本集

cat /usr/local/mongodb/config/mongod-shardsvr1.conf
shardsvr=true
replSet=shard1
port=22001
dbpath=/usr/local/mongodb/shard1/data
logpath=/usr/local/mongodb/shard1/log/shard1.log
fork=true
logappend=true
  
cat /usr/local/mongodb/config/mongod-shardsvr2.conf
shardsvr=true
replSet=shard2
port=22002
dbpath=/usr/local/mongodb/shard2/data
logpath=/usr/local/mongodb/shard2/log/shard2.log
fork=true
logappend=true
  
cat /usr/local/mongodb/config/mongod-shardsvr3.conf
shardsvr=true
replSet=shard3
port=22003
dbpath=/usr/local/mongodb/shard3/data
logpath=/usr/local/mongodb/shard3/log/shard3.log
fork=true
logappend=true

7,打包mongodb目录，拷贝到另外两台服务器

tar zcvf /mnt/mongodb.tar.gz /usr/local/mongodb
scp mongodb.tar.gz root@10.19.21.242:/mnt/
scp mongodb.tar.gz root@10.19.21.243:/mnt/

被拷贝的两台服务器分别解压

tar zxvf /mnt/mongodb.tar.gz -C /

 8,分别在每台机器上,启动服务，三台机器必须先全部启动mongod-configsvr.conf

ln -s /usr/local/mongodb/bin/mongo* /usr/bin/mongod
mongod -f /usr/local/mongodb/config/mongod-configsvr.conf
mongos -f /usr/local/mongodb/config/mongod-mongos.conf  (上面命令全部执行完再运行，否则报错)

启动各个分片的副本集

mongod -f /usr/local/mongodb/config/mongod-shardsvr1.conf
mongod -f /usr/local/mongodb/config/mongod-shardsvr2.conf
mongod -f /usr/local/mongodb/config//mongod-shardsvr3.conf

9,登陆任意一台，连接mongodb

设置第一个分片副本集

[root@VM-241 ~]# mongo 127.0.0.1:22001
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:22001/test
使用admin数据库 
mongos> use admin
switched to db admin

定义副本集配置

mongos> config={_id:"shard1",members:[{_id:0,host:"10.19.21.241:22001"},{_id:1,host:"10.19.21.242:22001"},{_id:2,host:"10.19.21.243:22001",arbiterOnly:true}]}
＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃
{
"_id" : "shard1",
"members" : [
{
"_id" : 0,
"host" : "10.19.21.241:22001"
},
{
"_id" : 1,
"host" : "10.19.21.242:22001"
},
{
"_id" : 2,
"host" : "10.19.21.243:22001",
"arbiterOnly" : true
}
]
}

初始化副本集配置

   > rs.initiate(config);

{
"info" : "Config now saved locally.  Should come online in about a minute.",
"ok" : 1
}

设置第二个分片副本集

[root@VM-241 ~]# mongo 127.0.0.1:22002
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:22002/test
> use admin
switched to db admin
> config={_id:"shard2",members:[{_id:0,host:"10.19.21.241:22002"},{_id:1,host:"10.19.21.242:22002"},{_id:2,host:"10.19.21.243:22002",arbiterOnly:true}]}
 
初始化副本集配置
> rs.initiate(config);

设置第三个分片副本集

[root@VM-241 ~]# mongo 127.0.0.1:22003
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:22003/test
> use admin
switched to db admin
> config={_id:"shard3",members:[{_id:0,host:"10.19.21.241:22003"},{_id:1,host:"10.19.21.242:22003"},{_id:2,host:"10.19.21.243:22003",arbiterOnly:true}]}
 
> rs.initiate(config);

10,配置分片

目前搭建的mongodb配置服务器，路由服务器，各个分片服务器，不过应用程序连接到mongs路由服务器并不能使用分片机制，还需要在程序里设置分片配置，让分片生效。

连接mongos

[root@VM-241 ~]# mongo 127.0.0.1:20000
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:20000/test

使用admin数据库

mongos> use admin
switched to db admin

串联路由服务器与分配副本集1

mongos> db.runCommand({addshard:"shard1/10.19.21.241:22001,10.19.21.242:22001,10.19.21.243:22001"});
{ "shardAdded" : "shard1", "ok" : 1 }

＃如里shard是单台服务器，用 db.runCommand( { addshard : “[: ]” } )这样的命令加入，如果shard是副本集，用db.runCommand( { addshard : “replicaSetName/[:port][,serverhostname2[:port],…]” });这样的格式表示 

串联路由服务器与分配副本集2

mongos> db.runCommand({addshard:"shard2/10.19.21.241:22002,10.19.21.242:22002,10.19.21.243:22002"});
{ "shardAdded" : "shard2", "ok" : 1 }

串联路由服务器与分配副本集3

mongos> db.runCommand({addshard:"shard3/10.19.21.241:22003,10.19.21.242:22003,10.19.21.243:22003"});
{ "shardAdded" : "shard3", "ok" : 1 }

查看分片服务器配置

mongos> db.runCommand({listshards:1})
{
"shards" : [
{
"_id" : "shard1",
"host" : "shard1/10.19.21.241:22001,10.19.21.242:22001"
},
{
"_id" : "shard2",
"host" : "shard2/10.19.21.241:22002,10.19.21.242:22002"
},
{
"_id" : "shard3",
"host" : "shard3/10.19.21.241:22003,10.19.21.242:22003"
}
],
"ok" : 1
}

由于10.19.21.243是每个分片副本集的仲裁节点，所以上面没有列出

11,目前配置服务、路由服务、分片服务、副本集服务都已经串联起来了，但我们的目的是希望插入数据，数据能够自动分片，连接在mongos上，准备让指定的数据库、指定的集合分片生效

指定数据库里面的索引

使用table1中的id字段的hash作为索引来分片，需要进入数据库中去建立

db.table1.ensureIndex({id:"hashed"});
db.table1.ensureIndex({id:1},{unique:true})；

指定数据库testdb使分片生效，在admin库中执行以下命令

mongos> db.runCommand({enablesharding:"testdb"});
{ "ok" : 1 }
或是
mongos> sh.enableSharding('testdb');

指定数据库里需要分片的集合和片键

mongos> db.runCommand({shardcollection:"testdb.table1",key:{id:"hashed"}})
{ "collectionsharded" : "testdb.table1", "ok" : 1 }
或是
mongos> sh.shardCollection('testdb.table1',{id:'hashed'})

我们设置testdb的 table1 表需要分片，根据 id 自动分片到 shard1 ，shard2，shard3 上面去。要这样设置是因为不是所有mongodb 的数据库和表 都需要分片！

mongos> use testdb
switched to db testdb

插入测试数据

for (var i=1;i<=100000;i++)db.table1.save({id:i,"test1":"testvar1"});
WriteResult({ "nInserted" : 1 })

查看分片情况如下：

mongos> db.table1.stats();
{
"sharded" : true,
"capped" : false,
"ns" : "testdb.table1",
"count" : 100000,
"size" : 5400000,
"storageSize" : 1822720,
"totalIndexSize" : 3674112,
"indexSizes" : {
"_id_" : 991232,
"id_hashed" : 2682880
},
"avgObjSize" : 54,
"nindexes" : 2,
"nchunks" : 6,

"shards" : {
"shard1" : {
"ns" : "testdb.table1",
"count" : 33755,
"size" : 1822770,
"avgObjSize" : 54,
"storageSize" : 614400,
"capped" : false,
"wiredTiger" : {
"metadata" : {
"formatVersion" : 1
},
......
"nindexes" : 2,
"totalIndexSize" : 1224704,
"indexSizes" : {
"_id_" : 335872,
"id_hashed" : 888832
},
"ok" : 1
},

"shard2" : {
"ns" : "testdb.table1",
"count" : 33143,
"size" : 1789722,
"avgObjSize" : 54,
"storageSize" : 606208,
"capped" : false,
"wiredTiger" : {
"metadata" : {
"formatVersion" : 1
},
......
"nindexes" : 2,
"totalIndexSize" : 1196032,
"indexSizes" : {
"_id_" : 327680,
"id_hashed" : 868352
},
"ok" : 1
},

"shard3" : {
"ns" : "testdb.table1",
"count" : 33102,
"size" : 1787508,
"avgObjSize" : 54,
"storageSize" : 602112,
"capped" : false,
"wiredTiger" : {
"metadata" : {
"formatVersion" : 1
},
......
"nindexes" : 2,
"totalIndexSize" : 1253376,
"indexSizes" : {
"_id_" : 327680,
"id_hashed" : 925696
},
"ok" : 1
}
},
"ok" : 1
}

可以看到数据分到3个分片，shard1:33755 shard2:33143 shard3:33102

----------------------------------------------------------------------------------------------

  • java程序调用分片集群，因为我们配置了三个mongos作为入口，就算其中哪个入口挂掉了都没关系，使用集群客户端程序如下：

  • public class TestMongoDBShards {
  
       public static void main(String[] args) {
  
             try {
                  List<ServerAddress> addresses = new ArrayList<ServerAddress>();
                  ServerAddress address1 = new ServerAddress("10.19.21.241" , 20000);
                  ServerAddress address2 = new ServerAddress("10.19.21.242" , 20000);
                  ServerAddress address3 = new ServerAddress("10.19.21.243" , 20000);
                  addresses.add(address1);
                  addresses.add(address2);
                  addresses.add(address3);
  
                  MongoClient client = new MongoClient(addresses);
                  DB db = client.getDB( "testdb" );
                  DBCollection coll = db.getCollection( "table1" );
  
                  BasicDBObject object = new BasicDBObject();
                  object.append( "id" , 1);
  
                  DBObject dbObject = coll.findOne(object);
  
                  System. out .println(dbObject);
  
            } catch (Exception e) {
                  e.printStackTrace();
            }
      }
}

整个分片集群搭建完了，思考一下我们这个架构是不是足够好呢？其实还有很多地方需要优化，比如我们把所有的仲裁节点放在一台机器，其余两台机器承担了全部读写操作，但是作为仲裁的192.168.0.138相当空闲。让机器3 192.168.0.138多分担点责任吧！架构可以这样调整，把机器的负载分的更加均衡一点，每个机器既可以作为主节点、副本节点、仲裁节点，这样压力就会均衡很多了，如图：

wKioL1fFKzuhmO4NAAAxTxy9uOM229.png

当然生产环境的数据远远大于当前的测试数据，大规模数据应用情况下我们不可能把全部的节点像这样部署，硬件瓶颈是硬伤，只能扩展机器。要用好mongodb还有很多机制需要调整，不过通过这个东东我们可以快速实现高可用性、高扩展性，所以它还是一个非常不错的Nosql组件。

再看看我们使用的mongodb java 驱动客户端 MongoClient(addresses)，这个可以传入多个mongos 的地址作为mongodb集群的入口，并且可以实现自动故障转移，但是负载均衡做的好不好呢？打开源代码查看：

wKiom1fFK2KDiWHnAAAXWv5WbtE284.png

它的机制是选择一个ping 最快的机器来作为所有请求的入口，如果这台机器挂掉会使用下一台机器。那这样。。。。肯定是不行的！万一出现双十一这样的情况所有请求集中发送到这一台机器，这台机器很有可能挂掉。一但挂掉了，按照它的机制会转移请求到下台机器，但是这个压力总量还是没有减少啊！下一台还是可能崩溃，所以这个架构还有漏洞！不过这个文章已经太长了，后续解决吧。

原文：http://charlie928.blog.51cto.com/3741218/1632314

参考：http://blog.jobbole.com/72643/