MongoDB 分片集群-Sharded Cluster 搭建

最新推荐文章于 2021-12-29 23:06:45 发布

丶Wilson

最新推荐文章于 2021-12-29 23:06:45 发布

阅读量415

点赞数

本文链接：https://blog.csdn.net/dsen726/article/details/105681574

版权

1. 分片概念

分片（sharding）是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。
换句话说：分片(sharding)是指将数据拆分，将其分散存在不同的机器上的过程。有时也用分区 (partitioning)来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以储存更多的数据，处理更多的负载。
具有大型数据集或高吞吐量应用程序的数据库系统可以会挑战单个服务器的容量。例如，高查询率会耗尽服务器的CPU容量。工作集大小大于系统的RAM会强调磁盘驱动器的I / O容量。
有两种解决系统增长的方法：垂直扩展和水平扩展。
垂直扩展意味着增加单个服务器的容量，例如使用更强大的CPU，添加更多RAM或增加存储空间量。可用技术的局限性可能会限制单个机器对于给定工作负载而言足够强大。此外，基于云的提供商基于可用的硬件配置具有硬性上限。结果，垂直缩放有实际的最大值。
水平扩展意味着划分系统数据集并加载多个服务器，添加其他服务器以根据需要增加容量。虽然单个机器的总体速度或容量可能不高，但每台机器处理整个工作负载的子集，可能提供比单个高速大容量服务器更高的效率。扩展部署容量只需要根据需要添加额外的服务器，这可能比单个机器的高端硬件的总体成本更低。权衡是基础架构和部署维护的复杂性增加。
MongoDB支持通过分片进行水平扩展

2. 分片集群包含的组件

MongoDB分片群集包含以下组件：分片（存储）：每个分片包含分片数据的子集。每个分片都可以部署为副本集。
mongos（路由）：mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口。
conﬁg servers（“调度”的配置）：
配置服务器存储分片群集的元数据和配置设置,还存储身份验证配置信息，例如基于角色的访问控制或群集的内部身份验证设置;MongoDB还使用配置服务器来管理分布式锁。从MongoDB 3.4开始，必须将配置服务器部署为副本集（CSRS）。
下图描述了分片集群中组件的交互：

MongoDB在集合级别对数据进行分片，将集合数据分布在集群中的分片上。
27018 if mongod is a shard member；
27019 if mongod is a conﬁg server member

3. 分片集群架构目标

两个分片节点副本集（3+3）+一个配置节点副本集（3）+两个路由节点（2），共11个服务节点

4. 分片（存储）节点副本集的创建

所有的的配置文件都直接放到 sharded_cluster 的相应的子目录下面，默认配置文件名字：
mongod.yml

4.1 第一套副本集

准备存放数据和日志的目录：

#-----------myshardrs01 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/data/db \ &
mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/data/db \ &
mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/data/db

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27018/mongod.yml

myshardrs01_27018：

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27018/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27018
replication:
    #副本集的名称
    replSetName:  myshardrs01
sharding:
    #分片角色
    clusterRole: shardsvr

注意：
设置sharding.clusterRole需要mongod实例运行复制。要将实例部署为副本集成员，请使用 replSetName设置并指定副本集的名称。
新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27118/mongod.yml

myshardrs01_27118：

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs01_27118/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27118/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27118/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27118
replication:
    #副本集的名称
    replSetName:  myshardrs01
sharding:
    #分片角色
    clusterRole: shardsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs01_27218/mongod.yml

myshardrs01_27218：

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs01_27218/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs01_27218/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27218/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27218
replication:
    #副本集的名称
    replSetName:  myshardrs01
sharding:
    #分片角色
    clusterRole: shardsvr

启动第一套副本集：一主一副本一仲裁
依次启动三个mongod服务：

[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123223 
child process started successfully, parent exiting
[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123292 
child process started successfully, parent exiting 
[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf 
about to fork child process, waiting until server is ready for connections. 
forked process: 123326 
child process started successfully, parent exiting

查看服务是否启动：

[root@localhost mymongos_27017]# ps -ef|grep mongod
root       9731      1  0 02:07 ?        00:03:53 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.yml
root       9759      1  0 02:07 ?        00:03:56 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.yml
root       9787      1  0 02:07 ?        00:02:49 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.yml

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27018

执行初始化副本集命令：

> rs.initiate()

出现如下图结果证明成功：

{        "ok" : "1", 
...... 
}

查看副本集情况(节选内容)：

myshardrs01:SECONDARY> rs.status() 
{        "set" : "myshardrs01", 
...... 
}

（2）主节点配置查看：

myshardrs01:PRIMARY> rs.conf() 
{ 
  "_id" : "myshardrs01",       
 "version" : 1,        
  "protocolVersion" : NumberLong(1),        
  "writeConcernMajorityJournalDefault" : true,        
  "members" : [                
        { "_id" : 0,
          "host" : "192.168.0.48:27018", 
          "arbiterOnly" : false,                        
          "buildIndexes" : true,                        
          "hidden" : false,                        
           "priority" : 1,                        
  "tags" : {
                        
   },                        
   "slaveDelay" : NumberLong(0),                        
   "votes" : 1                
  }        
],

（3）添加副本节点：

myshardrs01:PRIMARY> rs.add("192.168.0.48:27118") 
{        "ok" : 1,
        "operationTime" : Timestamp(1564593626, 1),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564593626, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

（4）添加仲裁节点：

myshardrs01:PRIMARY> rs.addArb("192.168.0.48:27218") {
        "ok" : 1,
        "operationTime" : Timestamp(1564593675, 1),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564593675, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看副本集的配置情况：

myshardrs01:PRIMARY> rs.conf()
{
	"_id" : "myshardrs01",
	"version" : 3,
	"protocolVersion" : NumberLong(1),
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.0.48:27018",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "192.168.0.48:27118",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "192.168.0.48:27218",
			"arbiterOnly" : true,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 0,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		}
	],
	"settings" : {
		"chainingAllowed" : true,
		"heartbeatIntervalMillis" : 2000,
		"heartbeatTimeoutSecs" : 10,
		"electionTimeoutMillis" : 10000,
		"catchUpTimeoutMillis" : -1,
		"catchUpTakeoverDelayMillis" : 30000,
		"getLastErrorModes" : {
			
		},
		"getLastErrorDefaults" : {
			"w" : 1,
			"wtimeout" : 0
		},
		"replicaSetId" : ObjectId("5ea0889b6b5d2823dfee58c1")
	}
}

4.2 第二套副本集

准备存放数据和日志的目录：

#-----------myshardrs02 
mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/data/db \ &
mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/data/db \ &
mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/log \ & 
mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/data/db

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs02_27318/mongod.yml

myshardrs02_27318：

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27318/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27318
replication:
    #副本集的名称
    replSetName:  myshardrs02
sharding:
    #分片角色
    clusterRole: shardsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs02_27418/mongod.yml

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs02_27418/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27418/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27418/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27418
replication:
    #副本集的名称
    replSetName:  myshardrs02
sharding:
    #分片角色
    clusterRole: shardsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myshardrs02_27518/mongod.yml

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myshardrs02_27518/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myshardrs02_27518/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27518/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27518
replication:
    #副本集的名称
    replSetName:  myshardrs02
sharding:
    #分片角色
    clusterRole: shardsvr

启动第二套副本集：一主一副本一仲裁

依次启动三个mongod服务：

[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27318/mongod.yml 
about to fork child process, waiting until server is ready for connections. 
forked process: 123223 
child process started successfully, parent exiting
[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.yml 
about to fork child process, waiting until server is ready for connections. 
forked process: 123292 
child process started successfully, parent exiting 
[root@localhost bin]# /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27518/mongod.yml 
about to fork child process, waiting until server is ready for connections. 
forked process: 123326 
child process started successfully, parent exiting

查看服务是否启动：

ps -ef|grep mongod

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27318

执行初始化副本集命令：

> rs.initiate()

出现如下图结果证明成功：

{        "ok" : "1", 
...... 
}

查看副本集情况(节选内容)：

myshardrs01:SECONDARY> rs.status() 
{        "set" : "myshardrs01", 
...... 
}

（2）主节点配置查看：

myshardrs01:PRIMARY> rs.conf() 
{ 
  "_id" : "myshardrs02",       
 "version" : 1,        
  "protocolVersion" : NumberLong(1),        
  "writeConcernMajorityJournalDefault" : true,        
  "members" : [                
        { "_id" : 0,
          "host" : "192.168.0.48:27318", 
          "arbiterOnly" : false,                        
          "buildIndexes" : true,                        
          "hidden" : false,                        
           "priority" : 1,                        
  "tags" : {
                        
   },                        
   "slaveDelay" : NumberLong(0),                        
   "votes" : 1                
  }        
],

（3）添加副本节点：

myshardrs01:PRIMARY> rs.add("192.168.0.48:27418") 
{        "ok" : 1,
        "operationTime" : Timestamp(1564593626, 1),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564593626, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

（4）添加仲裁节点：

myshardrs01:PRIMARY> rs.addArb("192.168.0.48:27518") {
        "ok" : 1,
        "operationTime" : Timestamp(1564593675, 1),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564593675, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看副本集的配置情况：

myshardrs01:PRIMARY> rs.conf()
{
	"_id" : "myshardrs01",
	"version" : 3,
	"protocolVersion" : NumberLong(1),
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.0.48:27318",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "192.168.0.48:27418",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "192.168.0.48:27518",
			"arbiterOnly" : true,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 0,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		}
	],
	"settings" : {
		"chainingAllowed" : true,
		"heartbeatIntervalMillis" : 2000,
		"heartbeatTimeoutSecs" : 10,
		"electionTimeoutMillis" : 10000,
		"catchUpTimeoutMillis" : -1,
		"catchUpTakeoverDelayMillis" : 30000,
		"getLastErrorModes" : {
			
		},
		"getLastErrorDefaults" : {
			"w" : 1,
			"wtimeout" : 0
		},
		"replicaSetId" : ObjectId("5ea0889b6b5d2823dfee58c1")
	}
}

5. 配置节点副本集的创建

第一步：准备存放数据和日志的目录：

#-----------configrs #建立数据节点data和日志目录 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/data/db \ &
mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/data/db \ &
mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/log \ & 
mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/data/db

新建或修改配置文件：

vim /mongodb/sharded_cluster/myconfigrs_27019/mongod.yml

myconﬁgrs_27019：

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27019/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27019
replication:
    #副本集的名称
    replSetName:  myconfigrs
sharding:
    #分片角色
    clusterRole: configsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myconfigrs_27119/mongod.yml

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myconfigrs_27119/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27119/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27119/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27119
replication:
    #副本集的名称
    replSetName:  myconfigrs
sharding:
    #分片角色
    clusterRole: configsvr

新建或修改配置文件：

vim /mongodb/sharded_cluster/myconfigrs_27219/mongod.yml

myconﬁgrs_27219

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/myconfigrs_27219/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
storage:
    #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。   
    dbPath: "/mongodb/sharded_cluster/myconfigrs_27219/data/db"
    journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复。      
        enabled: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27219/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27219
replication:
    #副本集的名称
    replSetName:  myconfigrs
sharding:
    #分片角色
    clusterRole: configsvr

启动配置副本集：一主两副本
依次启动三个mongod服务：

 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27019/mongod.yml
 /usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27119/mongod.yml
/usr/local/mongodb/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27219/mongod.yml

查看服务是否启动：

ps -ef |grep mongod

（1）初始化副本集和创建主节点：
使用客户端命令连接任意一个节点，但这里尽量要连接主节点：

/usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27019

执行初始化副本集命令：

> rs.initiate()

（3）添加两个副本节点：

 rs.add("192.168.0.48:27119") 
 rs.add("192.168.0.48:27219")

查看副本集的配置情况：

 rs.conf() 
 rs.status()

6. 路由节点的创建和操作

6.1 第一个路由节点的创建和连接

第一步：准备存放数据和日志的目录：

#-----------mongos01 mkdir -p /mongodb/sharded_cluster/mymongos_27017/log

mymongos_27017节点：
新建或修改配置文件：

vim /mongodb/sharded_cluster/mymongos_27017/mongos.yml

mongos.yml

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/mymongos_27017/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。   
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID   
    pidFilePath: "/mongodb/sharded_cluster/mymongos_27017/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip   
    #bindIpAll: true   
    #服务实例绑定的IP   
    bindIp: localhost,192.168.0.48
    #bindIp   
    #绑定的端口   
    port: 27017
sharding:
    #指定配置节点副本集
    configDB: myconfigrs/192.168.0.48:27019,192.168.0.48:27119,192.168.0.48:27219

启动mongos：

/usr/local/mongodb/bin/mongos -f /mongodb/sharded_cluster/mymongos_27017/mongos.yml

提示：启动如果失败，可以查看log目录下的日志，查看失败原因。
客户端登录mongos，

/usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27017

此时，写不进去数据，如果写数据会报错：

mongos> use aadb switched to db aadb mongos> db.aa.insert({aa:"aa"})
 WriteCommandError({
        "ok" : 0,
        "errmsg" : "unable to initialize targeter for write op for collection aa.aa :: caused by :: Database aa not found :: caused by :: No shards found",
        "code" : 70,
        "codeName" : "ShardNotFound",
        "operationTime" : Timestamp(1564600123, 2),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564600123, 2),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 })

原因：
通过路由节点操作，现在只是连接了配置节点，还没有连接分片数据节点，因此无法写入业务数据。

6.2 在路由节点上进行分片配置操作

使用命令添加分片：
（1）添加分片：
语法：

sh.addShard("IP:Port")

将第一套分片副本集添加进来：

mongos> sh.addShard("myshardrs01/192.168.0.48:27018,192.168.0.48:27118,192.168.0.48:27218") {
        "shardAdded" : "myshardrs01",
        "ok" : 1,
        "operationTime" : Timestamp(1564611970, 4),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564611970, 4),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看分片状态情况：

mongos> sh.status() 
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5ea0a4d493f9cedfd24aff20")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.0.48:27018,192.168.0.48:27118",  "state" : 1 }
  active mongoses:
        "3.6.17" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "audit",  "primary" : "myshardrs02",  "partitioned" : true }
                audit.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(2, 2) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(2, 3) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(2, 4) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(2, 5) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

继续将第二套分片副本集添加进来：

mongos> sh.addShard("myshardrs01/192.168.0.48:27318,192.168.0.48:27418,192.168.0.48:27518") {
        "shardAdded" : "myshardrs01",
        "ok" : 1,
        "operationTime" : Timestamp(1564611970, 4),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564611970, 4),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看分片状态：

mongos>  sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5ea0a4d493f9cedfd24aff20")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.0.48:27018,192.168.0.48:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.0.48:27318,192.168.0.48:27418",  "state" : 1 }
  active mongoses:
        "3.6.17" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "audit",  "primary" : "myshardrs02",  "partitioned" : true }
                audit.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(2, 2) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(2, 3) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(2, 4) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(2, 5) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

提示：如果添加分片失败，需要先手动移除分片，检查添加分片的信息的正确性后，再次添加分片。
移除分片参考(了解)：

use admin 
db.runCommand( { removeShard: "myshardrs02" } )

注意：如果只剩下最后一个shard，是无法删除的
移除时会自动转移分片数据，需要一个时间过程。
完成后，再次执行删除分片命令才能真正删除。
（2）开启分片功能：sh.enableSharding(“库名”)、sh.shardCollection(“库名.集合名”,{“key”:1})
在mongos上的audit数据库配置sharding:

mongos> sh.enableSharding("audit") {
        "ok" : 1,
        "operationTime" : Timestamp(1564612296, 5),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564612296, 5),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看分片状态：

mongos>  sh.status() 
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5ea0a4d493f9cedfd24aff20")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.0.48:27018,192.168.0.48:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.0.48:27318,192.168.0.48:27418",  "state" : 1 }
  active mongoses:
        "3.6.17" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "audit",  "primary" : "myshardrs02",  "partitioned" : true }
                audit.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(2, 2) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(2, 3) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(2, 4) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(2, 5) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

（3）集合分片
对集合分片，你必须使用 sh.shardCollection() 方法指定集合和分片键。
语法：

sh.shardCollection(namespace, key, unique)

参数：

Parameter	Type	Description
namespace	string	要（分片）共享的目标集合的命名空间，格式： .

key	document	用作分片键的索引规范文档。shard键决定MongoDB如何在 shard之间分发文档。除非集合为空，否则索引必须在shard collection命令之前存在。如果集合为空，则MongoDB在对集合进行分片之前创建索引，前提是支持分片键的索引不存在。简单的说：由包含字段和该字段的索引遍历方向的文档组成。
unique	boolean	当值为true情况下，片键字段上会限制为确保是唯一索引。哈希策略片键不支持唯一索引。默认是false。

对集合进行分片时,你需要选择一个片键（Shard Key） , shard key 是每条记录都必须包含的,且建立了索引的单个字段或复合字段,MongoDB按照片键将数据划分到不同的数据块中,并将数据块均衡地分布到所有分片中.为了按照片键划分数据块,MongoDB使用基于哈希的分片方式（随机平均分配）或者基于范围的分片方式（数值大小分配）。
用什么字段当片键都可以，如：nickname作为片键，但一定是必填字段。
分片规则一：哈希策略
对于基于哈希的分片 ,MongoDB计算一个字段的哈希值,并用这个哈希值来创建数据块. 在使用基于哈希分片的系统中,拥有”相近”片键的文档很可能不会存储在同一个数据块中,因此数据的分离性更好一些.
使用nickname作为片键，根据其值的哈希值进行数据分片

mongos> sh.shardCollection("audit.comment",{"nickname":"hashed"}) {
        "collectionsharded" : "articledb.comment",
        "collectionUUID" : UUID("ddea6ed8-ee61-4693-bd16-196acc3a45e8"),
        "ok" : 1,
        "operationTime" : Timestamp(1564612840, 28),
        "$clusterTime" : {
                "clusterTime" : Timestamp(1564612840, 28), 
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        }
 }

查看分片状态：

sh.status()

mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5ea0a4d493f9cedfd24aff20")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.0.48:27018,192.168.0.48:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.0.48:27318,192.168.0.48:27418",  "state" : 1 }
  active mongoses:
        "3.6.17" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "audit",  "primary" : "myshardrs02",  "partitioned" : true }
                audit.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(2, 2) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(2, 3) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(2, 4) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(2, 5) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

分片规则二：范围策略
对于基于范围的分片 ,MongoDB按照片键的范围把数据分成不同部分.假设有一个数字的片键:想象一个从负无穷到正无穷的直线,每一个片键的值都在直线上画了一个点.MongoDB把这条直线划分为更短的不重叠的片段,并称之为数据块 ,每个数据块包含了片键在一定范围内的数据.
在使用片键做范围划分的系统中,拥有”相近”片键的文档很可能存储在同一个数据块中,因此也会存储在同一个分片中.
如使用作者年龄字段作为片键，按照点赞数的值进行分片：

mongos> sh.shardCollection("audit.author",{"age":1})
{
	"collectionsharded" : "audit.author",
	"collectionUUID" : UUID("3ac51fc2-8d7f-44db-bd13-fa416f5143d1"),
	"ok" : 1,
	"operationTime" : Timestamp(1587742543, 13),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1587742543, 13),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

注意的是：
1）一个集合只能指定一个片键，否则报错。
2）一旦对一个集合分片，分片键和分片值就不可改变。如：不能给集合选择不同的分片键、不能更新分片键的值。
3）根据age索引进行分配数据。

查看分片状态：

mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("5ea0a4d493f9cedfd24aff20")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.0.48:27018,192.168.0.48:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.0.48:27318,192.168.0.48:27418",  "state" : 1 }
  active mongoses:
        "3.6.17" : 1
  autosplit:
        Currently enabled: yes
  balancer:
        Currently enabled:  yes
        Currently running:  no
        Failed balancer rounds in last 5 attempts:  0
        Migration Results for the last 24 hours: 
                No recent migrations
  databases:
        {  "_id" : "audit",  "primary" : "myshardrs02",  "partitioned" : true }
                audit.author
                        shard key: { "age" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs02	1
                        { "age" : { "$minKey" : 1 } } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(1, 0) 
                audit.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(2, 2) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(2, 3) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(2, 4) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(2, 5) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 0)

基于范围的分片方式与基于哈希的分片方式性能对比：
基于范围的分片方式提供了更高效的范围查询,给定一个片键的范围,分发路由可以很简单地确定哪个数据块存储了请求需要的数据,并将请求转发到相应的分片中. 不过,基于范围的分片会导致数据在不同分片上的不均衡,有时候,带来的消极作用会大于查询性能的积极作用.比如,如果片键所在的字段是线性增长的,一定时间内的所有请求都会落到某个固定的数据块中,最终导致分布在同一个分片中.在这种情况下,一小部分分片承载了集群大部分的数据,系统并不能很好地进行扩展.
与此相比,基于哈希的分片方式以范围查询性能的损失为代价,保证了集群中数据的均衡.哈希值的随机性使数据随机分布在每个数据块中,因此也随机分布在不同分片中.但是也正由于随机性,一个范围查询很难确定应该请求哪些分片,通常为了返回需要的结果,需要请求所有分片. 如无特殊情况，一般推荐使用 Hash Sharding。
而使用 _id 作为片键是一个不错的选择，因为它是必有的，你可以使用数据文档 _id 的哈希作为片键。
这个方案能够是的读和写都能够平均分布，并且它能够保证每个文档都有不同的片键所以数据块能够很精细。
似乎还是不够完美，因为这样的话对多个文档的查询必将命中所有的分片。虽说如此，这也是一种比较好的方案了。
理想化的 shard key 可以让 documents 均匀地在集群中分布：
在这里插入图片描述
显示集群的详细信息：

mongos> db.printShardingStatus()

查看均衡器是否工作（需要重新均衡时系统才会自动启动，不用管它）：

mongos> sh.isBalancerRunning()
 false

查看当前Balancer状态：

mongos> sh.getBalancerState()
 true

6.3 分片后插入数据测试
测试一（哈希规则）：登录mongs后，向comment循环插入1000条数据做测试：

mongos> use audit
switched to db audit
mongos> for(var i=1;i<=1000;i++) {db.comment.insert({_id:i+"",nickname:"BoBo"+i})}

提示：js的语法，因为mongo的shell是一个JavaScript的shell。
注意：从路由上插入的数据，必须包含片键，否则无法插入。

分别登陆两个片的主节点，统计文档数量
第一个分片副本集：

/usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27018

第一个分片副本集：

[root@localhost /]# /usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27018
MongoDB shell version v3.6.17
connecting to: mongodb://192.168.0.48:27018/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("4ed56026-dbf4-4269-bf2a-a2e8ce5d3dae") }
MongoDB server version: 3.6.17
Server has startup warnings: 
2020-04-23T02:07:31.298+0800 I CONTROL  [initandlisten] 
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] ** WARNING: Access control is not enabled for the database.
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] **          Read and write access to data and configuration is unrestricted.
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] ** WARNING: You are running this process as the root user, which is not recommended.
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] 
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] 
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] 
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-04-23T02:07:31.299+0800 I CONTROL  [initandlisten] 
myshardrs01:PRIMARY> show dbs
admin   0.000GB
audit   0.000GB
config  0.000GB
local   0.001GB
myshardrs01:PRIMARY> use audit
switched to db audit
myshardrs01:PRIMARY> show collections
comment
myshardrs01:PRIMARY> db.comment.count()
507

第二个分片副本集：

[root@localhost /]# /usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27318
MongoDB shell version v3.6.17
connecting to: mongodb://192.168.0.48:27318/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("b66499c8-ffa1-4ad2-a9a9-34c4dfab1eed") }
MongoDB server version: 3.6.17
Server has startup warnings: 
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] 
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] ** WARNING: Access control is not enabled for the database.
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] **          Read and write access to data and configuration is unrestricted.
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] ** WARNING: You are running this process as the root user, which is not recommended.
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] 
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] 
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] 
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'
2020-04-23T02:49:57.708+0800 I CONTROL  [initandlisten] 
myshardrs02:PRIMARY> show dbs
admin   0.000GB
audit   0.000GB
config  0.000GB
local   0.001GB
myshardrs02:PRIMARY> use audit
switched to db audit
myshardrs02:PRIMARY> show collections
Test
author
comment
myshardrs02:PRIMARY> db.comment.count()
493

可以看到，1000条数据近似均匀的分布到了2个shard上。是根据片键的哈希值分配的。
这种分配方式非常易于水平扩展：一旦数据存储需要更大空间，可以直接再增加分片即可，同时提升了性能。
使用db.comment.stats()查看单个集合的完整情况，mongos执行该命令可以查看该集合的数据分片的情况。
使用sh.status()查看本库内所有集合的分片信息。
测试二（范围规则）：登录mongs后，向comment循环插入1000条数据做测试：

[root@localhost /]# /usr/local/mongodb/bin/mongo --host 192.168.0.48 --port 27017
MongoDB shell version v3.6.17
connecting to: mongodb://192.168.0.48:27017/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("d6b9a136-f320-4a35-823a-c13b30e27f04") }
MongoDB server version: 3.6.17
Server has startup warnings: 
2020-04-23T17:22:15.907+0800 I CONTROL  [main] 
2020-04-23T17:22:15.907+0800 I CONTROL  [main] ** WARNING: Access control is not enabled for the database.
2020-04-23T17:22:15.907+0800 I CONTROL  [main] **          Read and write access to data and configuration is unrestricted.
2020-04-23T17:22:15.907+0800 I CONTROL  [main] ** WARNING: You are running this process as the root user, which is not recommended.
2020-04-23T17:22:15.907+0800 I CONTROL  [main] 
mongos> show dbs
admin   0.000GB
audit   0.000GB
config  0.001GB
mongos> use audit
switched to db audit
mongos> show collections
Test
author
comment
mongos> db.comment.count()
1000
mongos> for(var i=1;i<=20000;i++) {db.author.save({"name":"BoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoB oBoBoBoBoBoBoBoBo"+i,"age":NumberInt(i%120)})} 
WriteResult({ "nInserted" : 1 })
mongos> show collections
Test
author
comment
mongos> db.author.count()
20000

插入成功后，仍然要分别查看两个分片副本集的数据情况。
分片效果：

articledb.author
                        shard key: { "age" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01 2
                                myshardrs02 1 
                        { "age" : { "$minKey" : 1 } } -->> { "age" : 0 } on : myshardrs02 Timestamp(2, 0)
                        { "age" : 0 } -->> { "age" : 112 } on : myshardrs01 Timestamp(2, 1)
                        { "age" : 112 } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs01 Timestamp(1, 3)

提示：
如果查看状态发现没有分片，则可能是由于以下原因造成了：
1）系统繁忙，正在分片中。
2）数据块（chunk）没有填满，默认的数据块尺寸（chunksize）是64M，填满后才会考虑向其他片的数据块填充数据，因此，为了测试，可以将其改小，这里改为1M，操作如下：

use config db.settings.save( { _id:"chunksize", value: 1 } )

测试完改回来：

db.settings.save( { _id:"chunksize", value: 64 } )

注意：要先改小，再设置分片。为了测试，可以先删除集合，重新建立集合的分片策略，再插入数据测试即可。

6.4 再增加一个路由节点

#-----------mongos02 
mkdir -p /mongodb/sharded_cluster/mymongos_27117/log

新建或修改配置文件：

vi /mongodb/sharded_cluster/mymongos_27117/mongos.yml

mongos.yml

systemLog:
    #MongoDB发送所有日志输出的目标指定为文件
    destination: file
    #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
    path: "/mongodb/sharded_cluster/mymongos_27117/log/mongod.log"
    #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
    logAppend: true
processManagement:
    #启用在后台运行mongos或mongod进程的守护进程模式。
    fork: true
    #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
    pidFilePath: "/mongodb/sharded_cluster/mymongos_27117/log/mongod.pid"
net:
    #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
    #bindIpAll: true
    #服务实例绑定的IP
    bindIp: localhost,192.168.0.48
    #bindIp
    #绑定的端口
    port: 27117
sharding:
    #指定配置节点副本集
    configDB: myconfigrs/192.168.0.48:27019,192.168.0.48:27119,192.168.0.48:27219

启动mongos2：

[root@localhost mymongos_27117]# /usr/local/mongodb/bin/mongos -f /mongodb/sharded_cluster/mymongos_27117/mongos.yml
about to fork child process, waiting until server is ready for connections.
forked process: 22241
child process started successfully, parent exiting

使用mongo客户端登录27117，发现，第二个路由无需配置，因为分片配置都保存到了配置服务器中了。

丶Wilson

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MongoDB 分片集群-Sharded Cluster 搭建

1. 分片概念分片（sharding）是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。换句话说：分片(sharding)是指将数据拆分，将其分散存在不同的机器上的过程。有时也用分区 (partitioning)来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以储存更多的数据，处理更多的负载。具有大型数据集或高...
复制链接

扫一扫