MongoDB 分片集群

已于 2023-10-17 11:11:04 修改
阅读量676 收藏
点赞数
分类专栏： MongoDB 文章标签： mongodb
于 2023-10-16 15:36:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhf852963/article/details/133852616
版权

一、分片概念

        分片（sharding）是一种跨多台机器分布数据的方法， MongoDB 使用分片来支持具有非常大的数据集和高吞吐量操作的部署。

        换句话说：分片（sharding）是指将数据拆分，将其分散存在不同的机器上的过程。有时也用分区（partitioning）来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以储存更多的数据，处理更多的负载。

        具有大型数据集或高吞吐量应用程序的数据库系统可能会挑战单个服务器的容量。例如，高查询率会耗尽服务器的 CPU 容量。工作集大小大于系统的 RAM 会强调磁盘驱动器的 I / O 容量。

        有两种解决系统增长的方法：垂直扩展和水平扩展。

        垂直扩展意味着增加单个服务器的容量，例如使用更强大的 CPU，添加更多 RAM 或增加存储空间量。可用技术的局限性可能会限制单个机器对于给定工作负载而言足够强大。此外，基于云的提供商基于可用的硬件配置具有硬性上限。结果，垂直缩放有实际的最大值。

        水平扩展意味着划分系统数据集并加载多个服务器，添加其他服务器以根据需要增加容量。虽然单个机器的总体速度或容量可能不高，但每台机器处理整个工作负载的子集，可能提供比单个高速大容量服务器更高的效率。扩展部署容量只需要根据需要添加额外的服务器，这可能比单个机器的高端硬件的总体成本更低。权衡是基础架构和部署维护的复杂性增加。

        MongoDB 支持通过分片进行水平扩展。

二、分片集群包含的组件

MongoDB 分片群集包含以下组件：

        a、分片（存储）：每个分片包含分片数据的子集。 每个分片都可以部署为副本集。

        b、mongos（路由）：mongos 充当查询路由器，在客户端应用程序和分片集群之间提供接口。

        c、config servers（“调度”的配置）：配置服务器存储群集的元数据和配置设置。 从MongoDB 3.4 开始，必须将配置服务器部署为副本集（CSRS）。

        下图描述了分片集群中组件的交互，其中 MongoDB 在集合级别对数据进行分片，将集合数据分布在集群中的分片上。

三、分片集群的架构目标

        包括两个分片节点副本集（3+3）+一个配置节点副本集（3）+两个路由节点，一共 11 个节点服务。如下图所示：

四、分片节点副本集创建

4.1 第一套副本集创建

        创建存放数据和日志的目录，命令如下：

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27018/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27018/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27118/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27118/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27218/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs01_27218/data/db

        新建 27018 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf

        27018 的配置文件内容如下：

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

        需要注意的是：clusterRole 的可选项只有 configsvr（配置服务） 和 shardsvr（分片服务），在此处我们搭建的副本集就属于分片服务。

        新建 27118 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf

        27118 的配置文件内容如下：

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

        新建 27218 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf

        27218 的配置文件内容如下：

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

        依次启动三个 mongodb 服务

# 启动主节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf


# 启动副本节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf

# 启动仲裁节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
# 查看服务是否启动成功
[root@node1 db]# ps -ef | grep mongo
root      79379      1  0 23:32 ?        00:00:12 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
root      90640      1  0 20:14 ?        00:01:12 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
root      90673      1  0 20:14 ?        00:01:13 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
root      92359  62119  0 23:53 pts/1    00:00:00 grep --color=auto mongo

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

/usr/local/mongodb/bin/mongo --host 192.168.229.154 --port 27018
# 初始化副本集命令
> rs.initiate()
{
	"info2" : "no configuration specified. Using a default configuration for the set",
	"me" : "192.168.229.154:27018",
	"ok" : 1
}
myshardrs01:SECONDARY> 

# 添加副本节点
myshardrs01:PRIMARY> rs.add("192.168.229.154:27118")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697439387, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697439387, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 添加仲裁节点
myshardrs01:PRIMARY> rs.addArb("192.168.229.154:27218")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697439405, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697439405, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 查看副本集的配置情况
myshardrs01:PRIMARY> rs.conf()
{
	"_id" : "myshardrs01",
	"version" : 3,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.229.154:27018",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "192.168.229.154:27118",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "192.168.229.154: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("652cde750805d80f8574fda4")
	}
}
myshardrs01:PRIMARY>

4.2 第二套副本集创建

         创建存放数据和日志的目录，命令如下：

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27318/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27318/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27418/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27418/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27518/log
mkdir -p /usr/local/mongodb/sharded_cluster/myshardrs02_27518/data/db

        新建 27318 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs02_27318/mongod.conf

        27318 的配置文件内容如下：

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

        新建 27418 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs02_27418/mongod.conf

        27418 的配置文件内容如下：

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

        新建 27518 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myshardrs02_27518/mongod.conf

        27518 的配置文件内容如下：

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

        依次启动三个 mongodb 服务

# 启动主节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27318/mongod.conf


# 启动副本节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27418/mongod.conf

# 启动仲裁节点
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
# 查看服务是否启动成功
[root@node1 db]# ps -ef | grep mongo
root      79379      1  0 Oct15 ?        00:00:22 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
root      90640      1  0 Oct15 ?        00:01:20 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
root      90673      1  0 Oct15 ?        00:01:23 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
root     102785      1  3 00:11 ?        00:00:00 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
root     102984      1  4 00:11 ?        00:00:00 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27418/mongod.conf
root     103018      1  6 00:11 ?        00:00:00 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
root     103189  62119  0 00:11 pts/1    00:00:00 grep --color=auto mongo

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

/usr/local/mongodb/bin/mongo --host 192.168.229.154 --port 27318
# 初始化副本集
> rs.initiate()
{
	"info2" : "no configuration specified. Using a default configuration for the set",
	"me" : "192.168.229.154:27318",
	"ok" : 1
}

# 添加副本节点
myshardrs02:SECONDARY> rs.add("192.168.229.154:27418")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697440445, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697440445, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 添加仲裁节点
myshardrs02:PRIMARY> rs.addArb("192.168.229.154:27518")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697440457, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697440457, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 查看副本集的配置情况
myshardrs02:PRIMARY> rs.conf()
{
	"_id" : "myshardrs02",
	"version" : 3,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.229.154:27318",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "192.168.229.154:27418",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "192.168.229.154: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("652ce2b023e3bc8d21b4fd3b")
	}
}
myshardrs02:PRIMARY>

五、配置节点副本集创建

         创建存放数据和日志的目录，命令如下：

mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27019/log
mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27019/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27119/log
mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27119/data/db

mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27219/log
mkdir -p /usr/local/mongodb/sharded_cluster/myconfigrs_27219/data/db

         新建 27019 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myconfigrs_27019/mongod.conf

        27019 的配置文件内容如下：

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

        新建 27119 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myconfigrs_27119/mongod.conf

        27119 的配置文件内容如下：

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

          新建 27219 的配置文件，命令如下：

vim /usr/local/mongodb/sharded_cluster/myconfigrs_27219/mongod.conf

        27219 的配置文件内容如下：

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

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

# 主
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27019/mongod.conf

# 从
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27119/mongod.conf

# 从
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27219/mongod.conf
# 查看服务是否启动成功
[root@node1 sharded_cluster]# ps -ef | grep mongo
root      79379      1  0 Oct15 ?        00:00:35 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
root      90640      1  0 Oct15 ?        00:01:28 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
root      90673      1  0 Oct15 ?        00:01:34 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
root     102785      1  0 00:11 ?        00:00:11 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
root     102984      1  0 00:11 ?        00:00:11 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27418/mongod.conf
root     103018      1  0 00:11 ?        00:00:08 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
root     114303      1  3 00:30 ?        00:00:01 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
root     114342      1  2 00:30 ?        00:00:01 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27119/mongod.conf
root     114531      1 36 00:30 ?        00:00:14 /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/sharded_cluster/myconfigrs_27219/mongod.conf
root     114765  62119  0 00:31 pts/1    00:00:00 grep --color=auto mongo

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

/usr/local/mongodb/bin/mongo --host 192.168.229.154 --port 27019
# 初始化副本集命令
> rs.initiate()
{
	"info2" : "no configuration specified. Using a default configuration for the set",
	"me" : "192.168.229.154:27019",
	"ok" : 1,
	"$gleStats" : {
		"lastOpTime" : Timestamp(1697441587, 1),
		"electionId" : ObjectId("000000000000000000000000")
	},
	"lastCommittedOpTime" : Timestamp(0, 0)
}
myconfigrs:SECONDARY> 

# 添加第一个副本节点
myconfigrs:PRIMARY> rs.add("192.168.229.154:27119")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697441633, 1),
	"$gleStats" : {
		"lastOpTime" : {
			"ts" : Timestamp(1697441633, 1),
			"t" : NumberLong(1)
		},
		"electionId" : ObjectId("7fffffff0000000000000001")
	},
	"lastCommittedOpTime" : Timestamp(1697441628, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697441633, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 添加第二个副本节点
myconfigrs:PRIMARY> rs.add("192.168.229.154:27219")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697441639, 1),
	"$gleStats" : {
		"lastOpTime" : {
			"ts" : Timestamp(1697441639, 1),
			"t" : NumberLong(1)
		},
		"electionId" : ObjectId("7fffffff0000000000000001")
	},
	"lastCommittedOpTime" : Timestamp(1697441633, 1),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697441639, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 查看副本集的配置情况
myconfigrs:PRIMARY> rs.conf()
{
	"_id" : "myconfigrs",
	"version" : 3,
	"configsvr" : true,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.229.154:27019",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 1,
			"host" : "192.168.229.154:27119",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" : NumberLong(0),
			"votes" : 1
		},
		{
			"_id" : 2,
			"host" : "192.168.229.154:27219",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"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("652ce7334991027264953cb0")
	}
}
myconfigrs:PRIMARY>

六、路由节点的创建和操作

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

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

mkdir -p /usr/local/mongodb/sharded_cluster/mymongos_27017/log

        新建配置文件

vi /usr/local/mongodb/sharded_cluster/mymongos_27017/mongos.conf

        内容如下：

systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: "/usr/local/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: /usr/local/mongodb/sharded_cluster/mymongos_27017/log/mongod.pid"
net:
  # 服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  # 服务实例绑定的IP
  bindIp: localhost,192.168.229.154
  #bindIp
  # 绑定的端口
  port: 27017
sharding:
  # 指定配置节点副本集
  configDB:
    myconfigrs/192.168.229.154:27019,192.168.229.154:27119,192.168.229.154:27219

        启动 mongos

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

        客户端登录 mongos

/usr/local/mongodb/bin/mongo --host 192.168.229.154 --port 27017
# 测试是否可以写入数据
mongos> use testdata
switched to db testdata

# 此时，写不进去数据，如果写数据会报错
mongos> db.aa.insert({aa:"aa"})
WriteCommandError({
	"ok" : 0,
	"errmsg" : "unable to initialize targeter for write op for collection testdata.aa :: caused by :: Database testdata not found :: caused by :: No shards found",
	"code" : 70,
	"codeName" : "ShardNotFound",
	"operationTime" : Timestamp(1697446461, 3),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697446461, 3),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
})
mongos>

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

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

6.2.1 添加分片

        添加分片语法如下：

sh.addShard("IP:Port")
# 将第一套分片副本集添加进来
mongos> sh.addShard("myshardrs01/192.168.229.154:27018,192.168.229.154:27118,192.168.229.154:27218")
{
	"shardAdded" : "myshardrs01",
	"ok" : 1,
	"operationTime" : Timestamp(1697447335, 5),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697447335, 5),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

# 查看分片状态情况
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
  active mongoses:
        "4.0.28" : 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" : "config",  "primary" : "config",  "partitioned" : true }

mongos> 
# 续将第二套分片副本集添加进来
mongos> sh.addShard("myshardrs02/192.168.229.154:27318,192.168.229.154:27418,192.168.229.154:27518")
{
	"shardAdded" : "myshardrs02",
	"ok" : 1,
	"operationTime" : Timestamp(1697447436, 4),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697447436, 4),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
# 查看分片状态
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  # 并未显示仲裁者的 ip
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.229.154:27318,192.168.229.154:27418",  "state" : 1 }
  active mongoses:
        "4.0.28" : 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: 
                13 : Success
  databases:
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	1011
                                myshardrs02	13
                        too many chunks to print, use verbose if you want to force print

mongos>

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

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

        注意：如果只剩下最后一个 shard，是无法删除的。移除时会自动转移分片数据，需要一个时间过程。完成后，再次执行删除分片命令才能真正删除。

6.2.2 开启分片功能

        语法如下：

sh.enableSharding("库名")
# 在 mongos 上的 articledb 数据库配置 sharding
mongos> sh.enableSharding("articledb")
{
	"ok" : 1,
	"operationTime" : Timestamp(1697447788, 11),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697447788, 11),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
# 查看分片状态
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.229.154:27318,192.168.229.154:27418",  "state" : 1 }
  active mongoses:
        "4.0.28" : 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: 
                336 : Success
  databases:
        {  "_id" : "articledb",  "primary" : "myshardrs02",  "partitioned" : true,  "version" : {  "uuid" : UUID("14943571-dd3e-4b0b-84c4-7d3a05d5e0a0"),  "lastMod" : 1 } }
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	688
                                myshardrs02	336
                        too many chunks to print, use verbose if you want to force print

mongos>

6.2.3 集合分片

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

sh.shardCollection(namespace, key, unique)

Parameter

Type

Description

namespace

string

要（分片）共享的目标集合的命名空间，格式： 数据库名称.集合名称

key

document

用作分片键的索引规范文档。shard 键决定 MongoDB 如何在 shard 之间分发文档。除非集合为空，否则索引必须在 shardcollection 命令之前存在。如果集合为空，则 MongoDB 在对集合进行分片之前创建索引，前提是支持分片键的索引不存在。简单的说：由包含字段和该字段的索引遍历方向的文档组成。

unique

boolean

当值为 true 情况下，片键字段上会限制为确保是唯一索引。哈希策略片键不支持唯一索引。默认是 false。

        对集合进行分片时，你需要选择一个 片键（Shard Key） , shard key 是每条记录都必须包含的，且建立了索引的单个字段或复合字段，MongoDB 按照片键将数据划分到不同的数据块中，并将数据块均衡地分布到所有分片中。

        为了按照片键划分数据块，MongoDB 使用基于哈希的分片方式（随机平均分配）或者基于范围的分片方式（数值大小分配） 。用什么字段当片键都可以，如：nickname 作为片键，但一定是必填字段。

分片规则一：哈希策略

        对于基于哈希的分片，MongoDB 计算一个字段的哈希值，并用这个哈希值来创建数据块。在使用基于哈希分片的系统中，拥有 ”相近” 片键的文档很可能不会存储在同一个数据块中，因此数据的分离性更好一些。

# 使用 nickname 作为片键，根据其值的哈希值进行数据分片
mongos> sh.shardCollection("articledb.comment",{"nickname":"hashed"})
{
	"collectionsharded" : "articledb.comment",
	"collectionUUID" : UUID("99e2298a-c8fe-49c1-b002-aed320ea6ac7"),
	"ok" : 1,
	"operationTime" : Timestamp(1697506381, 28),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697506381, 28),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
# 查看分片状态
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.229.154:27318,192.168.229.154:27418",  "state" : 1 }
  active mongoses:
        "4.0.28" : 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: 
                512 : Success
  databases:
        {  "_id" : "articledb",  "primary" : "myshardrs02",  "partitioned" : true,  "version" : {  "uuid" : UUID("14943571-dd3e-4b0b-84c4-7d3a05d5e0a0"),  "lastMod" : 1 } }
                articledb.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(1, 0) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(1, 1) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(1, 2) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(1, 3) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	512
                                myshardrs02	512
                        too many chunks to print, use verbose if you want to force print

分片规则二：范围策略

        对于基于范围的分片 ，MongoDB 按照片键的范围把数据分成不同部分。假设有一个数字的片键：想象一个从负无穷到正无穷的直线，每一个片键的值都在直线上画了一个点。MongoDB 把这条直线划分为更短的不重叠的片段，并称之为数据块 ，每个数据块包含了片键在一定范围内的数据。

        在使用片键做范围划分的系统中，拥有”相近”片键的文档很可能存储在同一个数据块中，因此也会存储在同一个分片中。

# 如使用作者年龄字段作为片键，按照点赞数的值进行分片
mongos> sh.shardCollection("articledb.author",{"age":1})
{
	"collectionsharded" : "articledb.author",
	"collectionUUID" : UUID("a8a72040-581c-4030-b152-99975eaafaac"),
	"ok" : 1,
	"operationTime" : Timestamp(1697506689, 13),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697506689, 13),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}

注意：

        a、一个集合只能指定一个片键，否则报错。

        b、一旦对一个集合分片，分片键和分片值就不可改变。 如：不能给集合选择不同的分片键、不能更新分片键的值。

        c、根据 age 索引进行分配数据。

# 查看分片状态
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.229.154:27318,192.168.229.154:27418",  "state" : 1 }
  active mongoses:
        "4.0.28" : 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: 
                512 : Success
  databases:
        {  "_id" : "articledb",  "primary" : "myshardrs02",  "partitioned" : true,  "version" : {  "uuid" : UUID("14943571-dd3e-4b0b-84c4-7d3a05d5e0a0"),  "lastMod" : 1 } }
                articledb.author
                        shard key: { "age" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs02	1
                        { "age" : { "$minKey" : 1 } } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(1, 0)

哈希策略和范围策略性能对比：

        基于范围的分片方式提供了更高效的范围查询，给定一个片键的范围，分发路由可以很简单地确定哪个数据块存储了请求需要的数据，并将请求转发到相应的分片中。

        不过，基于范围的分片会导致数据在不同分片上的不均衡。有时候带来的消极作用会大于查询性能的积极作用。比如，如果片键所在的字段是线性增长的，一定时间内的所有请求都会落到某个固定的数据块中，最终导致分布在同一个分片中。在这种情况下，一小部分分片承载了集群大部分的数据，系统并不能很好地进行扩展。

        与此相比，基于哈希的分片方式以范围查询性能的损失为代价，保证了集群中数据的均衡。哈希值的随机性使数据随机分布在每个数据块中，因此也随机分布在不同分片中。但是也正由于随机性，一个范围查询很难确定应该请求哪些分片，通常为了返回需要的结果，需要请求所有分片。

        如无特殊情况，一般推荐使用 Hash Sharding。

        而使用 _id 作为片键是一个不错的选择，因为它是必有的，你可以使用数据文档 _id 的哈希作为片键。

        这个方案能够使得读和写都能够平均分布，并且它能够保证每个文档都有不同的片键，所以数据块能够很精细。

        似乎还是不够完美，因为这样的话对多个文档的查询必将命中所有的分片。虽说如此，这也是一种比较好的方案了。

        理想化的 shard key 可以让 documents 均匀地在集群中分布：

6.3 分片后插入数据测试

6.3.1 测试哈希规则

        登录 mongs 后，向 comment 循环插入1000 条数据做测试

mongos> use articledb
switched to db articledb
mongos> db
articledb
# js 的语法，因为 mongo 的 shell 是一个 JavaScript 的 shell
# 从路由上插入的数据，必须包含片键，否则无法插入
mongos> for(var i=1;i<=1000;i++){db.comment.insert({_id:i+"",nickname:"BoBo"+i})}
WriteResult({ "nInserted" : 1 })
mongos> db.comment.count()
1000

        分别登陆两个片的主节点，统计文档数量

/usr/local/mongodb/bin/mongo --port 27018
# 第一个分片副本集
myshardrs01:PRIMARY> use articledb
switched to db articledb
myshardrs01:PRIMARY> db.comment.count()
507

        登录第二个分片副本集统计 

/usr/local/mongodb/bin/mongo --port 27318
# 第二个副本集
myshardrs02:PRIMARY> use articledb
switched to db articledb
myshardrs02:PRIMARY> db.comment.count()
493

        可以看到，1000 条数据近似均匀的分布到了 2 个 shard 上。是根据片键的哈希值分配的。

        这种分配方式非常易于水平扩展：一旦数据存储需要更大空间，可以直接再增加分片即可，同时提升了性能。

        使用 db.comment.stats() 查看单个集合的完整情况，mongos 执行该命令可以查看该集合的数据分片的情况。

        使用 sh.status() 查看本库内所有集合的分片信息。

6.3.2 测试范围规则

        登录 mongs 后，向 author 循环插入 20000 条数据做测试

mongos> use articledb
switched to db articledb
mongos> for(var i=1;i<=20000;i++){db.author.save({"name":"BoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBo"+i,"age":NumberInt(i%120)})}
WriteResult({ "nInserted" : 1 })

        分别登陆两个片的主节点，统计文档数量

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

/usr/local/mongodb/bin/mongo --port 27318
# 第一个分片副本集
myshardrs01:PRIMARY> use articledb
switched to db articledb
myshardrs01:PRIMARY> db.author.count()
0

# 第二个分片副本集
myshardrs02:PRIMARY> use articledb
switched to db articledb
myshardrs02:PRIMARY> db.author.count()
20000

        我们发现并没有进行分片操作，是因为数据块（chunk）没有填满，默认的数据块尺寸（chunksize）是 64M，填满后才会考虑向其他片的数据块填充数据，因此，为了测试，可以将其改小，这里改为 1M，操作如下：

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

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

# 测试完毕后记得改回来
db.settings.save( { _id:"chunksize", value: 64 } )
mongos> use articledb
switched to db articledb
# 删除当前的集合
mongos> db.author.drop()
# 重新设置分片
mongos> sh.shardCollection("articledb.author",{"age":1})
{
	"collectionsharded" : "articledb.author",
	"collectionUUID" : UUID("91b6da9f-e87f-4041-8ec9-b7492141de4a"),
	"ok" : 1,
	"operationTime" : Timestamp(1697510782, 14),
	"$clusterTime" : {
		"clusterTime" : Timestamp(1697510782, 14),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	}
}
# 插入 20w 条数据，要不不容易满
mongos> for(var i=1;i<=200000;i++){db.author.save({"name":"BoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBo"+i,"age":NumberInt(i%120)})}
WriteResult({ "nInserted" : 1 })

# 第一个副本集数量统计
myshardrs01:PRIMARY> db.author.count()
110038

# 第二个副本集数量统计
myshardrs02:PRIMARY> db.author.count()
136524

6.4 再添加一个路由节点

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

mkdir -p /usr/local/mongodb/sharded_cluster/mymongos_27117/log

        新建配置文件

vi /usr/local/mongodb/sharded_cluster/mymongos_27117/mongos.conf

        内容如下：

systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: "/usr/local/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: /usr/local/mongodb/sharded_cluster/mymongos_27117/log/mongod.pid"
net:
  # 服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  # 服务实例绑定的IP
  bindIp: localhost,192.168.229.154
  #bindIp
  # 绑定的端口
  port: 27117
sharding:
  # 指定配置节点副本集
  configDB:
    myconfigrs/192.168.229.154:27019,192.168.229.154:27119,192.168.229.154:27219

        启动 mongos，命令如下：

/usr/local/mongodb/bin/mongos -f /usr/local/mongodb/sharded_cluster/mymongos_27117/mongos.conf

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

/usr/local/mongodb/bin/mongo --host 192.168.229.154 --port 27117
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("652ce7344991027264953cbe")
  }
  shards:
        {  "_id" : "myshardrs01",  "host" : "myshardrs01/192.168.229.154:27018,192.168.229.154:27118",  "state" : 1 }
        {  "_id" : "myshardrs02",  "host" : "myshardrs02/192.168.229.154:27318,192.168.229.154:27418",  "state" : 1 }
  active mongoses:
        "4.0.28" : 2
  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: 
                516 : Success
  databases:
        {  "_id" : "articledb",  "primary" : "myshardrs02",  "partitioned" : true,  "version" : {  "uuid" : UUID("14943571-dd3e-4b0b-84c4-7d3a05d5e0a0"),  "lastMod" : 1 } }
                articledb.author
                        shard key: { "age" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	8
                                myshardrs02	9
                        { "age" : { "$minKey" : 1 } } -->> { "age" : 0 } on : myshardrs01 Timestamp(2, 0) 
                        { "age" : 0 } -->> { "age" : 8 } on : myshardrs01 Timestamp(5, 2) 
                        { "age" : 8 } -->> { "age" : 17 } on : myshardrs01 Timestamp(5, 3) 
                        { "age" : 17 } -->> { "age" : 26 } on : myshardrs01 Timestamp(5, 4) 
                        { "age" : 26 } -->> { "age" : 34 } on : myshardrs01 Timestamp(4, 8) 
                        { "age" : 34 } -->> { "age" : 43 } on : myshardrs01 Timestamp(4, 9) 
                        { "age" : 43 } -->> { "age" : 52 } on : myshardrs01 Timestamp(4, 10) 
                        { "age" : 52 } -->> { "age" : 60 } on : myshardrs01 Timestamp(5, 0) 
                        { "age" : 60 } -->> { "age" : 70 } on : myshardrs02 Timestamp(5, 1) 
                        { "age" : 70 } -->> { "age" : 79 } on : myshardrs02 Timestamp(4, 7) 
                        { "age" : 79 } -->> { "age" : 83 } on : myshardrs02 Timestamp(5, 5) 
                        { "age" : 83 } -->> { "age" : 87 } on : myshardrs02 Timestamp(5, 6) 
                        { "age" : 87 } -->> { "age" : 92 } on : myshardrs02 Timestamp(5, 7) 
                        { "age" : 92 } -->> { "age" : 100 } on : myshardrs02 Timestamp(4, 2) 
                        { "age" : 100 } -->> { "age" : 109 } on : myshardrs02 Timestamp(4, 3) 
                        { "age" : 109 } -->> { "age" : 119 } on : myshardrs02 Timestamp(4, 4) 
                        { "age" : 119 } -->> { "age" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(3, 4) 
                articledb.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	2
                                myshardrs02	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : myshardrs01 Timestamp(1, 0) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : myshardrs01 Timestamp(1, 1) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : myshardrs02 Timestamp(1, 2) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : myshardrs02 Timestamp(1, 3) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                myshardrs01	512
                                myshardrs02	512
                        too many chunks to print, use verbose if you want to force print

七、SpringDataMongDB 连接分片集群

        Java 客户端常用的是 SpringDataMongoDB，其连接的是 mongs 路由，配置和单机 mongod 的配置是一样的。

        多个路由的时候的 SpringDataMongoDB 的客户端配置参考如下：

spring:
  # 数据源配置
  data:
    mongodb:
      # 主机地址
      # host: 192.168.229.154
      # 数据库
      # database: articledb
      # 默认端口是27017
      # port: 27017
      # 也可以使用uri连接
      uri: mongodb://192.168.229.154:27017,192.168.229.154:27117/articledb

        通过日志发现，写入数据的时候，会选择一个路由写入。

快乐的小三菊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MongoDB分片集群部署详解
09-09
本篇文章将详细阐述MongoDB分片集群的部署过程和相关概念。 首先，理解分片集群的基本构成。MongoDB的分片集群由三个主要部分组成：mongos路由服务器、config servers配置服务器以及shards存储节点。mongos负责...
mongodb分片集群安装包
06-01
总结来说，MongoDB分片集群的安装和配置是一个涉及多步骤的过程，包括服务器准备、组件设置、分片策略、监控和安全。理解这些知识点有助于构建高效、可靠的分布式数据库系统。通过实践，你可以熟练掌握MongoDB分片...
MongoDB单机集群方案及详解
我要的光荣哪怕只有一秒
11-24 1286
小白到架构师的MongoDB指南，看看你和架构师之间的差距~
8.MongoDB之分片集群
热门推荐
mijichui2153的博客
03-14 1万+
一、mongodb分片与各角色与概念介绍 Mongodb的分片机制是mongodb数据库的核心机制，也是其可用性高，扩展性好的原因，分片—sharding 的意思就是将数据库数据分散存贮到不同的服务器上，来缓解高并发访问，均衡负载。举例来说一下，比如说一个collection有TB级别的数据，在传统方式下如果有两个线程要访问其中的数据，即使这个线程访问的数据是不同的，为保证同步需要排队等待，分片机制可以很好的解决这个问题，分片机制其实就是分布式的集群，比如现在有五台服务器作为集群，mongodb可以将一.
『MongoDB』MongoDB高可用部署架构——分片集群篇（Sharding）
老陈聊架构
03-23 3239
📣读完这篇文章里你能收获到，为什么要使用分片吗， Mongodb分片集群有哪些特点了， Mongodb分片集群的完整架构，Mongodb分片集群数据分布方式， Mongodb分片集群的设计思路， Mongodb分片集群搭建及扩容...
2. MongoDB分片集群架构实战-----MongoDB分片集群和多文档事务详解
俺就是菜的很的博客
06-28 2412
分片(shard)是指在将数据进行水平切分之后，将其存储到多个不同的服务器节点上的一种扩展方式。分片在概念上非常类似于应用开发中的“水平分表"。不同的点在于，MongoDB本身就自带了分片管理的能力，对于开发者来说可以做到开箱即用。为什么要使用分片?MongoDB复制集实现了数据的多副本复制及高可用，但是一个复制集能承载的容量和负载是有限的。在你遇到下面的场景时，就需要考虑使用分片了∶存储容量需求超出单机的磁盘容量。活跃的数据集超出单机内存容量,导致很多请求都要从磁盘读取数据，影响性能。
mongodb分片集群增加acl
03-15
mongodb集群分片操作以及增加acl，有什么问题联系我！
MongoDB4.2分片及副本集群搭建
04-21
MongoDB4.2分片及副本集群搭建 MongoDB集群 MongoDB分片 MongoDB副本 MongoDB副本集群
mongodb 分片集群搭建过程（无副本）
04-18
mongodb 分片集群搭建过程（无副本），详细操作步骤，linux命令
centos7+mongodb 3.4 集群搭建：分片+副本集
12-13
centos7.0+mongodb 3.4 集群搭建：分片+副本集。3台虚拟机。如有问题可留言。
MongoDB的分片集群(一) : 基础知识
SRE成长记
02-02 1846
MongoDB的分片集群基础知识梳理
MongoDB的原理、基本使用、集群和分片集群
好好学习，天天向上！
04-09 2937
文章目录一、MongoDB的核心概念二、MongoDB的应用场景三、MongoDB的项目落地四、MongoDB的运行原理五、MongoDB的 CURD操作六、MongoDB项目封装七、MongoDB的索引八、MongoDB的分片九、MongoDB的集群 一、MongoDB的核心概念 概念 MongoDB是文档数据库，存储都是类似json的Bosn文件。 json与Bosn区别 相同点 格式一摸一样。 不同点 json无法定义数据类型。Bosn可以定义具体的数据类型。 MongoDB与传统数据库的
Mongodb分片集群的搭建及错误总结
qq_64377514的博客
10-30 436
在配置之前我们要先弄清楚之间的关系。我们总共要配的服务器包括在三台虚拟机上配置三台配置服务器、九台分片服务器、两台路由服务器，其中配置服务器中nosql01为主节点，其他节点上的两台为副本节点或仲裁节点，这三台配置服务器构成一个副本集；分片服务器一台虚拟机上有三台分片服务器，实现对数据的分片存储，而剩余两台分别和对应的服务器构成副本集（即nosql01上有shard1、shard2、shard3这三台服务器实现数据的分片存储，同时他们和其他两台构成副本集实现数据的高可用性）；
MongoDB分片部署
最新发布
yusupali19的博客
04-22 1037
fgOS：win10MongoDB：4.4.24从图中可以看出，分片集群中主要由三个部分组成，即分片服务器（ Shard ）、路由服务器 （ Mongos ）以及配置服务器（ Config Server ）组成。其中，分片服务器有三个，即 Shard1 、 Shard2 、 Shard3 ；路由服务器有两个，即 Mongos1 和 Mongos2 ；配置服务器有三个，即主、副、副。 主要有如下所述三个主要组件： Shard: 用于存储实际的数据块，实际生产环境中一个shard server 角色可由几台机器
深入剖析MongoDB集群架构设计
我是一名热爱编程和分享知识的技术作者，在金融和教育领域有多年的研发管理经验，感谢您访问我的博客，一定会为您带来不一样的收货！
04-14 1502
MongoDB 有三种集群架构模式，分别为主从复制（Master-Slaver）、副本集（Replica Set）和分片（Sharding）模式。当讨论 MongoDB 的集群架构时，应强调副本集和分片这两种官方推荐和支持的模式。如果在历史背景下讨论，可以提及主从复制作为早期的一种复制方式，但需明确指出它在现代 MongoDB 中已不再适用。探索非关系型世界：MongoDB核心概念全解析-CSDN博客TiDB存储引擎TiKV揭秘-CSDN博客。
MongoDB 4.2 部署分片群集
Database operation and maintenance
10-27 405
分片群集 MongoDB分片群集由以下组件组成： （一）shard：每个分片包含分片数据的子集。每个分片都可以部署为副本集。 （二）mongos：mongos充当查询路由器，在客户端应用程序和分片群集之间提供接口。从MongoDB 4.4开始，mongos可以支持 hedged reads 以最大程度地减少延迟。 （三）config servers：配置服务器存储集群的元数据和配置设置。 环境信息 这里准备三台虚拟机就可以了， 可以搭建“四套”副本集，各互为主从关系。 实际生产环境你可以根据成本投入或
MongoDB分片集群
weixin_41063119的博客
11-01 76
根据节点定义一个Zone,比如国际区号：1开头的读写美国的服务器，86开头的读写中国的服务器，方便完成国际化的全球项目的部署。
mongodb分片集群
05-28
MongoDB分片集群是MongoDB的一种分布式部署方式，它可以将一个大型的MongoDB数据库分成多个小的分片，并将这些分片分布在不同的物理服务器上。这样可以极大地提高MongoDB的数据处理能力和数据存储能力。 MongoDB分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐的小三菊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值