MongoDB——MongoDB分片集群（Sharded Cluster）两种搭建方式

最新推荐文章于 2025-03-07 12:00:00 发布
最新推荐文章于 2025-03-07 12:00:00 发布
阅读量894 收藏 4
点赞数
分类专栏： # MongoDB 文章标签： 运维 mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sixeleven611/article/details/118771571
版权

MongoDB分片集群（Sharded Cluster）两种搭建方式

MongoDB分片的概念

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

分片集群包含的组件

  • MongoDB分片群集包含以下组件：
    1. 分片(存储)︰每个分片包含分片数据的子集。每个分片都可以部署为副本集。
    2. mongos(路由) ：mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口。
    3. config servers(调度的配置）：配置服务器存储群集的元数据和配置设置。从MongoDB 3.4开始，必须将配置服务器部署为副本集(CSRS)
  • 下图描述了分片集群中组件的交互：
    在这里插入图片描述
  • MongoDB在集合级别对数据进行分片，将集合数据分布在集群中的分片上。

分片集群架构目标

  • 两个分片节点副本集(3+3)+一个配置节点副本集（3)+两个路由节点(2)，共11个服务节点。
    在这里插入图片描述

安装MongoDB

[root@mongodb ~]# vim /etc/yum.repos.d/mongodb-org-5.0.repo
[mongodb-org-5.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/5.0/x86_64/
gpgcheck=0
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-5.0.asc

[root@mongodb ~]# yum install -y mongodb-org

MongoDB分片集群搭建

  • sharding.clusterRole（群集角色）
ValueDescription
configsvr将此实例作为配置服务器启动.
shardsvr将此实例作为副本启动.

第一套副本集

  • 准备存放数据和日志的目录
[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/log
[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27018/data/db

[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/log
[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27118/data/db

[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/log
[root@pakho ~]# mkdir -p /mongodb/sharded_cluster/myshardrs01_27218/data/db
  • 新建或修改配置文件27018
[root@pakho ~]# vim /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs01_27018/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs01_27018/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs01_27018/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27018

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs01
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 新建或修改配置文件27118
[root@pakho ~]# vim /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs01_27118/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs01_27118/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs01_27118/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27118

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs01
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 新建或修改配置文件27218
[root@pakho ~]# vim /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs01_27218/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs01_27218/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs01_27218/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27218

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs01
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 启动第一套副本集：一主一副本一仲裁
#依次启动三个Mongod服务
[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1761
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1818
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1871
child process started successfully, parent exiting
  • 查看服务是否启动
[root@mongodb ~]# ps -ef | grep -v grep | grep mongodb
  • 初始化副本集和创建主节点
    • 使用客户端命令连接任意一个节点，但这里尽量要连接主节点
[root@mongodb ~]# mongo --host 192.168.100.10 --port 27018

#查看当前复制集状态
> rs.status()
{
	"ok" : 0, #还未初始化
	"errmsg" : "no replset config has been received",
	"code" : 94,
	"codeName" : "NotYetInitialized"
}

> use admin
#配置复制集
> config={_id:"myshardrs01",members:[{_id:0,host:"192.168.100.10:27018"},{_id:1,host:"192.168.100.10:27118"},{_id:2,host:"192.168.100.10:27218"}]}
{
	"_id" : "myshardrs01",
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.100.10:27018"
		},
		{
			"_id" : 1,
			"host" : "192.168.100.10:27118"
		},
		{
			"_id" : 2,
			"host" : "192.168.100.10:27218"
		}
	]
}
#复制集初始化
> rs.initiate(config)
{ "ok" : 1 }
myshardrs01:SECONDARY>
myshardrs01:PRIMARY>

第二套副本集

  • 准备存放数据和日志的目录
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27318/data/db

[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27418/data/db

[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myshardrs02_27518/data/db
  • 新建或修改配置文件27318
[root@mongodb ~]# vim /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs02_27318/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs02_27318/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs02_27318/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27318

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs02
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 新建或修改配置文件27418
[root@mongodb ~]# vim /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs02_27418/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs02_27418/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs02_27418/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27418

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs02
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 新建或修改配置文件27518
[root@mongodb ~]# vim /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myshardrs02_27518/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myshardrs02_27518/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myshardrs02_27518/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27518

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myshardrs02
sharding:
  # 分片角色
  clusterRole: shardsvr
  • 启动第二套副本集：一主一副本一仲裁
#依次启动三个Mongod服务
[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1964
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2017
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2070
child process started successfully, parent exiting
  • 查看服务是否启动
#此时已启动6个Mongo服务
[root@mongodb ~]# ps -ef | grep -v grep | grep mongodb
  • 初始化副本集和创建主节点
    • 使用客户端命令连接任意一个节点，但这里尽量要连接主节点
[root@mongodb ~]# mongo --host 192.168.100.10 --port 27318
> rs.status()
{
	"ok" : 0,
	"errmsg" : "no replset config has been received",
	"code" : 94,
	"codeName" : "NotYetInitialized"
}

> config={_id:"myshardrs02",members:[{_id:0,host:"192.168.100.10:27318"},{_id:1,host:"192.168.100.10:27418"},{_id:2,host:"192.168.100.10:27518"}]}
{
	"_id" : "myshardrs02",
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.100.10:27318"
		},
		{
			"_id" : 1,
			"host" : "192.168.100.10:27418"
		},
		{
			"_id" : 2,
			"host" : "192.168.100.10:27518"
		}
	]
}

#复制集初始化
> rs.initiate(config)
{ "ok" : 1 }
myshardrs02:OTHER> 
myshardrs02:PRIMARY>

配置节点副本集创建

  • 准备存放数据和日志的目录
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27019/data/db

[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27119/data/db

[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/log
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/myconfigrs_27219/data/db
  • 新建或修改配置文件27019
[root@mongodb ~]# vim /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myconfigrs_27019/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myconfigrs_27019/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myconfigrs_27019/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27019

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myconfigrs
sharding:
  # 分片角色
  clusterRole: configsvr
  • 新建或修改配置文件27119
[root@mongodb ~]# vim /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myconfigrs_27119/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myconfigrs_27119/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myconfigrs_27119/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27119

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myconfigrs
sharding:
  # 分片角色
  clusterRole: configsvr
  • 新建或修改配置文件27219
[root@mongodb ~]# vim /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/myconfigrs_27219/log/mongod.log

storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅使用mongod。
  dbPath: /mongodb/sharded_cluster/myconfigrs_27219/data/db
  journal:
    # 启用或禁用持久化日志以确保数据文件保持有效和可恢复
    enabled: true

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/myconfigrs_27219/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27219

replication:
  # 二进制日志文件，到达2048MB，之前的日志将丢弃
  oplogSizeMB: 2048
  # 副本集的名称
  replSetName: myconfigrs
sharding:
  # 分片角色
  clusterRole: configsvr
  • 启动配置副本集：一主两副本
#依次启动三个Mongod服务
[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2145
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2202
child process started successfully, parent exiting

[root@mongodb ~]# mongod -f /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2259
child process started successfully, parent exiting
  • 查看服务是否启动
#此时已启动9个Mongo服务
[root@mongodb ~]# ps -ef | grep -v grep | grep mongodb
  • 初始化副本集和创建主节点
    • 使用客户端命令连接任意一个节点，但这里尽量要连接主节点
[root@mongodb ~]# mongo --host 192.168.100.10 --port 27019

#配置复制集
> config={_id:"myconfigrs",members:[{_id:0,host:"192.168.100.10:27019"},{_id:1,host:"192.168.100.10:27119"},{_id:2,host:"192.168.100.10:27219"}]}
{
	"_id" : "myconfigrs",
	"members" : [
		{
			"_id" : 0,
			"host" : "192.168.100.10:27019"
		},
		{
			"_id" : 1,
			"host" : "192.168.100.10:27119"
		},
		{
			"_id" : 2,
			"host" : "192.168.100.10:27219"
		}
	]
}

#初始化复制集
> rs.initiate(config)
{
	"ok" : 1,
	"$gleStats" : {
		"lastOpTime" : Timestamp(1626430211, 1),
		"electionId" : ObjectId("000000000000000000000000")
	},
	"lastCommittedOpTime" : Timestamp(0, 0)
}
myconfigrs:SECONDARY> 
myconfigrs:PRIMARY>

路由节点的创建和操作

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

  • 准备日志存放目录
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/mymongos_27017/log
  • 新建或修改配置文件
[root@mongodb ~]# vim /mongodb/sharded_cluster/mymongos_27017/mongos.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/mymongos_27017/log/mongod.log

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/mymongos_27017/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27017

sharding:
  # 指定配置节点副本集
  configDB: myconfigrs/192.168.100.10:27019,192.168.100.10:27119,192.168.100.10:27219
  • 启动Mongos
    • 如果启动失败，可以查看log目录下的日志，查看失败原因
[root@mongodb ~]# mongos -f /mongodb/sharded_cluster/mymongos_27017/mongos.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 2376
child process started successfully, parent exiting
  • 客户端登陆Mongos
[root@mongodb ~]# mongo --host 192.168.100.10 --port 27017
mongos>

路由节点进行分片操作

mongos> use admin
#添加第一套分片副本
mongos> db.runCommand ({ addshard : "myshardrs01/192.168.100.10:27018,192.168.100.10:27118,192.168.100.10:27218",name:"shard1"})
{
	"shardAdded" : "shard1",
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626433783, 4),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626433783, 4)
}

#添加第二套分片副本
mongos> db.runCommand ({ addshard : "myshardrs02/192.168.100.10:27318,192.168.100.10:27418,192.168.100.10:27518",name:"shard2"})
{
	"shardAdded" : "shard2",
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626434057, 4),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626434057, 4)
}

#列出分片
mongos> db.runCommand ({ listshards : 1 })
{
	"shards" : [
		{
			"_id" : "shard1",
			"host" : "myshardrs01/192.168.100.10:27018,192.168.100.10:27118,192.168.100.10:27218",
			"state" : 1,
			"topologyTime" : Timestamp(1626433783, 1)
		},
		{
			"_id" : "shard2",
			"host" : "myshardrs02/192.168.100.10:27318,192.168.100.10:27418,192.168.100.10:27518",
			"state" : 1,
			"topologyTime" : Timestamp(1626434057, 2)
		}
	],
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626434108, 4),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626434108, 4)
}

#整体状态查看
mongos> sh.status()

在这里插入图片描述

  • 如果添加分片失败，需要先手动移除分片，检查添加分片的信息的正确性后，再次添加分片。
  • 移除分片参考
use admin
db.runCommand({ removeShard: "myshardrs02" })
  • 如果只剩下最后一个shard，是无法删除的！
    • 移除时会自动转移分片数据，需要一个时间过程
    • 完成后，再次执行删除分片命令才能真正删除

开启分片功能

sh.enableSharding("库名")、sh.shardCollection("库名.集合名",{"key":1})
  • 在mongos上的articledb数据库配置sharding
mongos> use admin
switched to db admin

#开启分片功能
mongos> sh.enableSharding("articledb")
{
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626440229, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626440228, 2)
}

集合分片

  • 对集合分片，必须使用sh.shardCollection()方法指定集合和分片键。
  • 语法
sh.shardCollection(namespace，key,unique)
  • 参数
参数类型描述
namespacestring要 (分片）共享的目标集合的命名空间，格式：<database> . <collection>
keydocument用作分片键的索引规范文档。shard键决定MongoDB如何在shard之间分发文档。除非集合为空，否则索引必须在shard collection命令之前存在。如果集合为空，则MongoDB在对集合进行分片之前创建索引，前提是支持分片键的索引不存在。简单的说：由包含字段和该字段的索引遍历方向的文档组成。
uniqueboolean当值为true情况下，片键字段上会限制为确保是唯一索引，哈希策略片键不支持唯一索引，默认是false

分片规则：哈希策略

  • 对于基于哈希的分片，MongoDB计算一个字段的哈希值，并用这个哈希值来创建数据块.
  • 在使用基于哈希分片的系统中，拥有相近片键的文档很可能不会存储在同一个数据块中，因此数据的分离性更好一些.
  • 使用nickname作为片键，根据其值的哈希值进行数据分片
mongos> sh.shardCollection("articledb.comment",{"nickname":"hashed"})
{
	"collectionsharded" : "articledb.comment",
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626441185, 4),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626441184, 10)
}
  • 查看分片状态sh.status()
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("60f15b0d57c3ca1cca83e203")
  }
  shards:
        {  "_id" : "shard1",  "host" : "myshardrs01/192.168.100.10:27018,192.168.100.10:27118,192.168.100.10:27218",  "state" : 1,  "topologyTime" : Timestamp(1626433783, 1) }
        {  "_id" : "shard2",  "host" : "myshardrs02/192.168.100.10:27318,192.168.100.10:27418,192.168.100.10:27518",  "state" : 1,  "topologyTime" : Timestamp(1626434057, 2) }
  active mongoses:
        "5.0.0" : 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" : "shard2",  "partitioned" : true,  "version" : {  "uuid" : UUID("bade6602-640f-47f3-9894-ca723d1f0d80"),  "timestamp" : Timestamp(1626440228, 1),  "lastMod" : 1 } }
                articledb.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	2
                                shard2	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : shard1 Timestamp(1, 0) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : shard1 Timestamp(1, 1) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : shard2 Timestamp(1, 2) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 3) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	512
                                shard2	512
                        too many chunks to print, use verbose if you want to force print
        {  "_id" : "test",  "primary" : "shard2",  "partitioned" : true,  "version" : {  "uuid" : UUID("c406c3d4-a34b-4e60-8f91-f1bededb520e"),  "timestamp" : Timestamp(1626434765, 4),  "lastMod" : 1 } }

分片规则：范围策略

  • 对于基于范围的分片，MongoDB按照片键的范围把数据分成不同部分，假设有一个数字的片键:想象一个从负无穷到正无穷的直线,每一个片键的值都在直线上画了一个点.MongoDB把这条直线划分为更短的不重叠的片段，并称之为数据块，每个数据块包含了片键在一定范围内的数据.
  • 在使用片键做范围划分的系统中，拥有相近片键的文档很可能存储在同一个数据块中，因此也会存储在同一个分片中.
  • 如使用作者年龄字段作为片键，按照点赞数的值进行分片
mongos> sh.shardCollection("articledb.author",{"age":1})
{
	"collectionsharded" : "articledb.author",
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1626441608, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1626441607, 14)
}
  • 再次查看分片状态sh.status()
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
  	"_id" : 1,
  	"minCompatibleVersion" : 5,
  	"currentVersion" : 6,
  	"clusterId" : ObjectId("60f15b0d57c3ca1cca83e203")
  }
  shards:
        {  "_id" : "shard1",  "host" : "myshardrs01/192.168.100.10:27018,192.168.100.10:27118,192.168.100.10:27218",  "state" : 1,  "topologyTime" : Timestamp(1626433783, 1) }
        {  "_id" : "shard2",  "host" : "myshardrs02/192.168.100.10:27318,192.168.100.10:27418,192.168.100.10:27518",  "state" : 1,  "topologyTime" : Timestamp(1626434057, 2) }
  active mongoses:
        "5.0.0" : 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" : "shard2",  "partitioned" : true,  "version" : {  "uuid" : UUID("bade6602-640f-47f3-9894-ca723d1f0d80"),  "timestamp" : Timestamp(1626440228, 1),  "lastMod" : 1 } }
                articledb.author
                        shard key: { "age" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard2	1
                        { "age" : { "$minKey" : 1 } } -->> { "age" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 0) 
                articledb.comment
                        shard key: { "nickname" : "hashed" }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	2
                                shard2	2
                        { "nickname" : { "$minKey" : 1 } } -->> { "nickname" : NumberLong("-4611686018427387902") } on : shard1 Timestamp(1, 0) 
                        { "nickname" : NumberLong("-4611686018427387902") } -->> { "nickname" : NumberLong(0) } on : shard1 Timestamp(1, 1) 
                        { "nickname" : NumberLong(0) } -->> { "nickname" : NumberLong("4611686018427387902") } on : shard2 Timestamp(1, 2) 
                        { "nickname" : NumberLong("4611686018427387902") } -->> { "nickname" : { "$maxKey" : 1 } } on : shard2 Timestamp(1, 3) 
        {  "_id" : "config",  "primary" : "config",  "partitioned" : true }
                config.system.sessions
                        shard key: { "_id" : 1 }
                        unique: false
                        balancing: true
                        chunks:
                                shard1	512
                                shard2	512
                        too many chunks to print, use verbose if you want to force print
        {  "_id" : "test",  "primary" : "shard2",  "partitioned" : true,  "version" : {  "uuid" : UUID("c406c3d4-a34b-4e60-8f91-f1bededb520e"),  "timestamp" : Timestamp(1626434765, 4),  "lastMod" : 1 } }

分片后插入数据测试

#分别提前登录分片副本1和分片副本2的主节点
[root@mongodb ~]# mongo --host 192.168.100.10 --port 27018
myshardrs01:PRIMARY>

[root@mongodb ~]# mongo --host 192.168.100.10 --port 27318
myshardrs02:PRIMARY>

测试一：哈希规则

  • 登录Mongos后，向Comment循环插入1000条数据做测试
mongos> use articledb
switched to db articledb
mongos> for(var i=1;i<=1000;i++){db.comment.insert({_id:i+"",nickname:"BoBo"+i})}
WriteResult({ "nInserted" : 1 })
mongos> show collections
author
comment
mongos> db.comment.count()
1000


#进入分片1查看
myshardrs01:PRIMARY> use articledb
switched to db articledb
myshardrs01:PRIMARY> db.comment.count()
507
#进入分片2查看
myshardrs02:PRIMARY> use articledb
switched to db articledb
myshardrs02:PRIMARY> db.comment.count()
493

测试二：范围策略

  • 登录Mongos后，向Comment循环插入20000条数据做测试
    • 数据块（chunk) 没有填满，默认的数据块尺寸(chunksize)是64M，填满后才会考虑向其他片的数据块填充数据，因此，为了测试，可以将其改小，这里改为1M，操作如下：
mongos> use config
switched to db config
mongos> db.setting.save( {_id:"chunksize",value: 1 } )
WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : "chunksize" })
  • 测试完改回来
switched to db config
mongos> db.setting.save( {_id:"chunksize",value: 64 } )
  • 注意：要先改小，再设置分片。为了测试，可以先删除集合，重新建立集合的分片策略，再插入数据测试即可
  • 插入数据测试
mongos> use articledb
switched to db articledb
mongos> for(var i=1;i<=20000;i++){db.author.save({"name":"BoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBoBo"+i,"age":NumberInt(i%120)})}
WriteResult({ "nInserted" : 1 })
mongos> db.author.count()
20000

#但是数据全部存储在了分片2
myshardrs01:PRIMARY> db.author.count()
0
myshardrs02:PRIMARY> db.author.count()
20000

再增加一个路由节点

  • 准备日志存放目录
[root@mongodb ~]# mkdir -p /mongodb/sharded_cluster/mymongos_27117/log
  • 新建或修改配置文件
    • 不需要添加分片，已经同步，只需连接即可！
[root@mongodb ~]# vim /mongodb/sharded_cluster/mymongos_27117/mongos.conf
systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  destination: file
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
  logAppend: true
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: /mongodb/sharded_cluster/mymongos_27117/log/mongod.log

processManagement:
  # 启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
  # 指定用于保存mongod或mongos进程的进程ID的文件位置其中mongos或mongod将写入其PID
  pidFilePath: /mongodb/sharded_cluster/mymongos_27117/log/mongod.pid
  timeZoneInfo: /usr/share/zoneinfo

net:
  # 服务实例绑定所有ip，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  # bindIpAll: true
  # 服务实例绑定的IP
  bindIp: 0.0.0.0
  port: 27117

sharding:
  # 指定配置节点副本集
  configDB: myconfigrs/192.168.100.10:27019,192.168.100.10:27119,192.168.100.10:27219
  • 启动Mongos2
[root@mongodb ~]# mongos -f /mongodb/sharded_cluster/mymongos_27117/mongos.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 9181
child process started successfully, parent exiting

基于Docker搭建MongoDB分片集群

#搭建三个config节点
#--configsvr 默认走的端口27019  --replSet 设置复制集名称
docker create --name configsvr01 -p 17000:27019 -v mongoconfigsvr-data-01:/data/configdb mongo:4.0.3 --configsvr --replSet "rs_configsvr" --bind_ip_all
docker create --name configsvr02 -p 17001:27019 -v mongoconfigsvr-data-02:/data/configdb mongo:4.0.3 --configsvr --replSet "rs_configsvr" --bind_ip_all
docker create --name configsvr03 -p 17002:27019 -v mongoconfigsvr-data-03:/data/configdb mongo:4.0.3 --configsvr --replSet "rs_configsvr" --bind_ip_all

#启动服务
docker start configsvr01 configsvr02 configsvr03

#进入容器操作
docker exec -it configsvr01 /bin/bash
mongo 192.168.100.100:17000

#集群初始化
rs.initiate(
  {
    _id: "rs_configsvr",
    configsvr: true,
    members: [
      { _id: 0, host : "192.168.100.100:17000" },
      { _id: 1, host : "192.168.100.100:17001" },
      { _id: 2, host : "192.168.100.100:17002" },
    ]
  }
)
rs_configsvr:SECONDARY>
rs_configsvr:PRIMARY>

#搭建2个shard集群,每个集群都有3个数据节点

#--shardsvr 参数添加后 默认端口为27018
#集群一
docker create --name shardsvr01 -p 37000:27018 -v mongoshardsvr-data-01:/data/db mongo:4.0.3 --replSet "rs_shardsvr1" --bind_ip_all --shardsvr
docker create --name shardsvr02 -p 37001:27018 -v mongoshardsvr-data-02:/data/db mongo:4.0.3 --replSet "rs_shardsvr1" --bind_ip_all --shardsvr
docker create --name shardsvr03 -p 37002:27018 -v mongoshardsvr-data-03:/data/db mongo:4.0.3 --replSet "rs_shardsvr1" --bind_ip_all --shardsvr

#集群二
docker create --name shardsvr04 -p 37003:27018 -v mongoshardsvr-data-04:/data/db mongo:4.0.3 --replSet "rs_shardsvr2" --bind_ip_all --shardsvr
docker create --name shardsvr05 -p 37004:27018 -v mongoshardsvr-data-05:/data/db mongo:4.0.3 --replSet "rs_shardsvr2" --bind_ip_all --shardsvr
docker create --name shardsvr06 -p 37005:27018 -v mongoshardsvr-data-06:/data/db mongo:4.0.3 --replSet "rs_shardsvr2" --bind_ip_all --shardsvr

#启动容器
docker start shardsvr01 shardsvr02 shardsvr03
docker start shardsvr04 shardsvr05 shardsvr06

#进入容器执行
docker exec -it shardsvr01 /bin/bash
mongo 192.168.100.100:37000

#初始化集群
rs.initiate(
  {
    _id: "rs_shardsvr1",
    members: [
      { _id: 0, host : "192.168.100.100:37000" },
      { _id: 1, host : "192.168.100.100:37001" },
      { _id: 2, host : "192.168.100.100:37002" },
    ]
  }
)

docker exec -it shardsvr04 /bin/bash
mongo 192.168.100.100:37003

rs.initiate(
  {
    _id: "rs_shardsvr2",
    members: [
      { _id: 0, host : "192.168.100.100:37003" },
      { _id: 1, host : "192.168.100.100:37004" },
      { _id: 2, host : "192.168.100.100:37005" },
    ]
  }
)

#创建Mongos节点容器,需要指定config服务
#--entrypoint 指定入口点
docker create --name mongos -p 6666:27017 --entrypoint "mongos" mongo:4.0.3 --configdb rs_configsvr/192.168.100.100:17000,192.168.100.100:17001,192.168.100.100:17002 --bind_ip_all

docker start mongos

#进入容器执行
docker exec -it mongos bash
mongo 192.168.100.100:6666
mongos>

#添加shard节点
sh.addShard("rs_shardsvr1/192.168.100.100:37000,192.168.100.100:37001,192.168.100.100:37002")
sh.addShard("rs_shardsvr2/192.168.100.100:37003,192.168.100.100:37004,192.168.100.100:37005")

#查看集群状态
sh.status()

集群测试操作

#启用分片
sh.enableSharding("test")

#设置分片规则,按照_id的hash进行区分
sh.shardCollection("test.order", {"_id": "hashed"})

#插入数据测试
use test

for (i = 1; i <= 1000; i=i+1){
    db.order.insert({'id':i , 'price': 100+i})
}
WriteResult({ "nInserted" : 1 })

mongos> db.order.count()
1000
mongos> db.order.find()

#分别在两个shard集群中查询数据进行测试
root@591de2dfcfe5:/# mongo 192.168.100.100:37000/test
rs_shardsvr1:PRIMARY> db.order.count()
502

root@591de2dfcfe5:/# mongo 192.168.100.100:37003/test
rs_shardsvr2:PRIMARY> db.order.count()
498

#集群操作(在Mongos中执行)
mongos> use config            #需要进入config库
mongos> db.databases.find()   #列出所有数据库分片情况
mongos> db.collections.find() #查看分片的片键
mongos> sh.status()           #查询分片集群的状态信息
搭建mongoDB Shard集群
weixin_42379136的博客
11-06 520
这里是用虚拟机模拟mongoDB Shard集群的搭建过程，实际项目中更多的shard server，搭建方法也一致。 准备环境： Hosts:      lin01.cniao5.com    （启动3个configuration server实例，互为replSet, 启动mongos服务） lin02.cniao5.com    （启动3个shard server实例,互为replS...
MongoDB——部署MongoDB分片集群
Cantevenl的博客
04-20 2129
MongoDB分片集群的搭建分片的概念分片集群的优势分片集群包含的组件部署MongoDB分片集群的准备工作配置shard配置Config Server配置 mongos配置复制集进入节点服务器集群配置节点衔接启动mongos指定分片键对集合分片 分片的概念 分片（sharding)是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。 换句话说：分片(sharding)是指将数据拆分，将其分散存在不同的机器上的过程。有时也用分区(partitionin
mongodb分片
10-23
i. 启动shard节点:mongod –shardsvr –f config/xx.conf ii. 启动config server节点:mongod –configsvr –f config/xx.conf iii. 启动mongos节点:mongos –f config/xx.conf –configserver configserver的id:port i) 添加分片过程 i. 步骤一.链接到mongos ii. Add shards 1. 单个数据库实例: -{addShard:””,maxSize:,name:””} 2. 副本集群: -{addShard:”/”,maxSize:,name:”<shard_
MongoDB Sharding Cluster 分片集群
最新发布
2402_88627342的博客
03-07 684
将MongoDB的分片和复制功能结合使用，在确保数据分片到多台服务器的同时，也确保了每份数据都有相应的备份，这样就可以确保有服务器坏掉时，其他的从库可以立即接替坏掉的部分继续工作。mongos就是掌握统一路口的路由器，其会将客户端发来的请求准确无误的路由到集群中的一个或者一组服务器上，同时会把接收到的响应拼装起来发回到客户端。哈希索引适合单调变化的字段，例如自增值，时间值等（因为可以将单调的字段通过hash函数映射到不同的块上去，从而分散写入压力，例如下图，虽然数据连续，但是写入了不同的数据块中）
Mongodb Cluster
我是Alvin家鸡鸭鱼的小米米
10-12 1634
高吞吐量系统 举一个例子，我们做项目需要安排计划，每一个模块可以由多人同时并行做多项任务，也可以一个人或者多个人串行工作，但始终会有一条关键路径，这条路径就是项目的工期。系统一次调用的响应时间跟项目计划一样，也有一条关键路径，这个关键路径是就是系统影响时间。关键路径由 CPU 运算、IO、外部系统响应等等组成。 对于一个系统的用户来说，从用户点击一个按钮、链接或发出一条指令开始，到系统
Mongodb cluster
weixin_34107955的博客
09-11 195
MongoDB分片（Sharding）技术 　　分片（sharding）是MongoDB用来将大型集合分割到不同服务器（或者说一个集群）上所采用的方法。尽管分片起源于关系型数据库分区，但MongoDB分片完全又是另一回事。 　　和MySQL分区方案相比，MongoDB的最大区别在于它几乎能自动完成所有事情，只要告诉MongoDB要分配数据，它就能自动维护数据在不同服务器之间的均衡。 1 分片的目的...
mongodb 集群shard_mongodb集群构建方案（一）
weixin_39685578的博客
12-30 163
1 docker搭建mongodb集群+副本集：为什么要使用分片集群数据容量日益增大，访问性能日渐下降，怎么破？线上异常火爆，如何支撑更多用户并发？垂直扩展价格昂贵，一台几十G上百G内存的服务器太贵了，不如分布式省钱为什么使用高可用副本集一台机子挂了，其它机子可以顶上去，不至于影响业务。这里我们要实现如下集群架构：详细拆解：拆解1：整体看，这个是一个mon...
4.MongoDB sharding Cluster 分片集群
2302_77503226的博客
06-11 669
MongoDB分片集群是MongoDB提供的一种可水平扩展的数据存储解决方案，当单个MongoDB服务器无法满足数据存储需求或吞吐量要求时，可以使用分片集群来分散数据量和查询负载。
mongodb 005——Sharding Cluster 分片集群及搭建过程
weixin_44167712的博客
04-01 470
MongoDB Sharding Cluster 分片集群5.1 规划5.2 shard复制集配置：5.2.1 目录创建：5.2.2 修改配置文件：5.2.3 启动所有节点，并搭建复制集5.3 config 节点配置5.3.1 目录创建5.3.2 修改配置文件5.3.3 启动节点，并配置复制集：5.4 mongos节点配置5.4.1 目录创建5.4.2 修改配置文件5.4.3 启动mongos...
mongodb分片集群搭建
wutongyuWxc的博客
08-14 1377
分片集群2: (10.168.2.138:27012、10.168.4.204:27012、10.168.4.205:27012)分片集群1:（10.168.2.138:27011、10.168.4.204:27011、10.168.4.205:27011）第一步：添加mongodb yum仓库 : /etc/yum.repos.d/mongodb-org.repo。：在三台服务器上分别创建分片配置文件： /etc/mongod-cfg.conf。：在10.168.2.138服务器上，执行分片集初始化。
mongodb-cluster-docker-compose：演示一个简单的分片的Mongo集群，并使用docker compose复制
02-04
带有Docker Compose的演示Mongo分片集群 PSS样式（小学-中学-中学） 需要PSA吗？ 检查 警告（Windows和OS X） Windows和OS X上的默认Docker设置使用VirtualBox VM托管Docker守护程序。 不幸的是，VirtualBox用于在...
mongodb 集群shard_mongodb集群构建方案（二）
weixin_35695652的博客
12-24 204
0.创建网段docker network create mongo1.编写yaml文件，，这里我命名fates-mongo-compose.yaml以下这个文件，建立3个mongo shard服务，3个secondary服务，3个arbiter服务，3个mongo config服务， 1个mongos服务：2.编写deploy-and-start.sh脚本该脚本流程详细描述一下1. 先启...
MongoDB-分片
无痕的博客
07-14 3256
mongodb分片与部署过程
MongoDB 分片
ws_hgo的专栏
11-27 2737
分片 sharding   分片是指将数据拆分,将起分散到不同服务器的过程.,将数据分散到不同的服务器上,可以存储更多的数据,处理更大的负载   MongoDB分片机制允许你创建一个包含许多服务器(分片)的集群,将子数据分散在集群中.每个分片维护着一个数据集合的子集,相比单服务器和副本集，分片具备更好的处理能力.整个集群对于应用服务器来说像是只有一台单机的服务器.为了实现这样操作,我们需要在分
MongoDB分片
只是甲的博客
11-23 957
文章目录分片简介一.MongoDB 分片架构二.分片配置2.1 启动配置服务器2.2 启动分片控制器2.3 启动两个分片服务器2.4 在分片控制器中添加分片2.5 设置块大小2.6 创建分片集合2.7 向分片添加数据三.维护3.1 添加新分片3.1.1 启动新的mongod3.1.2 添加新的分片3.1.3 查询分片状态3.1.4 查询三个分片的记录数4.2 删除分片4.2.1 删除分片4.2.2 验证参考 分片简介 分片 （sharding）是指将数据拆分，将其分散存放在不同的机器上的过程 。有时也用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

611#

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

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

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

打赏作者

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

抵扣说明：

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

余额充值