MongoDB 分片管理（不定时更新）
背景：
通过上一篇的 MongoDB 分片的原理、搭建、应用 大致了解了MongoDB分片的安装和一些基本的使用情况，现在来说明下如何管理和优化MongoDB分片的使用。
知识点：
1) 分片的配置和查看
① 添加分片：sh.addShard("IP:Port")
mongos> sh.addShard("192.168.200.A:40000") #添加分片
{ "shardAdded" : "shard0000", "ok" : }
mongos> sh.addShard("192.168.200.B:40000") #添加分片
{ "shardAdded" : "shard0001", "ok" : }
mongos> sh.addShard("192.168.200.C:40000") #添加分片
{ "shardAdded" : "shard0002", "ok" : }
② 开启分片功能：sh.enableSharding("库名")、sh.shardCollection("库名.集合名",{"key":1})
mongos> sh.enableSharding("dba")
{ "ok" : }
mongos> sh.shardCollection("dba.account",{"name":})
{ "collectionsharded" : "dba.account", "ok" : }
③ 查看分片状态：sh.status()
mongos> sh.status()
--- Sharding Status ---...
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" }
...
databases: #库
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : false, "primary" : "shard0000" }
{ "_id" : "dba", "partitioned" : true, "primary" : "shard0000" } #允许分片
dba.account #dba下的分片集合
shard key: { "name" : }
chunks: #块信息
shard0000
{ "name" : { "$minKey" : } } -->> { "name" : { "$maxKey" : } } on : shard0000 Timestamp(, ) #块里数据的范围
2) 配置信息说明，config库的介绍。
① 分片信息：config.shards
mongos> db.shards.find()
{ "_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" } #副本级分片，不需要把所有的节点写出
② 分片中所有数据库信息：config.databases
mongos> db.databases.find()
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : false, "primary" : "shard0001" }
{ "_id" : "dba", "partitioned" : true, "primary" : "shard0000" } #分片
{ "_id" : "abc", "partitioned" : true, "primary" : "shard0000" } #分片
③ 分片集合信息：config.collections
mongos> db.collections.findOne()
{
"_id" : "dba.account",
"lastmod" : ISODate("2015-07-14T15:12:29.706Z"),
"dropped" : false,
"key" : { #片键
"name" :
},
"unique" : false, #片键是否唯一
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77")
}
④ mongos路由的信息：config.mongs 。可以查看所有mongos的状态
mongos> db.mongos.findOne()
{
"_id" : "mongo2:30000",
"ping" : ISODate("2015-07-27T03:13:06.178Z"),
"up" : , #活着时间
"waiting" : true,
"mongoVersion" : "3.0.4" #版本
}
⑤ 均衡器锁的信息：config.locks，记录所有集群范围的锁，可得知哪个mongos是均衡器。
mongos> db.locks.findOne()
{
"_id" : "balancer", #均衡器
"state" : , #0非活动状态、1尝试得到锁，但还没得到，2表示正在进行均衡
"who" : "mongo1:30000:1436888525:1804289383:Balancer:846930886", #哪个mongos当均衡器
"ts" : ObjectId("55b5a2d5fdd9a605a039f951"),
"process" : "mongo1:30000:1436888525:1804289383",
"when" : ISODate("2015-07-27T03:17:41.159Z"),
"why" : "doing balance round" #均衡导致锁
}
⑥ 记录所有块的信息：config.chunks，也可以通过sh.status()查看
mongos> db.chunks.find().pretty()
{
"_id" : "dba.account-name_MinKey", #标识符
"lastmod" : Timestamp(, ), #块的版本
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77"), #块的版本
"ns" : "dba.account", #集合名
"min" : { #数据范围
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
},
"shard" : "mablevi" #所在分片
}
{
"_id" : "dba.account-name_\"9XXqCaBhfhPIXLq\"",
"lastmod" : Timestamp(, ),
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77"),
"ns" : "dba.account",
"min" : {
"name" : "9XXqCaBhfhPIXLq"
},
"max" : {
"name" : "RWINvgjYYQmbZds"
},
"shard" : "shard0002"
}
⑦ 记录所有的分片操作：config.changelog，拆分、迁移
拆分：
{
"_id" : "mongo1-2015-07-14T15:12:40-55a526e8f0432675a473009c",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:40.375Z"),
"what" : "multi-split", #拆分
"ns" : "dba.account",
"details" : { #拆分先后的信息
"before" : {
"min" : { #拆分前范围
"name" : { "$minKey" : }
},
"max" : {
"name" : { "$maxKey" : }
}
},
"number" : , #第一个块
"of" : , #拆分成3个块
"chunk" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
},
"lastmod" : Timestamp(, ), #版本号
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77")
}
}
}
{
"_id" : "mongo1-2015-07-14T15:12:40-55a526e8f0432675a473009d",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:40.378Z"),
"what" : "multi-split",
"ns" : "dba.account",
"details" : {
"before" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : { "$maxKey" : }
}
},
"number" : ,
"of" : ,
"chunk" : {
"min" : {
"name" : "9XXqCaBhfhPIXLq"
},
"max" : {
"name" : "okmjUUZuuKgftDC"
},
"lastmod" : Timestamp(, ), #版本号
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77")
}
}
}
{
"_id" : "mongo1-2015-07-14T15:12:40-55a526e8f0432675a473009e",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:40.381Z"),
"what" : "multi-split",
"ns" : "dba.account",
"details" : {
"before" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : { "$maxKey" : }
}
},
"number" : ,
"of" : ,
"chunk" : {
"min" : {
"name" : "okmjUUZuuKgftDC"
},
"max" : {
"name" : { "$maxKey" : }
},
"lastmod" : Timestamp(, ), #版本号
"lastmodEpoch" : ObjectId("55a526dd511d36716224fb77")
}
}
}
迁移：4个文档
{
"_id" : "mongo1-2015-07-14T15:12:41-55a526e9f0432675a47300a1",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:41.406Z"),
"what" : "moveChunk.start", #迁移开始
"ns" : "dba.account",
"details" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
},
"from" : "shard0000",
"to" : "mablevi"
}
}
{
"_id" : "mongo3-2015-07-14T15:12:42-55a526ead5bee637c12aadd4",
"server" : "mongo3",
"clientAddr" : ":27017",
"time" : ISODate("2015-07-14T15:12:42.419Z"),
"what" : "moveChunk.to", #from分片
"ns" : "dba.account",
"details" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
},
"step 1 of 5" : , #耗时，单位毫秒。检查命令参数
"step 2 of 5" : , #申请分布锁
"step 3 of 5" : , #连接到to分片
"step 4 of 5" : , #数据复制，每个分片都是直接和另一个分片、配置服务器直接连接
"step 5 of 5" : , #和to分片、配置服务器确认是否完成
"note" : "success"
}
}
{
"_id" : "mongo1-2015-07-14T15:12:42-55a526eaf0432675a47300a2",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:42.854Z"),
"what" : "moveChunk.commit", #提交
"ns" : "dba.account",
"details" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
},
"from" : "shard0000",
"to" : "mablevi",
"cloned" : NumberLong(),
"clonedBytes" : NumberLong(),
"catchup" : NumberLong(),
"steady" : NumberLong()
}
}
{
"_id" : "mongo1-2015-07-14T15:12:43-55a526ebf0432675a47300a3",
"server" : "mongo1",
"clientAddr" : "192.168.200.52:53257",
"time" : ISODate("2015-07-14T15:12:43.258Z"),
"what" : "moveChunk.from", #to分片
"ns" : "dba.account",
"details" : {
"min" : {
"name" : { "$minKey" : }
},
"max" : {
"name" : "9XXqCaBhfhPIXLq"
}, #步骤的时间为毫秒
"step 1 of 6" : , #迁移索引
"step 2 of 6" : , #删除块内的数据，清理数据残余
"step 3 of 6" : , #文档复制到to分片
"step 4 of 6" : , #复制期间，在to分片上执行操作
"step 5 of 6" : , #等待to分片将新迁移过来的数据复制到集群
"step 6 of 6" : , #修改元数据完成迁移
"to" : "mablevi",
"from" : "shard0000",
"note" : "success"
}
}
⑧ 分片标签：config.tags，sh.addShardTag
mongos> db.tags.findOne()
{
"_id" : {
"ns" : "abc.number",
"min" : {
"num" :
}
},
"ns" : "abc.number",
"min" : {
"num" :
},
"max" : {
"num" :
},
"tag" : "AAA"
}
⑨ 分片设置：config.settings，设置分片块的大小和开启关闭均衡器
mongos> db.settings.find()
{ "_id" : "chunksize", "value" : }
{ "_id" : "balancer", "stopped" : false }
⑩ 网络连接数： db.adminCommand({"connPoolStats":1})
mongos> db.adminCommand({"connPoolStats":})
{
"hosts" : {
"192.168.200.51:20000::0" : {
"available" : ,
"created" :
},
"192.168.200.51:20000::30" : {
"available" : ,
"created" :
},
"192.168.200.51:20000,192.168.200.51:21000,192.168.200.51:22000::0" : {
"available" : ,
"created" :
},
"192.168.200.51:20000,192.168.200.51:21000,192.168.200.51:22000::30" : {
"available" : ,
"created" :
},
"192.168.200.51:21000::0" : {
"available" : ,
"created" :
},
"192.168.200.51:21000::30" : {
"available" : ,
"created" :
},
"192.168.200.51:22000::0" : {
"available" : ,
"created" :
},
"192.168.200.51:22000::30" : {
"available" : ,
"created" :
},
"192.168.200.51:40000::0" : {
"available" : ,
"created" :
},
"192.168.200.52:40000::0" : {
"available" : ,
"created" :
},
"192.168.200.53:40000::0" : {
"available" : ,
"created" :
},
"192.168.200.53:50000::5" : {
"available" : ,
"created" :
},
"192.168.200.53:50001::0" : {
"available" : ,
"created" :
},
"192.168.200.53:50001::5" : {
"available" : ,
"created" :
},
"192.168.200.53:50002::0" : {
"available" : ,
"created" :
},
"192.168.200.53:50002::5" : {
"available" : ,
"created" :
},
"mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002::0" : {
"available" : ,
"created" :
}
},
"replicaSets" : {
"mablevi" : {
"hosts" : [
{
"addr" : "192.168.200.53:50000",
"ok" : true,
"ismaster" : true,
"hidden" : false,
"secondary" : false,
"pingTimeMillis" :
},
{
"addr" : "192.168.200.53:50001",
"ok" : true,
"ismaster" : false,
"hidden" : false,
"secondary" : true,
"pingTimeMillis" :
},
{
"addr" : "192.168.200.53:50002",
"ok" : true,
"ismaster" : false,
"hidden" : false,
"secondary" : true,
"pingTimeMillis" :
}
]
}
},
"createdByType" : {
"master" : ,
"set" : ,
"sync" :
},
"totalAvailable" : , #总的可用连接
"totalCreated" : , #总创建的连接
"numDBClientConnection" : ,
"numAScopedConnection" : ,
"ok" :
}
2）拆分块管理
mongos记录每个块中插入多少数据，一旦达到某个阈值，就会检查是否需要拆分块，需要则更新配置服务器上这个块的元信息。具体过程：
① 客户端发起请求，mongos检查当前块的阈值点。 ② 达到拆分的阈值点，mongos向分片发起一个拆分请求。 ③ 分片计算拆分点，将信息发回给mongos。 ④ mongos选择一个拆分点，将这些信息发给配置服务器。
阈值点和块大小相关，块大小可以直接设置，设置块大小：块大小不存在限制，因为当mongos不断重启，计数器可能永远无法达到阈值点。
mongos> db.settings.find({"_id":"chunksize"})
{ "_id" : "chunksize", "value" : }
mongos> db.settings.save({"_id":"chunksize","value":}) #块大小设置成64M
WriteResult({ "nMatched" : , "nUpserted" : , "nModified" : })
mongos> db.settings.find({"_id":"chunksize"})
{ "_id" : "chunksize", "value" : }
也可以对块进行手动拆分块：sh.splitAt('库.集合',{"name":"块值"})
mongos> db.chunks.findOne({"_id" : "abc.account-name_\"AIj2eqA3JsRxUxj\"",})
{
"_id" : "abc.account-name_\"AIj2eqA3JsRxUxj\"",
"lastmod" : Timestamp(, ),
"lastmodEpoch" : ObjectId("55a52ff1fdd9a605a0371327"),
"ns" : "abc.account",
"min" : {
"name" : "AIj2eqA3JsRxUxj"
},
"max" : {
"name" : "DM9BnUXfNIgPA15"
},
"shard" : "shard0000"
}
mongos> sh.splitAt('abc.account',{"name":"AIj7eqA3JsRxUxj"})
{ "ok" : }
mongos> db.chunks.findOne({"_id" : "abc.account-name_\"AIj2eqA3JsRxUxj\"",})
{
"_id" : "abc.account-name_\"AIj2eqA3JsRxUxj\"",
"lastmod" : Timestamp(, ),
"lastmodEpoch" : ObjectId("55a52ff1fdd9a605a0371327"),
"ns" : "abc.account",
"min" : {
"name" : "AIj2eqA3JsRxUxj"
},
"max" : {
"name" : "AIj7eqA3JsRxUxj" #被成功拆分
},
"shard" : "shard0000"
}
上面看到把块 abc.account-name_\"AIj2eqA3JsRxUxj\" 拆分成：
AIj2eqA3JsRxUxj到DM9BnUXfNIgPA15 拆分成 AIj2eqA3JsRxUxj到AIj7eqA3JsRxUxj到DM9BnUXfNIgPA15
具体的块信息和操作信息见config库里的chunks和changlogs集合。
3）均衡器：均衡器是使用块数量的多少，而不是数据的大小进行均衡
均衡器负责数据的迁移，会周期性的检查分片是否存在不均衡，如果存在则会进行块的迁移，不会影响到mongos正常的操作。均衡器进行均衡的条件是块数量的多少，而不是块大小，比如A片有几个较大的块，B片有很多较小的块，则均衡器会把B的分片迁移至A片。
① 关闭/开启自动均衡器：
mongos> sh.setBalancerState(false) #关闭均衡器
mongos> db.settings.find({"_id" : "balancer"})
{ "_id" : "balancer", "stopped" : true} mongos> sh.setBalancerState(true) #开启均衡器
mongos> db.settings.find({"_id" : "balancer"})
{ "_id" : "balancer", "stopped" : false} mongos> sh.stopBalancer() #关闭均衡器
Waiting for active hosts...
Waiting for active host mongo2: to recognize new settings... (ping : Mon Jul :: GMT+ (CST))
Waiting for the balancer lock...
Waiting again for active hosts after balancer is off...
mongos> db.settings.find({"_id" : "balancer"})
{ "_id" : "balancer", "stopped" : true}
mongos> sh.startBalancer() #开启均衡器
mongos> db.settings.find({"_id" : "balancer"})
{ "_id" : "balancer", "stopped" : false}
查看均衡器的锁：
mongos> use config
mongos> db.locks.find( { _id : "balancer" } ).pretty()
{
"_id" : "balancer",
"state" : , #0：非活动状态，1：正在获取，但还没有执行，2：正在均衡，迁移，有锁
"who" : "mongo3c:30000:1439446424:1804289383:Balancer:846930886",
"ts" : ObjectId("55ccb2e71778d3d54573d23d"),
"process" : "mongo3c:30000:1439446424:1804289383",
"when" : ISODate("2015-08-13T15:08:23.539Z"),
"why" : "doing balance round"
}
② 指定均衡器的工作时间：activeWindow
mongos> db.settings.update({"_id":"balancer"},{"$set":{"activeWindow":{"start":"07:00:00","stop":"03:00:00"}}},true)
WriteResult({ "nMatched" : , "nUpserted" : , "nModified" : })
mongos> db.settings.findOne({"_id":"balancer"})
{
"_id" : "balancer",
"stopped" : false,
"activeWindow" : { #凌晨7点到第二天凌晨3点开启均衡器功能。
"start" : "07:00:00",
"stop" : "03:00:00"
}
}
移除：
db.settings.update({ _id : "balancer" }, { $unset : { activeWindow : true } })
指定集合不进行/进行迁移：
sh.disableBalancing("students.grades") #关闭迁移
sh.enableBalancing("students.grades") #开启迁移
③ 手动迁移数据块：sh.moveChunk()，要是被迁移的数据块比较大则迁移比较慢，手动操作需要关闭均衡器
mongos> sh.moveChunk('abc.account',{"name":"W8evOO2dndQrmTy"},"mablevi") #把name为W8ev...（左下限值）的块迁移到mablevi分片里
{ "millis" : , "ok" : }
效果：
chunks:
mablevi
shard0000
shard0001
shard0002 after： chunks:
mablevi
shard0000
shard0001
shard0002
④ 手动拆分+迁移数据：要是被迁移的数据快大小超出了范围(默认块大小)，则不能被迁移：
chunk to big too move ...
方法一：设置块大小，大于被迁移的块。方法二：先手动拆分块，再迁移。
4）片键 ：(参考权威指南第二版第15章)
片键一般有三种形式：自增、随机、基于位置（Tag）。
各自的优缺点：
自增（升序）片键：
缺：所有的写请求都只在一个分片上，插入的文档总出现找最大的块里。分片的写入性能得不到提升，使得均衡处理数据变的困难。
优：在查询的时候能提高性能，数据有序写入，顺序。 随机片键：
缺：查询效率不高，数据分布分散。
优：写入比较均衡，写入请求性能比较高。 基于位置(Tag)：
通过sh.addShardTag把一个或则多个分片设置成一个tag，写入指定tag。
自增和随机分片好理解，就不做说明了，下面说明Tag片键的使用方法。
① 为分片指定tag：sh.addShardTag('shardName','tagName')
mongos> sh.addShardTag("mablevi","AAA")
mongos> sh.addShardTag("shard0000","BBB")
② 为tag指定规则：sh.addTagRange('库.集合',{minkey:num},{maxkey:num},tagName)
mongos> sh.addTagRange("abc.number",{"num":},{"num":},"AAA")
mongos> sh.addTagRange("abc.number",{"num":},{"num":},"BBB")
①和②的意思是把分片mablevi、shard000指定AAA、BBB标签。并且0到20的数据写到AAA标签里，21到50的数据写到BBB标签里。其他范围的数据也可以写进。
③ 数据写入到指定的标签里，比如想把一些指定的数据写入到指定的分片中，则：
写入数据：
mongos> db.number.find()
{ "_id" : ObjectId("55b608d7e7baf9146fe15ac3"), "num" : , "age" : } #写到mablevi分片
{ "_id" : ObjectId("55b608d0e7baf9146fe15ac2"), "num" : , "age" : } #写到shard000分片
单独进入到各个分片的mongod中看到，要写入的数据已被成功指定到分片。
mongos> sh.status()
--- Sharding Status ---
...
...
abc.number
shard key: { "num" : }
chunks:
mablevi
shard0000
{ "num" : { "$minKey" : } } -->> { "num" : } on : shard0000 Timestamp(, ) #数据范围
{ "num" : } -->> { "num" : } on : mablevi Timestamp(, ) #数据范围
{ "num" : } -->> { "num" : { "$maxKey" : } } on : shard0000 Timestamp(, ) #数据范围
tag: AAA { "num" : } -->> { "num" : }
tag: BBB { "num" : } -->> { "num" : }
比如分片mablevi是在SSD硬盘上的分片，其余都是普通的硬盘，现在把数据都写入到SSD标签的分片，提高写的性能，注意：这并不会影响集合的分发迁移，数据仍会被均衡器迁移到其他分片：
mongos> sh.addShardTag("mablevi","high") #把分片mablevi，添加到high标签里
mongos> sh.addTagRange('abc.ttt',{"age":MinKey},{"age":MaxKey},"high") #片键指定MinKey和MaxKey，把所有数据都写入改分片
写入数据并查看：
mongos> sh.status()
...
shards:
{ "_id" : "mablevi", "host" : "mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002", "tags" : [ "AAA", "high" ] } #分片的标签名
...
abc.ttt
shard key: { "age" : }
chunks:
mablevi
{ "age" : { "$minKey" : } } -->> { "age" : { "$maxKey" : } } on : mablevi Timestamp(, )
tag: high { "age" : { "$minKey" : } } -->> { "age" : { "$maxKey" : } }
进入到mablevi分片里查看，数据都写入在该分片，后续数据继续写入到达阈值后则均衡器会进行数据迁移。要想把历史数据进行迁移，保证其他分片数据均衡，则只需要在上面的基础上把MinKey改成当前值即可：
mongos> sh.shardCollection('abc.xxx',{"_id":}) #把自带的_id 设为片键
{ "collectionsharded" : "abc.xxx", "ok" : }
mongos> sh.addShardTag('shard0001','ssd') #设置标签
mongos> sh.addTagRange('abc.xxx',{"_id":ObjectId()},{"_id":MaxKey},"ssd") #ObjectId()表示当前值
查看：
mongos> sh.status()
...
abc.xxx
shard key: { "_id" : }
chunks:
shard0000
{ "_id" : { "$minKey" : } } -->> { "_id" : { "$maxKey" : } } on : shard0000 Timestamp(, )
tag: ssd { "_id" : ObjectId("55b6431f54858df435b6ba63") } -->> { "_id" : { "$maxKey" : } } #当前值到正无穷大
上面tag建立成功，数据也写到指定的分片中，现在需要把写入到ssd标签中的历史数据进行迁移，更新标签范围：
config库下：
mongos> db.tags.findOne({ns:"abc.xyz"}).min ＃查看最小值
{ "_id" : ObjectId("55b6463b54858df435b6ba68") }
mongos> db.tags.update({ns:"abc.xyz"},{"$set":{"min":ObjectId()}}) ＃把之前的最小值更新更当前值
WriteResult({ "nMatched" : , "nUpserted" : , "nModified" : })
mongos> db.tags.findOne({ns:"abc.xyz"}).min
ObjectId("55b647f654858df435b6ba6c")
更新完之后查看：
刷新：
mongos> db.adminCommand({"flushRouterConfig":})
{ "flushed" : true, "ok" : }
查看
mongos> sh.status()
--- Sharding Status --
abc.xyz
shard key: { "_id" : }
chunks:
shard0000
shard0002
{ "_id" : { "$minKey" : } } -->> { "_id" : ObjectId("55b6463b54858df435b6ba68") } on : shard0000 Timestamp(, )
{ "_id" : ObjectId("55b6463b54858df435b6ba68") } -->> { "_id" : { "$maxKey" : } } on : shard0002 Timestamp(, ) #历史数据被迁移到shard0002中
tag: ssd ObjectId("55b647f654858df435b6ba6c") -->> { "_id" : { "$maxKey" : } } #查看到块的范围已经被更新
如果该模式下出现问题，一个SSD分片写入满足不了要求，则需要删除tag，重新设置。
④ 删除标签：sh.removeShardTag()，标签被删除之后，数据不会丢失，后续的读写不会因为没有tag而不成功，但数据不会被迁移到其他的分片。
mongos> sh.removeShardTag('mablevi','high')
删除标签后，由于标签范围还在：
tag: ssd ObjectId("55b647f654858df435b6ba6c") -->> { "_id" : { "$maxKey" : } }
继续删除标签范围：sh.removeTagRange
3.0之前：进入到config库，删除tags集合上的和mablevi分片相关的信息。
3.0之后：sh.removeTagRange('abc.xyz',ObjectId("55b647f654858df435b6ba6c"),{ "_id" : { "$maxKey" : 1 },'ssd')
5）删除分片
db.runCommand({"removeshard":"mablevi"}) #删除mablevi分片
db.adminCommand({"movePrimary":"dba","to":"shard0001"}) #移动dba的主分片到shard0001.
6）查看分片成员：db.runCommand({ listshards : 1 })
mongos> db.runCommand({ listshards : })
{
"shards" : [
{
"_id" : "shard0000",
"host" : "192.168.200.51:40000",
"tags" : [
"BBB"
]
},
{
"_id" : "shard0001",
"host" : "192.168.200.52:40000",
"tags" : [ ]
},
{
"_id" : "shard0002",
"host" : "192.168.200.53:40000",
"tags" : [ ]
},
{
"_id" : "mablevi",
"host" : "mablevi/192.168.200.53:50000,192.168.200.53:50001,192.168.200.53:50002",
"tags" : [
"AAA"
],
"draining" : true #还在迁移
}
],
"ok" :
}
注意：要是在mablevi分片上设置了标签，需要把标签删除，包括标签范围（在config.tags里remove），分片才能被删除掉。数据不会丢失，会被迁移到其他分片：下面表示删除分片成功：
mongos> db.runCommand({"removeshard":"mablevi"})
{
"msg" : "removeshard completed successfully",
"state" : "completed",
"shard" : "mablevi",
"ok" :
}
7）查看各分片的状态：mongostat --discover
root@mongo1:~# mongostat --discover -udba -pdba --authenticationDatabase admin --port=
insert query update delete getmore command flushes mapped vsize res faults qr|qw ar|aw netIn netOut conn set repl time
localhost: * * * * | 160.0M 39.0M | | 79b 6k RTR :: 192.168.200.51: * * * * | 320.0M 941.0M 209.0M | | 79b 10k ::
192.168.200.52: * * * * | 448.0M .1G 192.0M | | 79b 10k ::
192.168.200.53: * * * * | 448.0M .1G 154.0M | | 79b 10k ::
localhost: * * * | 160.0M 39.0M | | 126b 6k RTR ::
8)
MongoDB 分片管理（不定时更新）的更多相关文章
- MongoDB 分片管理（三）服务器管理
MongoDB 分片管理(三)服务器管理
- MongoDB 数据库管理（不定时更新）
之前的几篇文章大致说了副本集的搭建.副本集的管理,现在说下MongoDB数据库的管理.数据库管理包括:备份.还原.导入.导出.服务器管理等. 一:查看服务器状态,查看命令行参数.db.serverSt ...
- MongoDB 分片管理
在MongoDB(版本 3.2.9)中,分片集群(sharded cluster)是一种水平扩展数据库系统性能的方法,能够将数据集分布式存储在不同的分片(shard)上,每个分片只保存数据集的一部分, ...
- MongoDB 分片管理（四）数据均衡
通常来说,MongoDB会自动处理数据均衡. 1.1 集群分片的块的均衡 注意,均衡器只使用块的数量,而非数据大小,来作为衡量分片间是否均衡的指标. 1.2 均衡器 1.执行所有数据库管理操作前,都应 ...
- MongoDB 分片管理（四）数据均衡 -- 特大快
1.1 特大快形成 如果用date字段作为片键,集合中date是一个日期字符串,如:year/month/day,也就是说,mongoDB一天创建一个块.因块内所有文档的片键一样,因此这些块是不可拆分 ...
- MongoDB 分片管理（一）检查集群状态
一.检查集群状态 1.1 使用sh.status()查看集群摘要信息 1.使用sh.status()可以查看分片信息.数据库信息.集合信息 sh.status() 如果数据块较多时,使用sh.stat ...
- MongoDB 分片管理（二）查看网络连接
1.1 查看连接统计 connPoolStats,查看mongos与mongod之间的连接信息,并可得知服务器 上打开的所有连接 1.2 限制连接数量
- Mongodb 笔记07 分片、配置分片、选择片键、分片管理
分片 1. 分片(sharding)是指将数据拆分,将其分散存放在不同的机器上的过程.有时也用分区(partitioning)来表示这个概念.将数据分散到不同的机器上,不需要功能强大的大型计算机就可以 ...
- MongoDB分片 在部署和维护管理 中常见事项的总结
分片(sharding)是MongoDB将大型集合分割到不同服务器(或者说集群)上所采用的方法,主要为应对高吞吐量与大数据量的应用场景提供了方法. 和既有的分库分表.分区方案相比,MongoDB的最大 ...
随机推荐
- linux文档常见后缀名
echo "Start bakup mdsoss Source code ..."_Name="templatecdr_src_"`date +%Y%m%d%H ...
- 【8-15】Markdown语法学习
学习Markdown语法 来源简书URL #,支持六级标题 列表 用-或*(指无序列表),有序列表直接1. 2. 3. 这样,中间有空格,可乱序(-+*都可,不能混合使用,混合使用为嵌套) 这是一个无 ...
- Linux服务器管理: 系统的进程管理后台进程的切换和相关命令
1.把进程放入到后台: [root@localhost/]#tar -zcf etc.tar.gz /etc & //这种方法是在后台运行的 [root@localhost ...
- php 选择排序法
private function demo(array $arr = array()){ $len = count($arr); if ($len == 1) return $arr; else fo ...
- 原生JavaScript技巧大收集(11~20)-(终于又被我找到这篇文章了)
11.原生JavaScript加入收藏夹 function AddFavorite(sURL, sTitle) { try { window.external.addFavorite(sURL, sT ...
- EF更新指定字段...
EF更新指定的字段... 搜来搜去发现没有自己想要的啊... 或许本来就有更好的办法来实现我这个,所以没有人来搞吧... 如果有,请不吝告知..GG.. //要更改UserInfo表中指定的列,比如这 ...
- 使用LIBSVM工具实现样本分类预测——MatLab
准备工作: https://www.csie.ntu.edu.tw/~cjlin/libsvm/,下载LIBSVM:(LIBSVM工具相较于MATLAB自带的工具:1).支持多分类及回归(‘-s 0’ ...
- Todd's Matlab讲义第4讲：控制误差和条件语句
误差和残量 数值求解方程\(f(x)=0\)的根,有多种方法测算结果的近似程度.最直接的方法是计算误差.第\(n\)步迭代结果与真值\(x^\*\)的差即为第\(n\)步迭代的误差: \begin{e ...
- 由pthread_create引起的段错误
一般线程的结束是由进程内的其他线程来结束的,调用pthread_cancel. 但是需要考虑到被结束线程的性质,一方面,线程是可被结束,也可无法结束,即不响应该信号:另一方面,如果线程是可被结束的,那 ...
- 新手学JavaScript都要学什么？
要从事网页开发,不知从何下手? 会JavaScript语言但是不知道该如何进阶! 最好的方法就是不断地做网页.写代码,不断地看别人的代码,研究别人的代码! 用代码实践JS的每个技巧点:多听多看多问多写 ...