MongoDB 分片的原理、搭建、应用

最新推荐文章于 2024-05-03 11:18:26 发布
最新推荐文章于 2024-05-03 11:18:26 发布
阅读量805 收藏
点赞数
分类专栏： Mongodb
一、概念：

分片 （sharding）是指将数据库拆分，将其分散在不同的机器上的过程。将数据分散到不同的机器上，不需要功能强大的服务器就可以存储更多的数据和处理更大的负载。

基本思想就是将集合切成小块，这些块分散到若干片里，每个片只负责总数据的一部分。通过一个名为mongos的路由进程进行操作，mongos知道数据和片的对应关系（通过配置服务器）。大部分使用场景都是解决磁盘空间的问题，对于写入有可能会变差（+++里面的说明+++），查询则尽量避免跨分片查询。使用分片的时机：

1，机器的磁盘不够用了。使用分片解决磁盘空间的问题。
2，单个mongod已经不能满足写数据的性能要求。通过分片让写压力分散到各个分片上面，使用分片服务器自身的资源。
3，想把大量数据放到内存里提高性能。和上面一样，通过分片使用分片服务器自身的资源。

二、部署安装 ： 前提是 安装 了mongodb（本文用3.0测试）

在搭建分片之前，先了解下分片中 各个角色 的作用。

① 配置服务器。是一个独立的mongod进程，保存集群和分片的元数据，即各分片包含了哪些数据的信息。最先开始建立，启用日志功能。像启动普通的mongod一样启动配置服务器，指定configsvr选项。不需要太多的空间和资源，配置服务器的1KB空间相当于真是数据的200MB。保存的只是数据的分布表。
② 路由服务器。即mongos，起到一个路由的功能，供程序连接。本身不保存数据，在启动时从配置服务器加载集群信息，开启mongos进程需要知道配置服务器的地址，指定configdb选项。
③ 分片服务器。是一个独立普通的mongod进程，保存数据信息。可以是一个副本集也可以是单独的一台服务器。

部署环境：3台机子

A：配置(3)、路由1、分片1；

B：分片2，路由2；

C：分片3

在部署之前先明白 片键 的意义，一个好的片键对分片至关重要。 片键必须是一个索引 ，通过sh.shardCollection加会自动创建索引。一个自增的片键对写入和数据均匀分布就不是很好，因为自增的片键总会在一个分片上写入，后续达到某个阀值可能会写到别的分片。但是按照片键查询会非常高效。随机片键对数据的均匀分布效果很好。注意尽量避免在多个分片上进行查询。在所有分片上查询，mongos会对结果进行归并排序。

启动上面这些服务，因为在后台运行，所以用配置文件启动，配置文件说明。

1）配置服务器的启动。(A上开启3个，Port：20000、21000、22000) 

配置服务器是一个普通的mongod进程，所以只需要新开一个实例即可。配置服务器必须开启1个或则3个，开启2个则会报错： 

BadValue need either 1 or 3 configdbs

因为要放到后台用用配置文件启动，需要修改配置文件： 

/etc/mongod_20000.conf

#数据目录
dbpath=/usr/local/config/
#日志文件
logpath=/var/log/mongodb/mongodb_config.log
#日志追加
logappend=true
#端口
port = 20000
#最大连接数
maxConns = 50
pidfilepath = /var/run/mongo_20000.pid
#日志,redo log
journal = true
#刷写提交机制
journalCommitInterval = 200
#守护进程模式
fork = true
#刷写数据到日志的频率
syncdelay = 60
#storageEngine = wiredTiger
#操作日志,单位M
oplogSize = 1000
#命名空间的文件大小,默认16M，最大2G。
nssize = 16
noauth = true
unixSocketPrefix = /tmp
configsvr = true

/etc/mongod_21000.conf

数据目录
dbpath=/usr/local/config1/
#日志文件
logpath=/var/log/mongodb/mongodb_config1.log
#日志追加
logappend=true
#端口
port = 21000
#最大连接数
maxConns = 50
pidfilepath = /var/run/mongo_21000.pid
#日志,redo log
journal = true
#刷写提交机制
journalCommitInterval = 200
#守护进程模式
fork = true
#刷写数据到日志的频率
syncdelay = 60
#storageEngine = wiredTiger
#操作日志,单位M
oplogSize = 1000
#命名空间的文件大小,默认16M，最大2G。
nssize = 16
noauth = true
unixSocketPrefix = /tmp
configsvr = true

开启配置服务器：

root@mongo1:~# mongod -f /etc/mongod_20000.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 8545
child process started successfully, parent exiting

root@mongo1:~# mongod -f /etc/mongod_21000.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 8595
child process started successfully, parent exiting

同理再起一个22000端口的配置服务器。

#数据目录
dbpath=/usr/local/config2/
#日志文件
logpath=/var/log/mongodb/mongodb_config2.log
#日志追加
logappend=true
#端口
port = 22000
#最大连接数
maxConns = 50
pidfilepath = /var/run/mongo_22000.pid
#日志,redo log
journal = true
#刷写提交机制
journalCommitInterval = 200
#守护进程模式
fork = true
#刷写数据到日志的频率
syncdelay = 60
#storageEngine = wiredTiger
#操作日志,单位M
oplogSize = 1000
#命名空间的文件大小,默认16M，最大2G。
nssize = 16

noauth = true
unixSocketPrefix = /tmp

configsvr = true
View Code

2）路由服务器的启动。(A、B上各开启1个，Port：30000)

路由服务器不保存数据，把日志记录一下即可。

# mongos

#日志文件
logpath=/var/log/mongodb/mongodb_route.log
#日志追加
logappend=true
#端口
port = 30000
#最大连接数
maxConns = 100
#绑定地址
#bind_ip=192.168.200.*,...,

pidfilepath = /var/run/mongo_30000.pid

configdb=192.168.200.A:20000,192.168.200.A:21000,192.168.200.A:22000  #必须是1个或则3个配置 。
#configdb=127.0.0.1:20000  #报错
#守护进程模式 fork = true
其中最重要的参数是

configdb，不能在其后面带的配置服务器的地址写成localhost或则127.0.0.1，需要设置成其他分片也能访问的地址，即192.168.200.A:20000/21000/22000。否则在addshard的时候会报错：

{
"ok" : 0,
"errmsg" : "can't use localhost as a shard since all shards need to communicate. either use all shards and configdbs in localhost or all in actual IPs  host: 172.16.5.104:20000 isLocalHost:0"
}

开启mongos：

root@mongo1:~# mongos -f /etc/mongod_30000.conf 
2015-07-10T14:42:58.741+0800 W SHARDING running with 1 config server should be done only for testing purposes and is not recommended for production
about to fork child process, waiting until server is ready for connections.
forked process: 8965
child process started successfully, parent exiting

3）分片服务器的启动：

就是一个普通的mongod进程：

root@mongo1:~# mongod -f /etc/mongod_40000.conf 
note: noprealloc may hurt performance in many applications
about to fork child process, waiting until server is ready for connections.
forked process: 9020
child process started successfully, parent exiting

A服务器上面的服务开启完毕

root@mongo1:~# ps -ef | grep mongo
root      9020     1  0 14:47 ?        00:00:06 mongod -f /etc/mongod_40000.conf
root      9990     1  0 15:14 ?        00:00:02 mongod -f /etc/mongod_20000.conf
root     10004     1  0 15:14 ?        00:00:01 mongod -f /etc/mongod_21000.conf
root     10076     1  0 15:20 ?        00:00:00 mongod -f /etc/mongod_22000.conf
root     10096     1  0 15:20 ?        00:00:00 mongos -f /etc/mongod_30000.conf

按照上面的方法再到B上开启分片服务和路由服务(配置文件一样)，以及在C上开启分片服务。 到此分片的配置服务器、路由服务器、分片服务器都已经部署完成。

三、配置分片： 下面的操作都是在mongodb的命令行里执行

1）添加分片：sh.addShard("IP:Port") 

登陆路由服务器 mongos 操作 ：

root@mongo1:~# mongo --port=30000
MongoDB shell version: 3.0.4
connecting to: 127.0.0.1:30000/test
mongos>

添加分片：

mongos> sh.status()    #查看集群的信息
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("559f72470f93270ba60b26c6")
}
  shards:
  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" : "admin",  "partitioned" : false,  "primary" : "config" }

mongos> sh.addShard("192.168.200.A:40000") #添加分片
{ "shardAdded" : "shard0000", "ok" : 1 }
mongos> sh.addShard("192.168.200.B:40000") #添加分片
{ "shardAdded" : "shard0001", "ok" : 1 }
mongos> sh.addShard("192.168.200.C:40000") #添加分片
{ "shardAdded" : "shard0002", "ok" : 1 }

mongos> sh.status()    #查看集群信息
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("559f72470f93270ba60b26c6")
}
  shards:  #分片信息
    {  "_id" : "shard0000",  "host" : "192.168.200.A:40000" }
    {  "_id" : "shard0001",  "host" : "192.168.200.B:40000" }
    {  "_id" : "shard0002",  "host" : "192.168.200.C:40000" }
  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" : "admin",  "partitioned" : false,  "primary" : "config" }

2）开启分片功能：sh.enableSharding("库名")、sh.shardCollection("库名.集合名",{"key":1})

mongos> sh.enableSharding("dba")  #首先对数据库启用分片
{ "ok" : 1 }
mongos> sh.status()               #查看分片信息
--- Sharding Status ---...
...
  databases:
    {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
    {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
    {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }

mongos> sh.shardCollection("dba.account",{"name":1})    #再对集合进行分片，name字段是片键。
{ "collectionsharded" : "dba.account", "ok" : 1 }
mongos> sh.status()
--- Sharding Status ---...
  shards:
    {  "_id" : "shard0000",  "host" : "192.168.200.51:40000" }
    {  "_id" : "shard0001",  "host" : "192.168.200.52:40000" }
    {  "_id" : "shard0002",  "host" : "192.168.200.53:40000" }
...
  databases:
    {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
    {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
    {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }  #库
        dba.account
            shard key: { "name" : 1 }                                    #集合
            chunks:
                shard0000    1
            { "name" : { "$minKey" : 1 } } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 0)

上面加粗部分表示分片信息已经配置完成。

四、测试 ： 对dba库的account集合进行测试，随机写入，查看是否分散到3个分片中。

通过一个python脚本进行随机写入：分别向A、B 2个mongos各写入10万条记录。

#!/usr/bin/env python
#-*- coding:utf-8 -*-
#随即写MongoDB Shard 测试
import pymongo
import time
from random import Random
def random_str(randomlength=8):
  str = ''
  chars = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789'
  length = len(chars) - 1
  random = Random()
  for i in range(randomlength):
    str+=chars[random.randint(0, length)]
    return str
def inc_data(conn):
  db = conn.dba
#	db = conn.test
  collection = db.account
  for i in range(100000):
    str = ''
    chars = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789'
    length = len(chars) - 1
    random = Random()
    for i in range(15):
      str+=chars[random.randint(0, length)]
      string = str
    collection.insert({"name" : string, "age" : 123+i, "address" : "hangzhou"+string})
if __name__ =='__main__':
  conn = pymongo.MongoClient(host='192.168.200.A/B',port=30000)
  StartTime = time.time()
  print "===============$inc==============="
  print "StartTime : %s" %StartTime
  inc_data(conn)
  EndTime = time.time()
  print "EndTime : %s" %EndTime
  CostTime = round(EndTime-StartTime)
  print "CostTime : %s" %CostTime
View Code

查看是否分片：db.collection.stats()

mongos> db.account.stats() #查看集合的分布情况
...
...
  "shards" : {
    "shard0000" : {
      "ns" : "dba.account",
      "count" : 89710,
      "size" : 10047520,
...
...
    "shard0001" : {
      "ns" : "dba.account",
      "count" : 19273,
      "size" : 2158576,
...
...
    "shard0002" : {
      "ns" : "dba.account",
      "count" : 91017,
      "size" : 10193904,
...
...

上面加粗部分为集合的基本信息，可以看到分片成功，各个分片都有数据(count)。到此MongoDB分片集群搭建成功。

++++++++++++++++++++++++++++++++++++++++++++++++

感兴趣的同学可以看下面这个比较有趣的现象：

#在写之前分片的基本信息：
mongos> sh.status()
--- Sharding Status --- 
...
...
  databases:
    {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
    {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
    {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }
        dba.account
            shard key: { "name" : 1 }
            chunks:
  shard0000    1
            { "name" : { "$minKey" : 1 } } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 0)   #可以看到这里片键的写入，都是写在shard0000里面的。

#在写期间的分片基本信息：
mongos> sh.status()
--- Sharding Status --- 
...
...
  databases:
    {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
    {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
    {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }
        dba.account
            shard key: { "name" : 1 }
            chunks:          #数据块分布
  shard0000    1
  shard0001    1
  shard0002    1
            { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
            { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 0) 
            { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(3, 1)   #可以看到片键写入的基本分布

#在写完成后的基本信息：
mongos> sh.status()
--- Sharding Status --- 
...
...
  databases:
    {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
    {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
    {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }
        dba.account
            shard key: { "name" : 1 }
            chunks:          #数据块分布
  shard0000    2
  shard0001    1
  shard0002    2
            { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
            { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "UavMbMlfszZOFrz" } on : shard0000 Timestamp(4, 0) 
            { "name" : "UavMbMlfszZOFrz" } -->> { "name" : "t9LyVSNXDmf6esP" } on : shard0002 Timestamp(4, 1) 
            { "name" : "t9LyVSNXDmf6esP" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 4) 
            { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(3, 1)  #最后片键写入的分布

上面加粗的信息对比上看到，本来在每个分片上都只有一个块，最后在shard0000、shard0002上有2个块，被拆分了。shard0001不变。 这是因为mongos在收到写请求的时候，会检查当前块的拆分阀值点。到达该阀值的时候，会向分片发起一个拆分的请求。 例子中shard0000和shard0002里的块被拆分了。分片内的数据进行了迁移（有一定的消耗），最后通过一个均衡器来对数据进行转移分配。所以在写入途中要是看到一个分片中集合的数量变小也是正常的。

balancer:  #均衡器
    Currently enabled:  yes
    Currently running:  yes   #正在转移
        Balancer lock taken at Fri Jul 10 2015 22:57:27 GMT+0800 (CST) by mongo2:30000:1436540125:1804289383:Balancer:846930886

所以要是遇到分片写入比单点 写入慢就是因为分片路由服务（mongos）需要维护元数据、数据迁移、路由开销等 。

++++++++++++++++++++++++++++++++++++++++++++++++ 

五、高可用：Sharding+Replset

上面的分片都是单点的，要是一个分片坏了，则数据会丢失，利用之前减少的副本集，能否把副本集加入到分片中？下面就来说明下。

1）添加副本集分片服务器（mmm副本集名称）：这里测试就只对一个分片加副本集，要实现完全的高可用就需要对所有分片加副本集，避免单点故障

一个普通的副本集：

mmm:PRIMARY> rs.status()
{
  "set" : "mmm",
  "date" : ISODate("2015-07-10T16:17:19Z"),
  "myState" : 1,
  "members" : [
    {
      "_id" : 2,
      "name" : "192.168.200.245:27017",
      "health" : 1,
      "state" : 2,
      "stateStr" : "SECONDARY",
      "uptime" : 418,
      "optime" : Timestamp(1436545003, 1),
      "optimeDate" : ISODate("2015-07-10T16:16:43Z"),
      "lastHeartbeat" : ISODate("2015-07-10T16:17:17Z"),
      "lastHeartbeatRecv" : ISODate("2015-07-10T16:17:18Z"),
      "pingMs" : 0,
      "syncingTo" : "192.168.200.25:27017"
    },
    {
      "_id" : 3,
      "name" : "192.168.200.25:27017",
      "health" : 1,
      "state" : 1,
      "stateStr" : "PRIMARY",
      "uptime" : 891321,
      "optime" : Timestamp(1436545003, 1),
      "optimeDate" : ISODate("2015-07-10T16:16:43Z"),
      "self" : true
    },
    {
      "_id" : 4,
      "name" : "192.168.200.245:37017",
      "health" : 1,
      "state" : 2,
      "stateStr" : "SECONDARY",
      "uptime" : 36,
      "optime" : Timestamp(1436545003, 1),
      "optimeDate" : ISODate("2015-07-10T16:16:43Z"),
      "lastHeartbeat" : ISODate("2015-07-10T16:17:17Z"),
      "lastHeartbeatRecv" : ISODate("2015-07-10T16:17:17Z"),
      "pingMs" : 0,
      "syncingTo" : "192.168.200.25:27017"
    }
  ],
  "ok" : 1
}
View Code

现在需要把这个副本集加入到分片中：

mongos> sh.addShard("mmm/192.168.200.25:27017,192.168.200.245:27017,192.168.200.245:37017") #加入副本集分片
{ "shardAdded" : "mmm", "ok" : 1 }
mongos> sh.status()
--- Sharding Status --- 
...
...
shards:
  {  "_id" : "mmm",  "host" : "mmm/192.168.200.245:27017,192.168.200.245:37017,192.168.200.25:27017" }
  {  "_id" : "shard0000",  "host" : "192.168.200.51:40000" }
  {  "_id" : "shard0001",  "host" : "192.168.200.52:40000" }
  {  "_id" : "shard0002",  "host" : "192.168.200.53:40000" }
  balancer:
  Currently enabled:  yes
  Currently running:  no
  Failed balancer rounds in last 5 attempts:  0
  Migration Results for the last 24 hours: 
    4 : Success
  databases:
  {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
  {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
  {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }
    dba.account
      shard key: { "name" : 1 }
      chunks:
        mmm	1
        shard0000	1
        shard0001	1
        shard0002	2
      { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
      { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "UavMbMlfszZOFrz" } on : mmm Timestamp(5, 0) 
      { "name" : "UavMbMlfszZOFrz" } -->> { "name" : "t9LyVSNXDmf6esP" } on : shard0002 Timestamp(4, 1) 
      { "name" : "t9LyVSNXDmf6esP" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 4) 
      { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(5, 1) 
  {  "_id" : "abc",  "partitioned" : false,  "primary" : "shard0000" }   #未设置分片

上面加粗部分表示副本集分片已经成功加入，并且 新加入的分片会分到已有的分片数据 。

mongos> db.account.stats()
...
...
  "shards" : {
    "mmm" : {
      "ns" : "dba.account",
      "count" : 7723,		#后加入的分片得到了数据
      "size" : 741408,
      "avgObjSize" : 96,
      "storageSize" : 2793472,
      "numExtents" : 5,
      "nindexes" : 2,
      "lastExtentSize" : 2097152,
      "paddingFactor" : 1,
      "systemFlags" : 1,
      "userFlags" : 0,
      "totalIndexSize" : 719488,
      "indexSizes" : {
        "_id_" : 343392,
        "name_1" : 376096
      },
      "ok" : 1
    },
...
...

2）继续用python脚本写数据，填充到副本集中  

由于之前的副本集是比较老的版本（2.4），所以在写入副本集分片的时候报错：

mongos> db.account.insert({"name":"UavMbMlfsz1OFrz"})
WriteResult({
    "nInserted" : 0,
    "writeError" : {
        "code" : 83,
        "errmsg" : "write results unavailable from 192.168.200.25:27017 :: caused by :: Location28563 cannot send batch write operation to server 192.168.200.25:27017 (192.168.200.25)"
    }
})

太混蛋了，错误提示不太人性化，搞了半天。所以说版本一致性还是很重要的。现在重新开了一个副本集：

mablevi:PRIMARY> rs.status()
{
  "set" : "mablevi",
  "date" : ISODate("2015-07-10T18:22:36.761Z"),
  "myState" : 1,
  "members" : [
    {
      "_id" : 1,
      "name" : "192.168.200.53:50000",
      "health" : 1,
      "state" : 1,
      "stateStr" : "PRIMARY",
      "uptime" : 820,
      "optime" : Timestamp(1436552412, 213),
      "optimeDate" : ISODate("2015-07-10T18:20:12Z"),
      "electionTime" : Timestamp(1436551910, 1),
      "electionDate" : ISODate("2015-07-10T18:11:50Z"),
      "configVersion" : 2,
      "self" : true
    },
    {
      "_id" : 2,
      "name" : "192.168.200.53:50001",
      "health" : 1,
      "state" : 2,
      "stateStr" : "SECONDARY",
      "uptime" : 650,
      "optime" : Timestamp(1436552412, 213),
      "optimeDate" : ISODate("2015-07-10T18:20:12Z"),
      "lastHeartbeat" : ISODate("2015-07-10T18:22:36.737Z"),
      "lastHeartbeatRecv" : ISODate("2015-07-10T18:22:36.551Z"),
      "pingMs" : 0,
      "syncingTo" : "192.168.200.53:50000",
      "configVersion" : 2
    },
    {
      "_id" : 3,
      "name" : "192.168.200.53:50002",
      "health" : 1,
      "state" : 2,
      "stateStr" : "SECONDARY",
      "uptime" : 614,
      "optime" : Timestamp(1436552412, 213),
      "optimeDate" : ISODate("2015-07-10T18:20:12Z"),
      "lastHeartbeat" : ISODate("2015-07-10T18:22:36.742Z"),
      "lastHeartbeatRecv" : ISODate("2015-07-10T18:22:36.741Z"),
      "pingMs" : 0,
      "syncingTo" : "192.168.200.53:50001",
      "configVersion" : 2
    }
  ],
  "ok" : 1,
  "$gleStats" : {
    "lastOpTime" : Timestamp(1436551942, 1),
    "electionId" : ObjectId("55a00ae6a08c789ce9e4b50d")
  }
}
View Code

把之前的副本集分片删除了，如何删除见下面3）。

新的副本集加入分片中：

mongos> sh.addShard("mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002")
{ "shardAdded" : "mablevi", "ok" : 1 }
mongos> sh.status()
--- Sharding Status --- 
...
...
  shards:
  {  "_id" : "mablevi",  "host" : "mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002" }
  {  "_id" : "shard0000",  "host" : "192.168.200.51:40000" }
  {  "_id" : "shard0001",  "host" : "192.168.200.52:40000" }
  {  "_id" : "shard0002",  "host" : "192.168.200.53:40000" }
...
...
    dba.account
      shard key: { "name" : 1 }
      chunks:
        mablevi	1
        shard0000	1
        shard0001	1
        shard0002	2
      { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
        { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "UavMbMlfszZOFrz" } on : mablevi Timestamp(9, 0) #新加入的分片得到数据
      { "name" : "UavMbMlfszZOFrz" } -->> { "name" : "t9LyVSNXDmf6esP" } on : shard0002 Timestamp(4, 1) 
      { "name" : "t9LyVSNXDmf6esP" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 4) 
      { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(9, 1) 
  {  "_id" : "abc",  "partitioned" : false,  "primary" : "shard0000" }
  {  "_id" : "mablevi",  "partitioned" : false,  "primary" : "shard0001" }

继续用python写入操作：

mongos> db.account.stats()
{
...
...
  "shards" : {
    "mablevi" : {
      "ns" : "dba.account",
      "count" : 47240,
      "size" : 5290880,
...
...

副本集的分片被写入了47240条记录。此时把副本集分片的Primary shutdown掉，再查看：

mongos> db.account.stats()
{
  "sharded" : true,
  "code" : 13639,
  "ok" : 0,
  "errmsg" : "exception: can't connect to new replica set master [192.168.200.53:50000], err: couldn't connect to server 192.168.200.53:50000 (192.168.200.53), connection attempt failed"  #由于副本集的Primary被shutdown之后，选举新主还是要几秒的时间，期间数据不能访问，导致分片数据也不能访问
}
mongos> db.account.stats()
...
...
  "shards" : {
    "mablevi" : {
      "ns" : "dba.account",
      "count" : 47240,	   #副本集新主选举完毕之后，分片数据访问正常。数据没有丢失，高可用得到了实现。
      "size" : 5290880,
...
...

要是让副本集分片只剩下一台（Secondary），则分片会报错 ： 

mongos> db.account.stats()
{
    "sharded" : true,
    "code" : 10009,
    "ok" : 0,
    "errmsg" : "exception: ReplicaSetMonitor no master found for set: mablevi" #数据不能访问
}
3）删除分片： db.runCommand({"removeshard":"mmm"})

要是觉得分片太多了，想删除，则：

mongos> use admin   #需要到admin下面删除
switched to db admin
mongos> db.runCommand({"removeshard":"mmm"})
{
  "msg" : "draining started successfully",
  "state" : "started",   #开始删除，数据正在转移
  "shard" : "mmm",
  "ok" : 1
}
mongos> sh.status()
--- Sharding Status ---...
...
  shards:
  {  "_id" : "mmm",  "host" : "mmm/192.168.200.245:27017,192.168.200.245:37017,192.168.200.25:27017",  "draining" : true }  #删除的分片数据移动到其他分片
  {  "_id" : "shard0000",  "host" : "192.168.200.51:40000" }
  {  "_id" : "shard0001",  "host" : "192.168.200.52:40000" }
  {  "_id" : "shard0002",  "host" : "192.168.200.53:40000" }
...
...
  databases:
  {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
  {  "_id" : "test",  "partitioned" : false,  "primary" : "shard0000" }
  {  "_id" : "dba",  "partitioned" : true,  "primary" : "shard0000" }
    dba.account
      shard key: { "name" : 1 }
      chunks:
        shard0000	2
        shard0001	1
        shard0002	2
      { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
      { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "UavMbMlfszZOFrz" } on : shard0000 Timestamp(8, 0) 
      { "name" : "UavMbMlfszZOFrz" } -->> { "name" : "t9LyVSNXDmf6esP" } on : shard0002 Timestamp(4, 1) #这里已经没有了被删除分片信息
      { "name" : "t9LyVSNXDmf6esP" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 4) 
      { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(7, 1) 
  {  "_id" : "abc",  "partitioned" : false,  "primary" : "shard0000" }
  {  "_id" : "mablevi",  "partitioned" : false,  "primary" : "shard0001" }
mongos> db.runCommand({"removeshard":"mmm"})   #再次执行，直到执行成功，要是原来分片的数据比较大，这里比较费时。
{
  "msg" : "removeshard completed successfully",
  "state" : "completed",  #完成删除
  "shard" : "mmm",
  "ok" : 1
}
mongos> sh.status()
--- Sharding Status ---...
  shards:   #分片消失
  {  "_id" : "shard0000",  "host" : "192.168.200.51:40000" }
  {  "_id" : "shard0001",  "host" : "192.168.200.52:40000" }
  {  "_id" : "shard0002",  "host" : "192.168.200.53:40000" }
...
...
      { "name" : { "$minKey" : 1 } } -->> { "name" : "5yyfY8mmR5HyhGJ" } on : shard0001 Timestamp(2, 0) 
      { "name" : "5yyfY8mmR5HyhGJ" } -->> { "name" : "UavMbMlfszZOFrz" } on : shard0000 Timestamp(8, 0) 
      { "name" : "UavMbMlfszZOFrz" } -->> { "name" : "t9LyVSNXDmf6esP" } on : shard0002 Timestamp(4, 1) #已经没有了被删除分片的信息
      { "name" : "t9LyVSNXDmf6esP" } -->> { "name" : "woQAv99Pq1FVoMX" } on : shard0002 Timestamp(3, 4) 
      { "name" : "woQAv99Pq1FVoMX" } -->> { "name" : { "$maxKey" : 1 } } on : shard0000 Timestamp(7, 1) 
  {  "_id" : "abc",  "partitioned" : false,  "primary" : "shard0000" }
  {  "_id" : "mablevi",  "partitioned" : false,  "primary" : "shard0001" }

分片被删除之后，数据被移到其他分片中，不会丢失。 

刷新下配置服务器：db.adminCommand({"flushRouterConfig":1})
db.adminCommand({"flushRouterConfig":1})

最后来查看下分片成员：db.runCommand({ listshards : 1 })

mongos> use admin  #需要进入admin才能执行
switched to db admin
mongos> db.runCommand({ listshards : 1 })
{
  "shards" : [
    {
      "_id" : "shard0000",
      "host" : "192.168.200.51:40000"
    },
    {
      "_id" : "shard0001",
      "host" : "192.168.200.52:40000"
    },
    {
      "_id" : "shard0002",
      "host" : "192.168.200.53:40000"
    },
    {
      "_id" : "mablevi",
      "host" : "mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002"
    }
  ],
  "ok" : 1
}

到此已经把MongoDB分片原理、搭建、应用大致已经介绍完。

六、总结：

分片很好的解决了单台服务器磁盘空间、内存、cpu等硬件资源的限制问题，把数据水平拆分出去，降低单节点的访问压力。每个分片都是一个独立的数据库，所有的分片组合起来构成一个逻辑上的完整的数据库。因此，分片机制降低了每个分片的数据操作量及需要存储的数据量，达到多台服务器来应对不断增加的负载和数据的效果。后面文章还会继续对分片的其他方面进行说明介绍。

参考文档：

说明： http://docs.mongodb.org/manual/core/sharding-introduction/

配置： http://docs.mongodb.org/manual/tutorial/deploy-shard-cluster/

应用： http://www.caiyiting.com/blog/2014/replica-sets-sharding-realization.html

amery2011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第五部分 架构篇 第十九章 MongoDB Sharding 架构（ mongos）
u014548782的专栏
12-18 2845
1、mongos mongos是用户和集群间的交互点，其职责是隐藏分片内部的复杂性并向用户提供一个简洁的单服务器接口，这个抽象层中也存在一些缝隙，不过大多数情况下mongos允许你把一个集群当做一台服务器。 使用集群时，应该连接一个mongos并向它发送所有的读写操作，无论如何，你都不应该直接访问分片(但如果想的话能做到)。 mongos会将所有用户请求转发到恰当的分片上，如果用户插入一份文档，mongos会查看文档的片键，对照数据块，并把文档发送到持有相应块的分片上。 举个例子，比如说我们要插入{
MongoDB4.2分片及副本集群搭建
04-21
MongoDB4.2分片及副本集群搭建 MongoDB集群 MongoDB分片 MongoDB副本 MongoDB副本集群
[Mongodb 5.0]将副本集中的Secondary节点变为Arbiter节点
无bug无江湖
05-13 1050
前言 Arbiter节点也被成为仲裁节点，也就是用来投票用的节点。当我们不在想将副本集中的某个Secondary节点用来保存数据的时候，而是仅仅想用它在选举Primary节点时进行投票使用，那么我们就可以考虑将这个Secondary节点变为Arbiter节点。 场景 我们假设已创建了一个副本集（没创建的可参考前面的文章）如下表格所示： PSS模式（还有PSA模式） 地址 别名 Secondary 192.168.40.128 节点1 Primary 192.16
MongoDB分片原理篇
最新发布
2401_84097774的博客
05-03 649
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！何时使用分片技术分片技术，使得集合中的数据分散到多个分片集中。使得MongoDB具备横向的发展。Sharded cluster由Shard、Mongos和Config server 3个组件构成。Mongos是Sharded cluster的访问入口，Mongos本身并不持久化数据，Sharded cluster所有的元数据都会存储到Config Server而用户的数据则会分散存储到各个shard。Mong
Mongodb-sharding
weixin_43394724的博客
01-31 2003
Practical MongoDB Aggregations Book 概述 分片（sharding）是一种跨多台机器分布数据的方法， MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。 MongoDB分片群集包含以下组件： 分片（存储）：每个分片包含分片数据的子集。 每个分片都可以部署为副本集。 mongos（路由）：mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口 config servers（“调度”的配置）：配置服务器存储群集的元数据和配置设置。 从MongoD
mongodb 基本原理：分片（Sharding）
guangyacyb的博客
02-16 4575
分片是将数据分布在多台机器的方法。MongoDB 使用分片来提供海量数据的部署和高吞吐操作 . 这种数据库系统可以挑战单服务器的最高容量，例如高频率的查询可以将服务器的cpu容量发挥到极致。超出系统内存的数据集则会充分调用磁盘的IO。 面对系统扩充有两种方法：垂直扩展和水平扩展 垂直扩展 提高单台服务器的容量，例如使用更强的cpu，加内存，存储空间。技术的局限限制了单台机器面对高负载的能...
mongodb副本集搭建
09-08
MongoDB 副本集搭建 MongoDB 副本集搭建是 MongoDB 的高可用性解决方案之一，它可以提供数据的冗余存储和自动故障转移，确保数据的高可用性和可靠性。下面将详细介绍 MongoDB 副本集搭建的步骤和过程。 一、安装...
Mongodb分片副本集集群搭建
04-04
搭建Mongodb分片集群的步骤文档，度娘上很多坑，被坑的可以看看，本文档专门埋坑。
mongodb 分片集群搭建过程（无副本）
04-18
mongodb 分片集群搭建过程（无副本），详细操作步骤，linux命令
MongoDB分片详解
09-09
传统手动分片需要应用程序自行管理和协调多个数据库服务器，而MongoDB提供了自动分片功能，通过路由进程（mongos）自动管理数据分布和负载均衡，简化了管理和运维。 2. MongoDB的自动分片： MongoDB的自动分片机制...
MongoDB - mongod 与 mongos
weixin_33694172的博客
04-26 3331
mongod 与 mongos mongod 概要 mongod is the primary daemon process for the MongoDB system. It handles data requests, manages data access, and performs background managemen...
MongoDB 分布式操作——分片操作
he91-com
08-31 245
MongoDB 分布式操作——分片操作 描述： 像其它分布式数据库一样，MongoDB同样支持分布式操作，且MongoDB将分布式已经集成到数据库中，其分布式体系如下图所示： 所谓的片，其实就是一个单独的MongoDB进程，它可以运行在不同的节点上，也可以运行在同一节点但监听不同的端口。同一个集合的数据可能在每个片中都存储的有数据，但它们在逻辑上整合成一个整体。分片的依据往往是根...
mongos
weixin_30677475的博客
08-01 1157
官方文档：https://docs.mongodb.com/manual/reference/program/mongos/#bin.mongos mongos是MongoDB shard的缩写，它是一个为应用层提供查询请求并决定数据在MongoDB分片中位置的路由服务。从应用层的角度来看，mongos的行为和一个MongoDB实例是没有区别的。 详细的配置参数，大概浏览一遍官方文档...
Mongod启用分片
Mori技术客栈
07-14 655
    在Mongodb中扩展可以通过横向扩展数据来处理，这种操作叫做分片。     通过跨服务器横向划分数据集，每台服务器负责处理自己的数据部分同时不会有一台服务器会负载过重，这样分片就可以支持大数据集和高吞吐量。每一个分片都是一个独立的数据库，所有的分片共同组成单个的逻辑数据库。分片集群中的组件：        分片数据服务器        mongos（路由服务器）        配置服务器...
MongoDB分片原理及架构详解
am_Linux的博客
03-20 455
有一点需要注意，一个自增的Shard Key对写入和数据均匀分布不是很友好，因为自增的Shard Key总会在一个分片上写入，后续达到某个阀值才可能会写到别的分片上。使用分片减少了每个分片存储的数据。高数据量和吞吐量的数据库应用会对单机的性能造成较大压力，大的查询量会将单机的CPU耗尽，大的数据量对单机的存储压力较大，最终会耗尽系统的内存而将压力转移到磁盘IO上。MongoDB分片是指将数据库拆分成多份，把它们分散到不同的机器上，从而实现不需要功能强大的服务器就可以存储更多的数据和处理更多的请求。
MongoDB分片原理篇，springboot线程池原理
m0_64204730的博客
11-18 545
存储容量需求超出单机磁盘容量 活跃的数据集超出单机内存容量，导致很多请求都要从磁盘读取数据，影响性能 写IOPS超出单个MongoDB节点的写服务能力 分片技术，使得集合中的数据分散到多个分片集中。使得MongoDB具备横向的发展。 Sharded cluster 分片架构 Sharded cluster由Shard、Mongos和Config server 3个组件构成。 Mongos是Sharded cluster的访问入口， Mongos本身并不持久化数据，Sharded.
关于Linux主机报错(Resource temporarily unavailable)的解决办法
热门推荐
Steven的博客
05-14 1万+
现象描述:主机登陆或者切换用户时报错资源暂时不可用(Resource temporarily unavailable)。[root@zyserver ~]# su - oracle-bash: fork: retry: Resource temporarily unavailable-bash: fork: retry: Resource temporarily unavailable-bash:...
mongodb分片集群搭建
09-26
为了搭建mongodb分片集群，首先需要配置每个分片的mongod服务组成副本集。每个分片可以由多台mongod服务组成。配置过程相同，并且需要在每个分片上依次启动mongod程序。然后需要初始化shard副本集和config server...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值