MongoDB构建分片集群及分片管理

最新推荐文章于 2024-06-06 21:22:22 发布
置顶 最新推荐文章于 2024-06-06 21:22:22 发布
阅读量1.4k 收藏 1
点赞数 2
分类专栏： 数据库管理 文章标签： 数据库 mysql 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CN_LiTianpeng/article/details/109561299
版权

一、副本的概念

1.主从复制和副本集区别

主从集群和制本集最大的区别就是副本集没有固定的“主节点";整个集群会选出一个主节点当其挂掉后，又在剩下的从节点中选中其他节点为"主节点"。副本集总有一个活跃点(主primary和一 个或多个备份节点(从secondary)。

2、副本集的两种类型

副本集有两种类型三种角色
两种类型:
主节点(Primary) 类型:数据操作的主要连接点，可读写.
次要(辅助、从)节点(Secondaries) 类型:数据冗余备份节点，可以读或选举。

3、三种角色:

主要成员(Primary) :主要接收所有写操作。就是主节点。
副本成员(Replicate) :从主节点通过复制操作以维护相同的数据集。即备份数据，可写操作，但可以读操作但需要配置。是默认的一种从节点类型。
仲裁者(Arbiter) :不保留任何数据的副本，只具有投票选举作用。当然也可以将仲裁服务器维护为副本集的一部分，即副本成员同时也可以是仲裁者。也是一种从节点类型。

4、缺点

相当于只从复制 master宕机后就凉了 ，为了实现高可用，就不得不介绍一下分片的概念了

二、分片概念

1.数据块

  • 块也叫区间，可能存在一分片一区间和一分片多区间两种情况。

  1. 一分片一区间：数据不会在片之间自动移动来保持分片的数据的均匀性，需要手动拆分分片来移动数据。

  2. 一分片多区间情况：一个数据块默认64MB，当数据块达到64MB时就会创建新的块，当然前提是当前的粒度还允许再拆分，平衡器会保证每个分片数据块的均匀。但是移动块也遵循分片的原则，块之间的数据集不能有交集。
    比如一个块[50-100)现在拆分成两个块，那么默认会拆分成[50-75)[75-100)两个块，如果当前分片块比其它分片的块大于9那么可能[75-100)改块会被移动到新的分片当中。

2.平衡器

平衡器（balancer）负责数据的迁移。它会周期性地检查分片间是否存在不平衡，如果存在，则会开启块的迁移。不平衡的表现指，一个分片明显比其他分片拥有更多的块。假如有一些集合达到了阈值，平衡器则会开始做块迁移。它会从负载比较比较大的分片中选择一个块，并询问该分片是否需要在迁移之前对块进行拆分。完成必要的拆分后，就会将块迁移至数量比较少的机器上。

一、副本的概念
主从复制和副本集区别
主从集群和制本集最大的区别就是副本集没有固定的“主节点";整个集群会选出一个主节点当其挂掉后，又在剩下的从节点中选中其他节点为"主节点"。副本集总有一个活跃点(主primary和一 个或多个备份节点(从secondary)。

1、副本集的两种类型
副本集有两种类型三种角色
两种类型:
主节点(Primary) 类型:数据操作的主要连接点，可读写.
次要(辅助、从)节点(Secondaries) 类型:数据冗余备份节点，可以读或选举。

2、三种角色:
主要成员(Primary) :主要接收所有写操作。就是主节点。
副本成员(Replicate) :从主节点通过复制操作以维护相同的数据集。即备份数据，可写操作，但可以读操作但需要配置。是默认的一种从节点类型。
仲裁者(Arbiter) :不保留任何数据的副本，只具有投票选举作用。当然也可以将仲裁服务器维护为副本集的一部分，即副本成员同时也可以是仲裁者。也是一种从节点类型。
4、缺点
相当于只从复制 master宕机后就凉了 ，为了实现高可用，就不得不介绍一下分片的概念了

三、分片集群包含的组件

MongoDB分片群集包含以下组件: .
●分片(存储)shard:每个分片包含分片数据的子集。 每个分片都可以部署为副本集。
●mongos (路由) : mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口。
●config servers (“调度"的配置) : 配置服务器存储群集的元数据和配置设置。从MongoDB 3.4开始，必须将配置服务器部署为副本集(CSRS)。

在这里插入图片描述

四、构建分片群集

拓扑

在这里插入图片描述

1.解压软件包

[root@localhost ~]# tar zxvf mongodb-linux-x86_64-3.2.1.tgz -C /opt/
[root@localhost ~]# mv /opt/mongodb-linux-x86_64-3.2.1/ /usr/local/mongodb  ##移动到/usr/local下便于管理

2.创建日志文件及数据目录

[root@localhost ~]# mkdir -p /data/mongodb/mongodb{1,2,3,4}
[root@localhost ~]# mkdir /data/mongodb/logs
[root@localhost ~]# touch /data/mongodb/logs/mongodb{1,2,3,4}.1og
[root@localhost ~]# chmod -R 777 /data/mongodb/logs/*.1og     ##一定要授予777权限

3.进行一些缓存优化

[root@localhost ~]# ulimit -n 25000      ##每个进程可以同时打开的最大文件数
[root@localhost ~]# ulimit -u 25000    ##可以运行的最大并发进程数
##### 下面3条优化，当某节点内存不足时，从其他节点分配内存 ########
[root@localhost bin]#  sysctl -w vm.zone_reclaim_mode=0      ##禁止大页面内存的出现
vm.zone_reclaim_mode = 0
[root@localhost bin]#  echo never > /sys/kernel/mm/transparent_hugepage/enabled
[root@localhost bin]#  echo never > /sys/kernel/mm/transparent_hugepage/defrag

4.编写配置文件

[root@localhost ~]# cd /usr/local/mongodb/bin/    ##配置文件就放到/usr/local/mongodb/bin/目录下
[root@localhost bin]#  vim mongodb1.conf
port=37017
dbpath=/data/mongodb/mongodb1
logpath=/data/mongodb/logs/mongodb1.log
logappend=true
fork=true
maxConns=5000
storageEngine=mmapv1
configsvr=true         ##指定这是属于配置服务器的模式

5.建立软连接，便于调用命令

[root@localhost bin]# ln -s /usr/local/mongodb/bin/mongod /usr/bin/mongod
[root@localhost bin]# ln -s /usr/local/mongodb/bin/mongo /usr/bin/mongo

6.启动实例

[root@localhost bin]# mongod -f /usr/local/mongodb/bin/mongodb1.conf
about to fork child process, waiting until server is ready for connections.
forked process: 2099
child process started successfully, parent exiting

7.配置分片服务器

[root@localhost bin]# cp -p mongodb1.conf mongodb2.conf
[root@localhost bin]# vim mongodb2.conf
port=47017    ##修改端口号
dbpath=/data/mongodb/mongodb2     ##修改数据目录位置
logpath=/data/mongodb/logs/mongodb2.log    ##修改日志文件路径
shardsvr=true    ##configsvr改成shardsvr

[root@localhost bin]# cp -p mongodb2.conf mongodb3.conf
[root@localhost bin]# vim mongodb3.conf 
port=47018    ##修改端口号
dbpath=/data/mongodb/mongodb3     ##修改数据目录位置
logpath=/data/mongodb/logs/mongodb3.log    ##修改日志文件路径

[root@localhost bin]# cp -p mongodb2.conf mongodb4.conf
[root@localhost bin]# vim mongodb4.conf 
port=47019    ##修改端口号
dbpath=/data/mongodb/mongodb4     ##修改数据目录位置
logpath=/data/mongodb/logs/mongodb4.log    ##修改日志文件路径
#######################依次启动实例####################################
[root@localhost bin]# mongod -f /usr/local/mongodb/bin/mongodb2.conf     ##'启动实例2'
about to fork child process, waiting until server is ready for connections.
forked process: 2393
child process started successfully, parent exiting
[root@localhost bin]# mongod -f /usr/local/mongodb/bin/mongodb3.conf    ##'启动实例3'
about to fork child process, waiting until server is ready for connections.
forked process: 2408
child process started successfully, parent exiting
[root@localhost bin]# mongod -f /usr/local/mongodb/bin/mongodb4.conf    ##'启动实例4'
about to fork child process, waiting until server is ready for connections.
forked process: 2423
child process started successfully, parent exiting

8.启动路由服务器

[root@localhost bin]# ./mongos --help    ##mongos是开启路由模式的一个脚本，--help查看帮助信息
[root@localhost bin]# ./mongos --port 27017 --fork --logpath=/usr/local/mongodb/bin/route.log --configdb 192.168.10.10:37017 --chunkSize 1   
##--port指定对方访问端口（入口），--fork后台运行；--logpath日志文件位置；--configdb指定处理请求的配置服务器；--chunkSize指定数据块（最后这个配置只是用来测试的，不加也行，默认空间是200M大小）
2020-11-09T01:36:31.297+0800 W SHARDING [main] Running a sharded cluster with fewer than 3 config servers should only be done for testing purposes and is not recommended for production.
about to fork child process, waiting until server is ready for connections.
forked process: 37738
child process started successfully, parent exiting

[root@localhost bin]# mongo     ##mongo命令直接进入路由服务器（默认端口是27017）
MongoDB shell version: 3.2.1
connecting to: test
Server has startup warnings: 
2020-11-09T01:36:31.307+0800 I CONTROL  [main] ** WARNING: You are running this process as the root user, which is not recommended.
2020-11-09T01:36:31.307+0800 I CONTROL  [main] 
mongos>

9.启用分片服务器

sh.addShard()命令添加分片服务器

[root@localhost bin]# mongo     ##进入路由服务器实际上相当于进入了配置服务器
mongos> show dbs       ##只能查看到一个配置config库
config  0.031GB
mongos> sh.status()     ##查看该服务器下是否有分片服务器
--- Sharding Status --- 
  sharding version: {
	"_id" : 1,
	"minCompatibleVersion" : 5,
	"currentVersion" : 6,
	"clusterId" : ObjectId("5fa82c9fef682337a84b13a1")
}
  shards:       ##现在这个版块下是空的，说明并没有分片服务器
  active mongoses:
	"3.2.1" : 1
  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:
mongos> sh.addShard("192.168.10.10:47017")      ##添加分片服务器192.168.10.10:47017
{ "shardAdded" : "shard0000", "ok" : 1 }
mongos> sh.addShard("192.168.10.10:47018")      ##添加分片服务器192.168.10.10:47018
{ "shardAdded" : "shard0001", "ok" : 1 }

mongos> sh.status()       ##再次查看分片集群状态
--- Sharding Status --- 
  sharding version: {
	"_id" : 1,
	"minCompatibleVersion" : 5,
	"currentVersion" : 6,
	"clusterId" : ObjectId("5fa82c9fef682337a84b13a1")
}
  shards:                ##在shards下多次两个节点
	{  "_id" : "shard0000",  "host" : "192.168.10.10:47017" }
	{  "_id" : "shard0001",  "host" : "192.168.10.10:47018" }
  active mongoses:
	"3.2.1" : 1
  balancer:

10 分片功能管理初步了解

mongos> use school     ##进入school库
 
mongos> for(var i=1;i<=10000;i++)db.info.insert({"id":i,"team":"member"+i})    ##插入10000条数据，用于验证分片
 
mongos> db.info.find().limit(3)     ##查看头3行数据
{ "_id" : ObjectId("5fa83a28597e4c3f6bb3f3c6"), "id" : 1, "team" : "member1" }
{ "_id" : ObjectId("5fa83a29597e4c3f6bb3f3c7"), "id" : 2, "team" : "member2" }
{ "_id" : ObjectId("5fa83a29597e4c3f6bb3f3c8"), "id" : 3, "team" : "member3" }


############# 也可以通过在MongoDB外用文件导入数据######################
./mongoimport -d school -c info --file /opt/test.txt
#################################################################

mongos> show dbs    ##插入数据后新建了一个school库
config  0.031GB
school  0.078GB
mongos> use school   ##进入school库
 
mongos> show collections    ##查看集合，已经有数据了
info
system.indexes

mongos> sh.status()
……省略部分
  databases:
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : false }   ##数据并没有进行分片，提示false


mongos> sh.enableSharding("school")    ##对school库开启分片处理

mongos> sh.status()
……省略部分
  databases:
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : true }   ##显示ture，开启了分片处理，但是到这一步只是开启了对库的分片，对集合并没有分片



#对集合进行分片需要先创建索引
mongos> db.info.createIndex({"id":1})     ##给info集合创建以“id”为索引，从1开始

mongos> sh.shardCollection("school.info",{"id":1})     ##对集合info分片


mongos> sh.status()    ##再次查看信息，可以看出10000条数据分成了三段1~4682,4682~9364,9364~最后
……省略部分
  databases:
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : true }
		school.info
			shard key: { "id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	3
			{ "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0000 Timestamp(1, 0) 
			{ "id" : 4682 } -->> { "id" : 9364 } on : shard0000 Timestamp(1, 1) 
			{ "id" : 9364 } -->> { "id" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 2)

总结：一共三个步骤，1.配置路由服务器，2.构建配置服务器，3.构建分片服务器

五、分片管理示例

集合分片

mongos> use school

mongos> sh.enableSharding("school")       ##开启school库的分片功能

mongos> for(var i=1;i<=50000;i++)db.test.insert({"id":i,"name":"test"+i})     ##插入50000条数据

mongos> show tables    ##查看集合
info
system.indexes
test

mongos> db.test.count()      ##统计有5000条记录
50000

mongos> db.test.find().limit(3)       ##查看开头三条数据，数据插入成功
{ "_id" : ObjectId("5fa8483f3a9549125843e1f8"), "id" : 1, "name" : "test1" }
{ "_id" : ObjectId("5fa8483f3a9549125843e1f9"), "id" : 2, "name" : "test2" }
{ "_id" : ObjectId("5fa8483f3a9549125843e1fa"), "id" : 3, "name" : "test3" }

mongos> db.test.createIndex({"id":1})   ##建立索引，以"id"为索引，从1开始

mongos> sh.shardCollection("school.test",{"id":1})       ##根据索引对test集合进行分片，索引建议最好是能作为主键的字段（非空且唯一），例如像性别这样的键就不适合做索引，除了男就是女两种值。

mongos> sh.status()         ##查看分片信息
--- Sharding Status --- 
……省略部分
  shards:
  	{  "_id" : "shard0000",  "host" : "192.168.10.10:47017" }       ##192.168.10.10:47017节点的id号是shard0000
	{  "_id" : "shard0001",  "host" : "192.168.10.10:47018" }        ##192.168.10.10:47018节点的id号是shard0001

  databases:
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : true }
		school.info                                      ##info集合的分片信息
			shard key: { "id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	3
				shard0001	2
			{ "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0001 Timestamp(2, 0) 
			{ "id" : 4682 } -->> { "id" : 9364 } on : shard0000 Timestamp(3, 1) 
			{ "id" : 9364 } -->> { "id" : 13407 } on : shard0000 Timestamp(2, 2) 
			{ "id" : 13407 } -->> { "id" : 18945 } on : shard0000 Timestamp(2, 3) 
			{ "id" : 18945 } -->> { "id" : { "$maxKey" : 1 } } on : shard0001 Timestamp(3, 0) 
		school.test                                      ##test集合的分片信息
			shard key: { "id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	6               ##6段分片放在节点00上
				shard0001	5                 ##5段分片放在节点01上
			{ "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0001 Timestamp(2, 0)      ##这段分片放在shard01节点上
			{ "id" : 4682 } -->> { "id" : 9364 } on : shard0001 Timestamp(3, 0)                        ##这段分片也是放在shard01节点上
			{ "id" : 9364 } -->> { "id" : 14046 } on : shard0001 Timestamp(4, 0) 
			{ "id" : 14046 } -->> { "id" : 18728 } on : shard0001 Timestamp(5, 0) 
			{ "id" : 18728 } -->> { "id" : 23410 } on : shard0001 Timestamp(6, 0) 
			{ "id" : 23410 } -->> { "id" : 28092 } on : shard0000 Timestamp(6, 1)                  ##这段分片放在shard00节点上
			{ "id" : 28092 } -->> { "id" : 32774 } on : shard0000 Timestamp(1, 6) 
			{ "id" : 32774 } -->> { "id" : 37456 } on : shard0000 Timestamp(1, 7) 
			{ "id" : 37456 } -->> { "id" : 42138 } on : shard0000 Timestamp(1, 8) 
			{ "id" : 42138 } -->> { "id" : 46820 } on : shard0000 Timestamp(1, 9) 
			{ "id" : 46820 } -->> { "id" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 10)

添加标签

mongos> sh.addShardTag("shard0000","slave1")    ##shard0000是节点id号，通过sh.status()可以查到，设置给节点标签slave1
mongos> sh.addShardTag("shard0001","slave2")   ##给shard0001节点打上标签salve2
mongos> sh.status()      ##查看分片信息
--- Sharding Status --- 
  sharding version: {
	"_id" : 1,
	"minCompatibleVersion" : 5,
	"currentVersion" : 6,
	"clusterId" : ObjectId("5fa82c9fef682337a84b13a1")
}
  shards:
	{  "_id" : "shard0000",  "host" : "192.168.10.10:47017",  "tags" : [ "slave1" ] }    ##后面追加了标签信息
	{  "_id" : "shard0001",  "host" : "192.168.10.10:47018",  "tags" : [ "slave2" ] }
……省略部分

添加新节点，查看数据分片情况

注意点：我们所有的操作都通过路由服务器请求配置服务器，有配置服务器完成的
[root@localhost ~]# mongo --port 37017     ##进入配置服务器 
configsvr> use config     ##进入config库
switched to db config
configsvr> show tables      ##可看到这几个集合，我们所有的信息都可以在这些集合中看到
……省略部分
chunks       ##分片数据块信息
collections    ##集合信息
databases    ##数据库信息
……省略部分

configsvr> db.databases.find()       ##可以查看到我们新建的数据库
{ "_id" : "school", "primary" : "shard0000", "partitioned" : true }

configsvr> db.collections.find()    ##可以查看集合信息

configsvr> db.databases.find()   ##可以查看分片（数据块）信息



[root@localhost ~]# mongo    ##进入路由服务器

mongos> sh.addShard("192.168.10.10:47019")       ##再次添加一个分片服务器（上个实验中创建好了的实例）

mongos> sh.status()       ##查看分片信息
-……省略部分
  shards:          ###添加分片节点后，自动更新信息，可以看到多出了一个分片节点
	{  "_id" : "shard0000",  "host" : "192.168.10.10:47017",  "tags" : [ "slave1" ] }
	{  "_id" : "shard0001",  "host" : "192.168.10.10:47018",  "tags" : [ "slave2" ] }
	{  "_id" : "shard0002",  "host" : "192.168.10.10:47019" }
  ……省略部分
  databases:                              ##由下面信息可以看出，分片数据段重新进行了分配，新加的节点与旧节点之间平均分配旧数据
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : true }
		…………省略部分
		school.test
			shard key: { "id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	4
				shard0001	4
				shard0002	3
			{ "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0002 Timestamp(9, 0) 
			{ "id" : 4682 } -->> { "id" : 9364 } on : shard0001 Timestamp(9, 1) 
			{ "id" : 9364 } -->> { "id" : 14046 } on : shard0001 Timestamp(4, 0) 
			{ "id" : 14046 } -->> { "id" : 18728 } on : shard0001 Timestamp(5, 0) 
			{ "id" : 18728 } -->> { "id" : 23410 } on : shard0001 Timestamp(6, 0) 
			{ "id" : 23410 } -->> { "id" : 28092 } on : shard0002 Timestamp(7, 0) 
			{ "id" : 28092 } -->> { "id" : 32774 } on : shard0002 Timestamp(8, 0) 
			{ "id" : 32774 } -->> { "id" : 37456 } on : shard0000 Timestamp(8, 1) 
			{ "id" : 37456 } -->> { "id" : 42138 } on : shard0000 Timestamp(1, 8) 
			{ "id" : 42138 } -->> { "id" : 46820 } on : shard0000 Timestamp(1, 9) 
			{ "id" : 46820 } -->> { "id" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 10)

删除分片节点

mongos> use admin       ###需要先进admin库

mongos> db.runCommand({"removeshard":"192.168.10.10:47019"})     ##删除分片节点

mongos> sh.status()
--- Sharding Status --- 
 ……省略部分
  shards:
	{  "_id" : "shard0000",  "host" : "192.168.10.10:47017",  "tags" : [ "slave1" ] }
	{  "_id" : "shard0001",  "host" : "192.168.10.10:47018",  "tags" : [ "slave2" ] }
	{  "_id" : "shard0002",  "host" : "192.168.10.10:47019",  "draining" : true }      ##显示这台节点停机
 ……省略部分
  databases:                                ##由下面信息可以看出，删除后，数据再次从新分配给存活的两台节点
	{  "_id" : "school",  "primary" : "shard0000",  "partitioned" : true }
		school.test
			shard key: { "id" : 1 }
			unique: false
			balancing: true
			chunks:
				shard0000	6
				shard0001	5
			{ "id" : { "$minKey" : 1 } } -->> { "id" : 4682 } on : shard0000 Timestamp(10, 0) 
			{ "id" : 4682 } -->> { "id" : 9364 } on : shard0001 Timestamp(9, 1) 
			{ "id" : 9364 } -->> { "id" : 14046 } on : shard0001 Timestamp(4, 0) 
			{ "id" : 14046 } -->> { "id" : 18728 } on : shard0001 Timestamp(5, 0) 
			{ "id" : 18728 } -->> { "id" : 23410 } on : shard0001 Timestamp(6, 0) 
			{ "id" : 23410 } -->> { "id" : 28092 } on : shard0001 Timestamp(11, 0) 
			{ "id" : 28092 } -->> { "id" : 32774 } on : shard0000 Timestamp(12, 0) 
			{ "id" : 32774 } -->> { "id" : 37456 } on : shard0000 Timestamp(8, 1) 
			{ "id" : 37456 } -->> { "id" : 42138 } on : shard0000 Timestamp(1, 8) 
			{ "id" : 42138 } -->> { "id" : 46820 } on : shard0000 Timestamp(1, 9) 
			{ "id" : 46820 } -->> { "id" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 10)

总结：由此可以看出，MongoDB数据库非常灵活，无论删除或者添加分片节点，数据自动进行划分，十分有利于服务器的横向扩展，因此在大数据处理上非常受欢迎

知无涯学无尽
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
MongoDB入门与实战-第六章-MongoDB分片
Blueeyedboy521的博客
12-07 673
mongodb分片 猿创征文｜MongoDB数据库 分片集群搭建部署实战 MongoDB 分片集群介绍在Mongodb里面存在另一种集群，就是分片技术,可以满足MongoDB数据量大量增长的需求。当MongoDB存储海量的数据时，一台机器可能不足以存储数据也足以提供可接受的读写吞吐量。这时，我们就可以通过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。应用程序不必知道哪片对应哪些数据,甚至不需要知道数据已经被拆分了，所以在分片之前要运行一个路由进程,进程名，这个路由器知道所有数据的存放位置,所以
MongoDB分片集群部署(三)
wyl9527的博客
12-01 1647
1.分片集群介绍与原理 2.分片集群安装 2.1解压，创建软连接，配置环境变量 2.2config server配置服务器（ configsvr角色） 2.3配置分片副本集三台机器都要配( shardsvr角色 ) 2.3.1设置第一个分片副本集 2.3.2设置第二个分片副本集： 2.3.2设置第三个分片副本集 2.3配置路由服务器mongos(路由角色) 3.启用分片 4.测...
MongoDB 分片集群
最新发布
MJQ12060613的博客
06-06 542
mongos， 提供集群单一入口，转发应用端请求，选择合适的数据节点进行读写，合并多个数据节点的返回。客户请求应发给mongos，而不是 分片服务器，当查询包含分片片键时，mongos将查询发送到指定分片，否则，mongos将查询发送到所有分片，并汇总所有查询结果。当数据段尺寸过大，或者包含过多文档时，触发数据段分裂,只有新增、更新文档时才可能自动触发数据段分裂,数据段分裂通过更新元数据来实现。1. MongoDB的分片时基于集合的，就算有分片集群不等于数据会自动分片，需要显示分片表。
MongoDB搭建分片集群
weixin_41330836的博客
04-14 375
前言 MongoDB分片集群需要三种角色： Shard Server: 该实例是用于存储的实际数据块，在际生产环境中一个shard server角色可由多台机器组成一个relica set承担，以防止服务器单点故障。 Config Server:该实例存储了整个 Cluster Metadata，其中也包括了 chunk 信息。 Route Server:该实例为前端路由，客户端由此接入，通过R...
2021-05-12 MongoDB面试题 构建一个分片集群需要用的那些角色
热门推荐
微软MVP Eleven
05-12 3万+
构建一个分片集群需要用的那些角色？分别是什么？ 1）分片服务器（Shard Server） mongod 实例,用于存储实际的数据块,实际生产环境中一个 shard server 角色可由几台机器组个一个 relica set 承担,防止主机单点故障 这是一个独立普通的mongod进程,保存数据信息。可以是一个副本集也可以是单独的一台服务器。 2）配置服务器（Config Server） mongod 实例,存储了整个 Cluster Metadata,其中包括 chunk 信息。 这是一个独立的mongo
mongodb分片
Meiko记录
09-26 314
分片(sharding)是指将数据库拆分，将其拆分到不同机器的过程，有时也用分区(partitioning)来表示，它是 MongoDB 为应对数据增长需求而采取的办法。 为什么要分片 增加单台服务器可用的磁盘空间 减轻单台服务器的负载 处理单个mongod无法承受的吞吐量 分片原理 在搭建mongodb分片集群之前，我们需要先了解一下其架构和原理，下图是...
MongoDB的分片集群基本配置教程
09-10
总的来说，MongoDB的分片集群提供了一种灵活、高效的方式来处理大数据量的问题，通过合理的配置和管理，可以构建出高度可扩展和可靠的数据库环境。理解并掌握分片集群的配置和管理，对于在大型项目中使用MongoDB至关...
详解MongoDB4.0构建分布式分片群集
09-09
在MongoDB 4.0版本中，引入了分片（Sharding）技术来构建分布式分片群集，以应对高数据量和吞吐量的挑战。分片允许我们将数据分散到多个服务器上，以提高存储能力和处理能力，确保系统的稳定性和性能。 分片简述： ...
mongodb分片集群安装包
06-01
MongoDB是一种流行的开源、分布式文档数据库，用于处理大量数据。分片集群是MongoDB扩展存储能力、提高性能的关键特性，适合大数据应用场景...通过实践，你可以熟练掌握MongoDB分片集群的管理，应对大数据场景的挑战。
MongoDB 分片集群组件
安安静静敲代码
03-15 1297
在搭建 MongoDB 分片集群环境之前，我们先了解一下分片集群包含哪些组件。一个 MongoDB 分片集群（参考官方文档 Sharded Cluster）由以下三个组件构成，缺一不可： 1.shard：每个分片是整体数据的一部分子集。每个分片都可以部署为副本集。强烈建议在生产环境下将分片部署为副本集且最少部署 2 个分片。 2.mongos：充当查询路由器，提供客户端应用程序和分片集群之间的接口...
mongodb----分片集群
bangfox0730的博客
02-17 149
mongodb分片 一般用得比较少，需要较多服务器，还有三种的角色。 一般把mongodb的副本集应用得好就足够用了，可搭建多套mongodb副本集。 mongodb分片技术 mongodb副本集可以解决数据备份，读性能的问题，但由于mongodb副本集是每份数据都是一模一样的，无法解决数据量过大的问题。 mongodb分片技术能够把数据分...
MongoDB主从集群、副本集与分片集群
qq_45511733的博客
08-15 1493
MongoDB主从集群、副本集与分片集群 一、主从复制 主从复制是MongoDB最常用的复制方式,也是一个简单的数据库同步备份的集群技术,这种方式很灵活.可用于备份,故障恢复,读扩展等. 最基本的设置方式就是建立一个主节点和一个或多个从节点,每个从节点要知道主节点的地址。采用双机备份后主节点挂掉了后从节点可以接替主机继续服务。所以这种模式比单节点的高可用性要好很多。 配置主从复制的注意点 1）在数据库集群中要明确的知道谁是主服务器,主服务器只有一台. 2）从服务器要知道自己的数据源也就是对应的主服务是谁.
MongoDB分片集
liuyuhui_gdtyj的博客
06-28 265
环境： 三台CentOS7.6 最小安装，禁用SeLinux。 MongoDB 4.X：各版本下载列表：https://www.mongodb.org/dl/linux/x86_64 数据分片访问示意图： 分片中的角色，有三种： ① 配置服务器。是一个独立的mongod进程，保存集群和分片的元数据，即各分片包含了哪些数据的信息。最先开始建立，启用日志功能。像启动普通的mongod一样启动配置服务...
MongoDB3.x中用户权限
atarik@163.com
03-22 1695
1. 数据库用户角色：read、readWrite;    2. 数据库管理角色：dbAdmin、dbOwner、userAdmin；    3. 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；    4. 备份恢复角色：backup、restore；    5. 所有数据库角
听说MongoDB你很豪横？-------------MongoDB 部署分片群集以及管理分片
weixin_47219935的博客
09-11 1142
文章目录一、副本的概念1、副本集的三个角色2、三种角色:4、缺点二、分片概念三、分片集群包含的组件四、部署 MongoDB 分片群集1、环境准备2、拓扑图如下3、环境搭建4、config配置服务器5、shard服务器6、当某节点内存不足时，从其他节点分配内存7、启动路由服务器8、设置分片9、加入shard节点五、分片管理1、添加数据，进行分片存储2、添加标签3、连接config配置服务器：4、添加/删除分片服务器 一、副本的概念 (3)主从复制和副本集区别 主从集群和制本集最大的区别就是剽本集没有固定的“主
MongoDB高可用集群配置的方案
weixin_33827590的博客
09-29 469
高可用性即HA（High Availability）指的是通过尽量缩短因日常维护操作（计划）和突发的系统崩溃（非计划）所导致的停机时间，以提高系统和应用的可用性。 高可用集群的解决方案 计算机系统的高可用在不同的层面上有不同的表现： （1）网络高可用 由于网络存储的快速发展，网络冗余技术被不断提升，提高IT系统的高可用性的关键应用就是网络高可用性，网络高可用性与网络高可靠性是有区别...
MongoDB 学习笔记：Sharded Cluster
崔显龙的博客
07-23 1657
Shard Key（片键）由文档中的一个或多个字段组成，Shard Key 中的字段必须是某个索引的前缀，即至少需要创建一个索引，且该索引以 Shard Key 作为前缀字段，或该索引仅包含Shard Key字段。当各Shard上的数据量不均衡时，超过某个阈值，将会引发Chunk的迁移操作，数据量过多的Shard中的部分数据，将会以Chunk为单位，迁移至其它Shard中，以达到各Shard相对均衡的状态。Router本身不存储数据，而是用于请求的路由，将请求分发至相应的Shard节点。
mongoDB浅度学习初体验——分片式集群的配置
milu_ELK的博客
05-30 634
mongoDB浅度学习之分片式集群配置笔记
一汽丰田数据湖环境mongoDB分片集群测试
02-06
本次测试主要是针对一汽丰田的数据湖环境中mongoDB分片集群进行的。在测试过程中，我们采用了三台虚拟机，分别为192.168.213.17、192.168.213.18、192.168.213.19，分别命名为slave1.yqft.com、slave2.yqft.com、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值