集群搭建有3种方式，Replica Set / Sharding / Master-Slaver。

复制集群(Replica Set )

ReplicaSet角色介绍

master:主节点，负责处理客户端请求，负责读写查询数据
salve：从节点，负责备份数据，可以设置为提供查询数据的功能，从而减少主节点的查询压力
arbite：仲裁节点，监控功能，当主节点挂了，会指定某个从节点去代替主节点。不存储数据

mongodb各节点常见的搭配方式为：一主一从一仲裁、一主多从一仲裁

主节点记录在其上的所有操作日志，从节点定期轮询主节点获取这些操作，然后对自己的数据副本进行这些操作，从而保证从节点的数据与主节点一致。

前置准备(一个mongodb应用，启用多个端口)

将mongodb的tgz以及mongosh的tgz解压到/usr/local，分别命名为mongodb-rs，mongosh。
【1】进入mongodb-rs目录，创建数据库目录，配置文件目录，日志目录

mkdir -p data/mater
mkdir -p data/salve1
mkdir -p data/salve2
mkdir -p data/arbite
mkdir logs
mkdir conf
cd logs
touch master.log salve1.log salve2.log arbite.log
cd ../conf
touch mongodb_master.conf mongodb_salve1.conf mongodb_salve2.conf mongodb_arbite.conf

【2】mongodb_master.conf 配置如下

dbpath=/usr/local/mongodb-rs/data/master
logpath=/usr/local/mongodb-rs/logs/master.log
logappend=true
bind_ip_all=true
port=27017
fork=true
replSet=rs0

【3】mongodb_salve1.conf配置如下

dbpath=/usr/local/mongodb-rs/data/slave1
logpath=/usr/local/mongodb-rs/logs/slave1.log
logappend=true
bind_ip_all=true
port=27018
fork=true
replSet=rs0

【4】mongodb_salve2.conf配置如下

dbpath=/usr/local/mongodb-rs/data/slave2
logpath=/usr/local/mongodb-rs/logs/slave2.log
logappend=true
bind_ip_all=true
port=27019
fork=true
replSet=rs0

【5】mongodb_arbite.conf配置如下

dbpath=/usr/local/mongodb-rs/data/arbite
logpath=/usr/local/mongodb-rs/logs/arbite.log
logappend=true
bind_ip_all=true
port=27020
fork=true
replSet=rs0

【6】启动一主两从一仲裁的mongodb服务

/usr/local/mongodb-rs/bin/mongod --config /usr/local/mongodb-rs/conf/mongodb_master.conf
/usr/local/mongodb-rs/bin/mongod --config /usr/local/mongodb-rs/conf/mongodb_slave1.conf
/usr/local/mongodb-rs/bin/mongod --config /usr/local/mongodb-rs/conf/mongodb_slave2.conf
/usr/local/mongodb-rs/bin/mongod --config /usr/local/mongodb-rs/conf/mongodb_arbite.conf

【6】连接其中一个服务

/usr/local/mongosh/bin/mongosh --port 27017
#然后使用use admin以后 初始化(下面的代码)

rs.initiate({  //复制集初始化
    _id:"rs0", //复制集的名称 与几个配置文件相同
    members:[    //复制集成员信息
        {_id:0,host:"127.0.0.1:27017",priority:3},   //_id唯一标记 priority权重，越大优先级越高。host主机地址
        {_id:1,host:"127.0.0.1:27018",priority:2},
        {_id:2,host:"127.0.0.1:27019",priority:1},
        {_id:3,host:"127.0.0.1:27020",arbiterOnly:true}  //arbiterOnly:是否是仲裁节点，权重越高越能成为主节点
    ]
});

复制集群搭建完毕

分片集群(Sharding)

什么是分片

当MongoDB存储数据量过大的时候，一台机器可能不足以存储数据或者不能够提供足够的读写吞吐量。就可以在多台机器上分割数据，使得数据库系统能够存储或者处理更多的数据。

分片结构

image.png

提示：
路由可是是多个，配置服务也可以是多个。分片shard必须是两个及其以上！！！。
另外，以上本质上都是Replica Set(复制集群)。但是配置服务不能有仲裁节点，路由不需要有数据库目录，只是指定配置服务即可。

sharding方案将整个数据集拆分成多个更小的chunk，并分布在集群中多个mongod节点上，最终达到存储和负载能力扩容、压力分流的作用。在sharding架构中，每个负责存储一部分数据的mongod节点称为shard（分片），shard上分布的数据块称为chunk，collections可以根据“shard key”（称为分片键）将数据集拆分为多个chunks，并相对均衡的分布在多个shards上。

术语解释

Shard
用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障
Config Server
mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。
Routers
前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用。
Shard Key
数据的分区根据“shard key”，对于每个需要sharding的collection，都需要指定“shard key”（分片键）；分片键必须是索引字段或者为组合索引的左前缀；mongodb根据分片键将数据分成多个chunks，并将它们均匀分布在多个shards节点上。目前，mongodb支持两种分区算法：区间分区（Range）和哈希（Hash）分区。
Range分区
首先shard key必须是数字类型或字符串类型（字符串类型根据索引排序作为分裂依据），整个区间的上下边界分别为“正无穷大”、“负无穷大”，每个chunk覆盖一段子区间，即整体而言，任何shard key均会被某个特定的chunk所覆盖。区间均为左闭右开。每个区间均不会有重叠覆盖，且互相临近。当然chunk并不是预先创建的，而是随着chunk数据的增大而不断split。
Hash分区
计算shard key的hash值（64位数字），并以此作为Range来分区；Hash值具有很强的散列能力，通常不同的shard key具有不同的hash值（冲突是有限的），这种分区方式可以将document更加随机的分散在不同的chunks上。

分片集群的搭建

前置准备(一个mongodb应用，启用多个端口)

将mongodb的tgz以及mongosh的tgz解压到/usr/local，分别命名为mongodb-sh，mongosh。
【1】进入mongodb-sh目录，创建数据库目录，配置文件目录，日志目录

#创建分片1的数据库目录(一主一从一裁决)
mkdir -p data/db/sh0/master_db
mkdir -p data/db/sh0/salve_db
mkdir -p data/db/sh0/arbite_db
#创建分片2的数据库目录(一主一从一裁决)
mkdir -p data/db/sh1/master_db
mkdir -p data/db/sh1/salve_db
mkdir -p data/db/sh1/arbite_db
#创建配置服务的数据库目录(一主两从无仲裁)
mkdir -p data/db/config_server/master_db
mkdir -p data/db/config_server/salve_db0
mkdir -p data/db/config_server/salve_db1
#创建日志目录以及日志文件
mkdir logs
cd logs
touch sh0-master.log   #分片1的主节点日志
touch sh0-salve.log     #分片1的从节点日志
touch sh0-arbite.log    #分片1的仲裁节点日志
touch sh1-master.log  #分片2的主节点日志
touch sh1-salve.log    #分片2的从节点日志
touch sh1-arbite.log   #分片2的仲裁节点日志
touch config-master.log #配置服务的主节点日志
touch config-salve0.log  #配置服务的从节点1日志
touch config-salve1.log #配置服务的从节点2日志
touch router.log               #路由的日志
#创建配置文件目录以及配置文件
cd ../
mkdir conf
touch sh0-master.conf   #分片1的主节点配置文件
touch sh0-salve.conf     #分片1的从节点配置文件
touch sh0-arbite.conf    #分片1的仲裁节点配置文件
touch sh1-master.conf  #分片2的主节点配置文件
touch sh1-salve.conf    #分片2的从节点配置文件
touch sh1-arbite.conf   #分片2的仲裁节点配置文件
touch config-master.conf #配置服务的主节点配置文件
touch config-salve0.conf  #配置服务的从节点1配置文件
touch config-salve1.conf #配置服务的从节点2配置文件
touch router.conf               #路由的配置文件

配置文件的具体内容：

#sh0_master.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh0/master_db
logpath=/usr/local/mongodb-sh/logs/sh0-master.log
bind_ip_all=true
shardsvr=true  #是否是分片
logappend=true
replSet=sh0
port=27010
oplogSize=10000
fork=true
#sh0_salve.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh0/salve_db
logpath=/usr/local/mongodb-sh/logs/sh0-salve.log
bind_ip_all=true
shardsvr=true
logappend=true
replSet=sh0
port=27011
oplogSize=10000
fork=true
#sh0_arbite.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh0/arbite_db
logpath=/usr/local/mongodb-sh/logs/sh0-arbite.log
bind_ip_all=true
shardsvr=true
logappend=true
replSet=sh0
port=27012
oplogSize=10000
fork=true
#sh1_master.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh1/master_db
logpath=/usr/local/mongodb-sh/logs/sh1-master.log
bind_ip_all=true
shardsvr=true
logappend=true
replSet=sh1
port=27020
oplogSize=10000
fork=true
#sh1_salve.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh1/salve_db
logpath=/usr/local/mongodb-sh/logs/sh1-salve.log
bind_ip_all=true
shardsvr=true
logappend=true
replSet=sh1
port=27021
oplogSize=10000
fork=true
#sh1_arbite.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/sh1/arbite_db
logpath=/usr/local/mongodb-sh/logs/sh1-arbite.log
bind_ip_all=true
shardsvr=true
logappend=true
replSet=sh1
port=27022
oplogSize=10000
fork=true
#config_master.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/config_server/master_db
logpath=/usr/local/mongodb-sh/logs/config-master.log
bind_ip_all=true
configsvr=true  #是否是配置服务
logappend=true
replSet=cf
port=27030
oplogSize=10000
fork=true
#config_salve0.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/config_server/salve_db0
logpath=/usr/local/mongodb-sh/logs/config-salve0.log
bind_ip_all=true
configsvr=true
logappend=true
replSet=cf
port=27031
oplogSize=10000
fork=true
#config_salve1.conf配置文件内容
dbpath=/usr/local/mongodb-sh/data/db/config_server/salve_db1
logpath=/usr/local/mongodb-sh/logs/config-salve1.log
bind_ip_all=true
configsvr=true
logappend=true
replSet=cf
port=27032
oplogSize=10000
fork=true
#router.conf路由的配置文件内容
configdb=cf/127.0.0.1:27030,127.0.0.1:27031,127.0.0.1:27032
logpath=/usr/local/mongodb-sh/logs/router-master.log
bind_ip_all=true
port=27040
fork=true

启动分片1服务

/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh0-master.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh0-salve.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh0-arbite.conf

连接分片1

/usr/local/mongosh/bin/mongosh --port 27010
#然后使用use admin以后 初始化(下面的代码)

初始化分片1

rs.initiate({  //复制集初始化
    _id:"sh0", //复制集的名称 与几个配置文件相同
    members:[    //复制集成员信息
        {_id:0,host:"127.0.0.1:27010",priority:2},   //_id唯一标记 priority权重，越大优先级越高。host主机地址
        {_id:1,host:"127.0.0.1:27011",priority:1},
        {_id:2,host:"127.0.0.1:27012",arbiterOnly:true}  //arbiterOnly:是否是仲裁节点，权重越高越能成为主节点
    ]
});

启动分片2服务

/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh1-master.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh1-salve.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/sh1-arbite.conf

连接分片2

/usr/local/mongosh/bin/mongosh --port 27020
#然后使用use admin以后 初始化(下面的代码)

初始化分片2

rs.initiate({  //复制集初始化
    _id:"sh1", //复制集的名称 与几个配置文件相同
    members:[    //复制集成员信息
        {_id:0,host:"127.0.0.1:27020",priority:2},   //_id唯一标记 priority权重，越大优先级越高。host主机地址
        {_id:1,host:"127.0.0.1:27021",priority:1},
        {_id:2,host:"127.0.0.1:27022",arbiterOnly:true}  //arbiterOnly:是否是仲裁节点，权重越高越能成为主节点
    ]
});

启动config-server服务

/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/config-master.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/config-salve0.conf
/usr/local/mongodb-sh/bin/mongod --config /usr/local/mongodb-sh/conf/config-salve1.conf

连接config-server服务

/usr/local/mongosh/bin/mongosh --port 27030
#然后使用use admin以后 初始化(下面的代码)

初始化config-server

rs.initiate({  //复制集初始化
    _id:"cf", //复制集的名称 与几个配置文件相同
    members:[    //复制集成员信息
        {_id:0,host:"127.0.0.1:27030",priority:2},   //_id唯一标记 priority权重，越大优先级越高。host主机地址
        {_id:1,host:"127.0.0.1:27031",priority:1},
        {_id:2,host:"127.0.0.1:27032",priority:1}  //注意没有仲裁地址
    ]
});

启动router路由服务(注意：路由启动用mongos不是mongod)

/usr/local/mongodb-sh/bin/mongos --config /usr/local/mongodb-sh/conf/router.conf

连接router路由服务

/usr/local/mongosh/bin/mongosh --port 27040
#然后使用use admin以后

注意MongoDB6以后直接在路由中加入分片信息会报错
在admin角色下，执行:

db.adminCommand({
  "setDefaultRWConcern" : 1,
  "defaultWriteConcern" : {
    "w" : 2  #这里的数量是分片排除仲裁节点以后的节点总数
  }
});

然后路由服务中加入分片信息:

db.runCommand({'addShard':'sh0/127.0.0.1:27010,127.0.0.1:27011,127.0.0.1:27012'});
db.runCommand({'addShard':'sh1/127.0.0.1:27020,127.0.0.1:27021,127.0.0.1:27022'});

开启Shard
首先需要将Database开启sharding，否则数据仍然无法在集群中分布，即数据库、collection默认为non-sharding。对于non-sharding的database或者collection均会保存在primary shard上，直到开启sharding才会在集群中分布。
创建测试库:

use test

开启Shard，开启分片命令必须在admin库下运行。

db.runCommand({ enablesharding: 'test'})

此后我们可以对collection开启sharding，在此之前需要先指定shard key和建立“shard key索引”，我们根据application对数据访问的模式，来设定shard key。
需要切换进入到对应的库中：

use test
db.users.ensureIndex({'alias':'hashed'});

设置集合为可分片集合的命令，必须在admin库中执行。

db.runCommand({ shardcollection: 'test.users', key: {'alias': 'hashed'}})

那么users集合将使用“alias”作为第一维shard key，采用hashed分区模式，将此chunk分裂成2个，我们可以通过sh.status()查看每个chunk的分裂区间。
至此，分片集群搭建完毕。