[ MongoDB ] 分片集群及测试

分片

在Mongodb里面存在另一种集群,就是分片技术,可以满足MongoDB数据量大量增长的需求。

当MongoDB存储海量的数据时,一台机器可能不足以存储数据,也可能不足以提供可接受的读写吞吐量。这时,我们就可以通过在多台机器上分割数据,使得数据库系统能存储和处理更多的数据。

为什么使用分片?

    1. 复制所有的写入操作到主节点
    2. 延迟的敏感数据会在主节点查询
    3. 单个副本集限制在12个节点
    4. 当请求量巨大时会出现内存不足。
    5. 本地磁盘不足
    6. 垂直扩展价格昂贵

Shard:
    用于存储实际的数据块,实际生产环境中一个shard server角色可由几台机器组个一个relica set承担,防止主机单点故障

Config Server:
    mongod实例,存储了整个 ClusterMetadata,其中包括 chunk信息。

Query Routers:
    前端路由,客户端由此接入,且让整个集群看上去像单一数据库,前端应用可以透明使用。

分片实例:
    node1:10.0.0.10 -- 3个Config Server、1个Routers、1个Shard
    node2:10.0.0.11 -- 1个Routers、1个Shard
    node3:10.0.0.12 -- 1个Shard

注意:在做分片的时候,要避免Shard在同一台主机上,这样就没办法实现分片。

 

node1 配置如下:


三个Shard 的配置文件:

[root@node1 conf]# ls
mongosvr-20000.conf  mongosvr-21000.conf  mongosvr-22000.conf
[root@node1 conf]# vim mongosvr-20000.conf 

systemLog:
 destination: file
###日志存储位置
 path: /mongodb/logs/mongosvr-20000.log
 logAppend: true
storage:
##journal配置
 journal:
  enabled: true
##数据文件存储位置
 dbPath: /mongodb/data/mongosvr-20000
##是否一个库一个文件夹
 directoryPerDB: true
##数据引擎
 engine: wiredTiger
##WT引擎配置
 wiredTiger:
  engineConfig:
##WT最大使用cache(根据服务器实际情况调节)
   cacheSizeGB: 10
##是否将索引也按数据库名单独存储
   directoryForIndexes: true
##表压缩配置
  collectionConfig:
   blockCompressor: zlib
##索引配置
  indexConfig:
   prefixCompression: true
processManagement:
 fork: true  # fork and run in background
 pidFilePath: /mongodb/socket/mongodsvr-20000.pid
##端口配置
net:
 port: 20000
 bindIp: 10.0.0.10
sharding:
 clusterRole: configsvr

# 启动config服务
[root@node1 ~]# mongod -f /mongodb/conf/mongosvr-20000.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 1934
child process started successfully, parent exiting


[root@node1 conf]# netstat -ntplu | grep mongod
tcp        0      0 10.0.0.10:20000             0.0.0.0:*                   LISTEN      1934/mongod         
tcp        0      0 10.0.0.10:21000             0.0.0.0:*                   LISTEN      1960/mongod         
tcp        0      0 10.0.0.10:22000             0.0.0.0:*                   LISTEN      1990/mongod 

创建mongos服务

[root@node1 conf]# vim mongos-30000.conf 

systemLog:
 destination: file
###日志存储位置
 path: /mongodb/logs/mongos-30000.log
 logAppend: true
processManagement:
 fork: true  # fork and run in background
 pidFilePath: /mongodb/socket/mongos-30000.pid
##端口配置
net:
 port: 30000
 bindIp: 10.0.0.10

## 将confige server 添加到路由
sharding:
 configDB: 10.0.0.10:20000,10.0.0.10:21000,10.0.0.10:22000

启动路由服务

[root@node1 conf]# mongos -f /mongodb/conf/mongos-30000.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 2022
child process started successfully, parent exiting

[root@node1 conf]# netstat -ntplu | grep mongos
tcp        0      0 10.0.0.10:30000             0.0.0.0:*                   LISTEN      2022/mongos 

在开启一个Shard服务

配置:
[root@node1 conf]# ls
mongod-40000.conf  mongos-30000.conf  mongosvr-20000.conf  mongosvr-21000.conf  mongosvr-22000.conf
[root@node1 conf]# vim mongod-40000.conf 

systemLog:
 destination: file
###日志存储位置
 path: /mongodb/logs/mongod-40000.log
 logAppend: true
storage:
##journal配置
 journal:
  enabled: true
##数据文件存储位置
 dbPath: /mongodb/data/mongod-40000
##是否一个库一个文件夹
 directoryPerDB: true
##数据引擎
 engine: wiredTiger
##WT引擎配置
 wiredTiger:
  engineConfig:
##WT最大使用cache(根据服务器实际情况调节)
   cacheSizeGB: 10
##是否将索引也按数据库名单独存储
   directoryForIndexes: true
##表压缩配置
  collectionConfig:
   blockCompressor: zlib
##索引配置
  indexConfig:
   prefixCompression: true
processManagement:
 fork: true  # fork and run in background
 pidFilePath: /mongodb/socket/mongod-40000.pid
##端口配置
net:
 port: 40000
 bindIp: 10.0.0.10


# 启动Shard服务

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

node1 节点服务配置完毕。




node2 配置1个router、1个Shard
node3 配置1个Shard

配置如同node1一样,这里不在贴代码。

node1:
[root@node1 ~]# netstat -ntplu | grep mongo.
tcp        0      0 10.0.0.10:40000             0.0.0.0:*                   LISTEN      2184/mongod         
tcp        0      0 10.0.0.10:20000             0.0.0.0:*                   LISTEN      1934/mongod         
tcp        0      0 10.0.0.10:21000             0.0.0.0:*                   LISTEN      1960/mongod         
tcp        0      0 10.0.0.10:30000             0.0.0.0:*                   LISTEN      2022/mongos         
tcp        0      0 10.0.0.10:22000             0.0.0.0:*                   LISTEN      1990/mongod

node2:
[root@node2 ~]# netstat -ntplu | grep mongo.
tcp        0      0 10.0.0.11:40000             0.0.0.0:*                   LISTEN      1851/mongod         
tcp        0      0 10.0.0.11:30000             0.0.0.0:*                   LISTEN      1923/mongos

node3:
[root@node3 ~]# netstat -ntplu | grep mongo.
tcp        0      0 10.0.0.12:40000             0.0.0.0:*                   LISTEN      1927/mongod 

 

接下来需要在node1上进行分片的配置:

[root@node1 ~]# mongo 10.0.0.10:30000

mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("57b1addb0a3c54686427f812")
}
  shards:            # 目前还没有节点加入到分片中
  active mongoses:
    "3.2.8" : 2
  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('10.0.0.10:40000')
{ "shardAdded" : "shard0000", "ok" : 1 }
mongos> sh.addShard('10.0.0.11:40000')
{ "shardAdded" : "shard0001", "ok" : 1 }
mongos> sh.addShard('10.0.0.12:40000')
{ "shardAdded" : "shard0002", "ok" : 1 }



mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("57b1addb0a3c54686427f812")
}
  shards:        # 这里就可以看到刚才添加的三个Shard节点
    {  "_id" : "shard0000",  "host" : "10.0.0.10:40000" }
    {  "_id" : "shard0001",  "host" : "10.0.0.11:40000" }
    {  "_id" : "shard0002",  "host" : "10.0.0.12:40000" }
  active mongoses:
    "3.2.8" : 2
  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:

注意:分片的功能是需要手动开启才能实现的:sh.enableSharding("库名")、sh.shardCollection("库名.集合名",{"key":1})

mongos> sh.enableSharding('testdb')
{ "ok" : 1 }
mongos> sh.shardCollection('testdb.users',{uid:1})
{ "collectionsharded" : "testdb.users", "ok" : 1 }
mongos> show dbs
config  0.001GB
testdb  0.000GB
mongos> use testdb
switched to db testdb
mongos> for(i=1;i<=200000;i++) db.users.insert({uid:i,name:'hukey',age:23})  # 生成20W条数据,并且通过uid来进行分片
WriteResult({ "nInserted" : 1 })

# 分片的规则是自动分裂和平衡。

数据生成完毕,我们可以通过node2的router服务登录上去查看。

mongos> db.users.count()
200000
mongos> sh.status()
--- Sharding Status --- 
  sharding version: {
    "_id" : 1,
    "minCompatibleVersion" : 5,
    "currentVersion" : 6,
    "clusterId" : ObjectId("57b1addb0a3c54686427f812")
}
  shards:
    {  "_id" : "shard0000",  "host" : "10.0.0.10:40000" }
    {  "_id" : "shard0001",  "host" : "10.0.0.11:40000" }
    {  "_id" : "shard0002",  "host" : "10.0.0.12:40000" }
  active mongoses:
    "3.2.8" : 2
  balancer:
    Currently enabled:  yes
    Currently running:  no
    Failed balancer rounds in last 5 attempts:  0
    Migration Results for the last 24 hours: 
        2 : Success
  databases:
    {  "_id" : "testdb",  "primary" : "shard0000",  "partitioned" : true }
        testdb.users
            shard key: { "uid" : 1 }
            unique: false
            balancing: true
            chunks:                # 这里可以查看到平均分片到每个Shard上。
                shard0000    1
                shard0001    1
                shard0002    1
            { "uid" : { "$minKey" : 1 } } -->> { "uid" : 2 } on : shard0001 Timestamp(2, 0) 
            { "uid" : 2 } -->> { "uid" : 18 } on : shard0002 Timestamp(3, 0) 
            { "uid" : 18 } -->> { "uid" : { "$maxKey" : 1 } } on : shard0000 Timestamp(3, 1)

mongodb是用来存储海量数据的,所以20W分片可能不是特别明显,可以每次增加10W条来查看。

            chunks:
                shard0000    3
                shard0001    2
                shard0002    2
            { "uid" : { "$minKey" : 1 } } -->> { "uid" : 2 } on : shard0001 Timestamp(2, 0) 
            { "uid" : 2 } -->> { "uid" : 18 } on : shard0002 Timestamp(3, 0) 
            { "uid" : 18 } -->> { "uid" : 26232 } on : shard0002 Timestamp(5, 0) 
            { "uid" : 26232 } -->> { "uid" : 59000 } on : shard0000 Timestamp(5, 1) 
            { "uid" : 59000 } -->> { "uid" : 65554 } on : shard0000 Timestamp(4, 4) 
            { "uid" : 65554 } -->> { "uid" : 200000 } on : shard0000 Timestamp(3, 3) 
            { "uid" : 200000 } -->> { "uid" : { "$maxKey" : 1 } } on : shard0001 Timestamp(4, 0)

    这样,就很明显了。分片集群搭建完毕,但是目前所有节点都是单点,一旦故障就造成很严重的后果,因此需要将分片和副本集联合起来用,才能实现高可用。

posted @ 2016-08-15 21:21  hukey  阅读(3657)  评论(0编辑  收藏  举报