文档章节

mongoDB 分片的管理

sushupro
 sushupro
发布于 2015/04/19 09:42
字数 4682
阅读 46
收藏 1
点赞 0
评论 0

具体操作为:

新增分片1,插入数据,

新增分片2,插入数据,

新增分片3,插入数据,

新增分片4,插入数据,

移除分片2,新增分片5 的处理。


用于模拟 一开始业务数据量不大,只使用一台服务器。

随着时间的流逝,数据量增大了, 不断地增加分片服务器。

以及某些旧的服务器需要淘汰了,更换新的服务器的处理。


以及如果一个 分片服务器 Down 了, 如果通过语句查询出来。


以及 同时运行多个 mongos 进程的时候, 及 C# 客户端连接代码的处理。

系统环境

五台 CentOS 虚拟机, 用于担当 “片”  机器名称分别为

 MyCentOS_01    (192.168.253.209)

 MyCentOS_02    (192.168.253.210)  

 MyCentOS_03    (192.168.253.211)

 MyCentOS_04    (192.168.253.212)

 MyCentOS_05    (192.168.253.213)

一台 Windows 主机 (192.168.253.78), 用于担当  “配置服务器”

步骤1.  启动配置服务器.

Windows 机器上,  下载  mongodb-win32-x86_64-2.4.6.zip

解压缩到 D: 盘

修改目录名为  mongodb

D: 盘下面, 创建一个 D:\data\db 目录

然后进入  D:\mongodb\bin 目录

运行

mongod.exe  --dbpath  D:\data\db 

启动配置服务器

 

步骤2. 启动 mongos 进程

Windows 机器上

进入 D:\mongodb\bin 目录

运行 

mongos  --port 30000  --configdb  192.168.253.78:27017

启动 mongos 进程

注意事项:  

1.运行 mongos , 必须要指定  --configdb 参数, 这个参数意思是 指定 配置服务器的地址 

2.  --configdb 参数, 后面需要写 具体的机器名称,或者 ip地址,不要使用 localhost

步骤3. 启动第一个片

在 MyCentOS_01  虚拟机上面, 运行

mkdir -p  /data/sdb

创建用于存储数据库文件的目录

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序



步骤4. 添加
第一个

在 Windows 机器上

进入 D:\mongodb\bin 目录

运行 

mongo.exe  192.168.253.78:30000/admin

运行 mongo 客户端, 连接到 mongos

注意事项:

这里的端口, 是 mongos 的端口, 不要写成 配置服务器的端口

在 mongo 客户端中, 输入命令

db.runCommand({addshard : "192.168.253.209:27017",  "name" : "Basic Shard Server" })

新增一个片

系统返回:

{ "shardAdded" : "Basic Shard Server", "ok" : 1 }

步骤5. 数据库与表 的配置

运行

db.runCommand({"enableSharding" : "test"})

对数据库 test 启用 分片

系统返回:

{ "ok" : 1 }

运行

db.runCommand({"shardCollection" : "test.TestBasic",  "key" : {"_id" : 1}  })

对数据库  test  下面的  TestBasic  表, 启用分片

按照 _id  列进行分片

系统返回:

{ "collectionsharded" : "test.TestBasic", "ok" : 1 }


步骤6. 管理分片

在mongo 客户端中, 输入命令

mongos> use config
switched to db config

查询所有的 片

mongos> db.shards.find()

{ "_id" : "Basic Shard Server", "host" : "192.168.253.209:27017" }

步骤7. 插入测试数据

步骤8. 查看数据分布

mongos> use test
switched to db test

mongos> db.TestBasic.count()
50692


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Basic Shard Server      3
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Basic Shard Server Timestamp(1, 1)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Basic Shard Server Timestamp
(1, 3)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : { "$maxKey" : 1 } } on : Basic Shard Server Timestamp(1, 4)

通过上面的结果, 可以看出, 数据被分成了3个片。

但是由于 服务器只有1个, 因此, 3个片都存储在那个  “Basic Shard Server” 服务器上面。



步骤9. 启动第二个片

在  MyCentOS_02  虚拟机上面, 运行

mkdir -p  /data/sdb

创建用于存储数据库文件的目录

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序



步骤10. 添加
第二个


mongos> use admin
switched to db admin

mongos> db.runCommand({addshard : "192.168.253.210:27017",  "name" : "Exp Shard Server 02" });
{ "shardAdded" : "Exp Shard Server 02", "ok" : 1 }

步骤11. 查询片的分布.

mongos>  use test
switched to db test


mongos> db.TestBasic.count()
100000


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 02",  "host" : "192.168.253.210:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 02     1
                                Basic Shard Server      2

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 02 Timestamp(2, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Basic Shard Server Timestamp
(2, 1)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : { "$maxKey" : 1 } } on : Basic Shard Server Timestamp(1, 4)

通过上面的结果, 可以看出, 数据被分成了3个片。

服务器有2个

其中1个片存储在那个  “Exp Shard Server 02” 服务器上面。

其中2个片存储在那个  “Basic Shard Server” 服务器上面。


步骤12. 启动第三个片

在  MyCentOS_03  虚拟机上面, 运行

mkdir -p  /data/sdb

创建用于存储数据库文件的目录

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序



步骤13. 添加



mongos> use admin
switched to db admin

mongos> db.runCommand({addshard : "192.168.253.211:27017",  "name" : "Exp Shard Server 03" });
{ "shardAdded" : "Exp Shard Server 03", "ok" : 1 }


步骤14. 查询片的分布.

mongos>  use test
switched to db test


mongos> db.TestBasic.count()
100000


mongos> db.printShardingStatus()

--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 02",  "host" : "192.168.253.210:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 02     1
                                Exp Shard Server 03     1
                                Basic Shard Server      1

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 02 Timestamp(2, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 03 Timestam
p(3, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : { "$maxKey" : 1 } } on : Basic Shard Server Timestamp(3, 1)

通过上面的结果, 可以看出, 数据被分成了3个片。

服务器有3个

其中1个片存储在那个  “Exp Shard Server 02” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 03” 服务器上面。

其中1个片存储在那个  “Basic Shard Server” 服务器上面。



步骤15.  继续插入测试数据




步骤16. 查询片的分布.


mongos> db.TestBasic.count()
239170


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 02",  "host" : "192.168.253.210:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 02     2
                                Exp Shard Server 03     1
                                Basic Shard Server      1

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 02 Timestamp(2, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 03 Timestam
p(3, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : ObjectId("525660b070da9a23008cc895") } on : Basic Shard Server Timestamp
(4, 1)
                        { "_id" : ObjectId("525660b070da9a23008cc895") } -->> {
"_id" : { "$maxKey" : 1 } } on : Exp Shard Server 02 Timestamp(4, 0)

通过上面的结果, 可以看出, 随着数据量的增加,数据被分成了4个片。

服务器有3个

其中2个片存储在那个  “Exp Shard Server 02” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 03” 服务器上面。

其中1个片存储在那个  “Basic Shard Server” 服务器上面。



步骤17. 启动第四个片

在  MyCentOS_04  虚拟机上面, 运行

mkdir -p  /data/sdb

创建用于存储数据库文件的目录

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序



步骤18. 添加
第四



mongos> use admin
switched to db admin


mongos> db.runCommand({addshard : "192.168.253.212:27017",  "name" : "Exp Shard Server 04" });

{ "shardAdded" : "Exp Shard Server 04", "ok" : 1 }

步骤19. 查询片的分布.


mongos> use test
switched to db test


mongos> db.TestBasic.count()
300000


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 02",  "host" : "192.168.253.210:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
        {  "_id" : "Exp Shard Server 04",  "host" : "192.168.253.212:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 04     1
                                Exp Shard Server 03     1
                                Basic Shard Server      1
                                Exp Shard Server 02     1

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 04 Timestamp(5, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 03 Timestam
p(3, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : ObjectId("525660b070da9a23008cc895") } on : Basic Shard Server Timestamp
(4, 1)
                        { "_id" : ObjectId("525660b070da9a23008cc895") } -->> {
"_id" : { "$maxKey" : 1 } } on : Exp Shard Server 02 Timestamp(5, 1)



通过上面的结果, 可以看出, 随着数据量的增加,数据被分成了4个片。

服务器有4个

其中1个片存储在那个  “Exp Shard Server 04” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 02” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 03” 服务器上面。

其中1个片存储在那个  “Basic Shard Server” 服务器上面。




步骤20. 启动第五个片

在  MyCentOS_05  虚拟机上面, 运行

mkdir -p  /data/sdb

创建用于存储数据库文件的目录

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序

步骤21.  移除 第二个片;  加入第五个片  ( 本操作模拟 新增一个服务器,更换掉旧有的服务器 )


mongos> use admin
switched to db admin

mongos> db.runCommand({removeShard : "Exp Shard Server 02" });
{
        "msg" : "draining started successfully",
        "state" : "started",
        "shard" : "Exp Shard Server 02",
        "ok" : 1
}


mongos> db.runCommand({addshard : "192.168.253.213:27017",  "name" : "Exp Shard Server 05" });
{ "shardAdded" : "Exp Shard Server 05", "ok" : 1 }



注意: 移除分片,是一个比较耗时的处理。

上面的返回结果中, state 是  started 

也就是 移除分片的处理开始了.

一段时间以后, 再次执行语句:

mongos> db.runCommand({removeShard : "Exp Shard Server 02" });
{
        "msg" : "removeshard completed successfully",
        "state" : "completed",
        "shard" : "Exp Shard Server 02",
        "ok" : 1
}

状态显示, 分片已经被移除了.


步骤22. 查询片的分布.


mongos> use test
switched to db test


mongos> db.TestBasic.count()
300000


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
        {  "_id" : "Exp Shard Server 04",  "host" : "192.168.253.212:27017" }
        {  "_id" : "Exp Shard Server 05",  "host" : "192.168.253.213:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 04     1
                                Exp Shard Server 03     1
                                Exp Shard Server 05     1
                                Basic Shard Server      1

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 04 Timestamp(5, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 03 Timestam
p(3, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : ObjectId("525660b070da9a23008cc895") } on : Exp Shard Server 05 Timestam
p(7, 0)
                        { "_id" : ObjectId("525660b070da9a23008cc895") } -->> {
"_id" : { "$maxKey" : 1 } } on : Basic Shard Server Timestamp(7, 1)

通过上面的结果, 可以看出,数据被分成了4个片。

服务器有4个

其中1个片存储在那个  “Exp Shard Server 04” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 05” 服务器上面。

其中1个片存储在那个  “Exp Shard Server 03” 服务器上面。

其中1个片存储在那个  “Basic Shard Server” 服务器上面。

其中的  Exp Shard Server 02  已经被移除掉了, 因此在上面的列表中, 没有该片的信息。

通过与 步骤 19 的结果对比。

数据库可能是这样处理 移除与新增的处理的:

当移除 “Exp Shard Server 02”  的时候, 原本由 Exp Shard Server 02 存储的数据, 需要迁移到 “Basic Shard Server”  上面去。

当新增 “Exp Shard Server 05” 的时候,数据又从 “Basic Shard Server”  迁移一部分到  “Exp Shard Server 05”  上面去。


步骤23.  模拟某个分片发生故障


在  MyCentOS_03  虚拟机上面, 运行

shutdown -h now

关闭计算机


步骤24. 查询片的分布.

mongos> use test
switched to db test

mongos> db.TestBasic.count()
Thu Oct 10 17:06:24.159 count failed: { "code" : 15988, "ok" : 0, "errmsg" : "ex
ception: error querying server" } at src/mongo/shell/query.js:180



mongos> use config
switched to db config

mongos> db.mongos.find()
error: {
        "$err" : "socket exception [CONNECT_ERROR] for 192.168.253.211:27017",
        "code" : 11002,
        "shard" : "config"
}



mongos> db.shards.find()
error: {
        "$err" : "socket exception [CONNECT_ERROR] for 192.168.253.211:27017",
        "code" : 11002,
        "shard" : "config"
}

步骤25. 启动第三个片  (模拟某个分片发生故障后恢复

在  MyCentOS_03  虚拟机上面

运行

./mongod --dbpath  /data/sdb

启动 mongo 服务器端程序

步骤26. 查询片的分布.

mongos> use test
switched to db test


mongos> db.TestBasic.count()
300000

mongos> use config
switched to db config


mongos> db.mongos.find()
{ "_id" : "EdwardPC:30000", "mongoVersion" : "2.4.6", "ping" : ISODate("2013-10-
10T09:16:20.179Z"), "up" : 7798, "waiting" : true }


mongos> db.shards.find()
{ "_id" : "Basic Shard Server", "host" : "192.168.253.209:27017" }
{ "_id" : "Exp Shard Server 03", "host" : "192.168.253.211:27017" }
{ "_id" : "Exp Shard Server 04", "host" : "192.168.253.212:27017" }
{ "_id" : "Exp Shard Server 05", "host" : "192.168.253.213:27017" }

mongos> db.databases.find();
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "Basic Shard Server" }

mongos> db.collections.find();
{ "_id" : "test.TestBasic", "lastmod" : ISODate("1970-01-16T23:43:09.637Z"), "dr
opped" : false, "key" : { "_id" : 1 }, "unique" : false, "lastmodEpoch" : Object
Id("525655455b9ed4426aecea13") }

mongos> db.chunks.find();
{ "_id" : "test.TestBasic-_id_MinKey", "lastmod" : Timestamp(5, 0), "lastmodEpoc
h" : ObjectId("525655455b9ed4426aecea13"), "ns" : "test.TestBasic", "min" : { "_
id" : { "$minKey" : 1 } }, "max" : { "_id" : ObjectId("5256589670da9a26988abf39"
) }, "shard" : "Exp Shard Server 04" }
{ "_id" : "test.TestBasic-_id_ObjectId('5256589670da9a26988abf39')", "lastmod" :
Timestamp(3, 0), "lastmodEpoch" : ObjectId("525655455b9ed4426aecea13"), "ns" :
"test.TestBasic", "min" : { "_id" : ObjectId("5256589670da9a26988abf39") }, "max
" : { "_id" : ObjectId("525658c070da9a26988ade12") }, "shard" : "Exp Shard Serve
r 03"
 }
{ "_id" : "test.TestBasic-_id_ObjectId('525658c070da9a26988ade12')", "lastmod" :
Timestamp(7, 0), "lastmodEpoch" : ObjectId("525655455b9ed4426aecea13"), "ns" :
"test.TestBasic", "min" : { "_id" : ObjectId("525658c070da9a26988ade12") }, "max
" : { "_id" : ObjectId("525660b070da9a23008cc895") }, "shard" : "Exp Shard Serve
r 05"
 }
{ "_id" : "test.TestBasic-_id_ObjectId('525660b070da9a23008cc895')", "lastmod" :
Timestamp(7, 1), "lastmodEpoch" : ObjectId("525655455b9ed4426aecea13"), "ns" :
"test.TestBasic", "min" : { "_id" : ObjectId("525660b070da9a23008cc895") }, "max
" : { "_id" : { "$maxKey" : 1 } }, "shard" : "Basic Shard Server" }

步骤27.  启动第二个 mongos 进程  (用于避免第一个 mongos 进程 Down 掉 )

Windows 机器上

进入 D:\mongodb\bin 目录

运行 

mongos  --port 30001  --configdb  192.168.253.78:27017

启动 mongos 进程

步骤28.  C# 客户端代码


            // 下面这种情况, 是用于多个 mongos 进程的情况.

            MongoClientSettings setting = new MongoClientSettings();

            setting.ConnectionMode = ConnectionMode.ShardRouter;


            setting.Servers = new List <MongoServerAddress>() {

                new MongoServerAddress ("192.168.253.78", 30000),

                new MongoServerAddress ("192.168.253.78", 30001) };


            MongoClient client = new MongoClient(setting);

运行并插入数据。

核对数据量

步骤29.  停掉第一个 mongos 进程

在步骤2 的 “mongos” 窗口上, 按 Ctrl+C 停止该进程。

步骤30. 再次运行 C# 客户端代码

运行并插入数据。

核对数据量


步骤31.  备份的处理



D:\mongodb\bin>mongodump.exe -h 192.168.253.78:30001 -d test -o d:\test
connected to: 192.168.253.78:30001
Thu Oct 10 18:42:21.424 DATABASE: test   to     d:\test\test
Thu Oct 10 18:42:21.446         test.system.indexes to d:\test\test\system.index
es.bson
Thu Oct 10 18:42:21.451                  1 objects
Thu Oct 10 18:42:21.453         test.TestBasic to d:\test\test\TestBasic.bson
Thu Oct 10 18:42:24.193                 Collection File Writing Progress: 109900
/500000 21%     (objects)
Thu Oct 10 18:42:27.515                 Collection File Writing Progress: 403900
/500000 80%     (objects)
Thu Oct 10 18:42:27.658                  500000 objects
Thu Oct 10 18:42:27.659         Metadata for test.TestBasic to d:\test\test\Test
Basic.metadata.json

上面的操作, 是 通过 连接  mongos,   一次性备份全部分片的数据.

步骤32.  模拟  分片正常  配置服务器物理损坏.


把前面 步骤1 的  mongod.exe  停掉 

步骤2 与 步骤 27 的 mongos 全部停掉

D: 盘下面, 创建一个 D:\data\db2 目录

然后进入  D:\mongodb\bin 目录

运行

mongod.exe  --dbpath  D:\data\db2 

启动配置服务器

 

步骤33. 启动 mongos 进程

Windows 机器上

进入 D:\mongodb\bin 目录

运行 

mongos  --port 30000  --configdb  192.168.253.78:27017

启动 mongos 进程

步骤34. 重新加入分片

D:\mongodb\bin>mongo.exe  192.168.253.78:30000/admin
MongoDB shell version: 2.4.6
connecting to: 192.168.253.78:30000/admin
mongos> db.runCommand({addshard : "192.168.253.209:27017",  "name" : "Basic Shard Server" })
{ "shardAdded" : "Basic Shard Server", "ok" : 1 }


mongos> db.runCommand({addshard : "192.168.253.210:27017",  "name" : "Exp Shard Server 02" });
{
        "ok" : 0,
        "errmsg" : "can't add shard 192.168.253.210:27017 because a local databa
se 'test' exists in another Basic Shard Server:192.168.253.209:27017"
}


mongos> db.runCommand({addshard : "192.168.253.211:27017",  "name" : "Exp Shard Server 03" });
{
        "ok" : 0,
        "errmsg" : "can't add shard 192.168.253.211:27017 because a local databa
se 'test' exists in another Basic Shard Server:192.168.253.209:27017"
}

上面的执行结果显示,  如果 配置服务器 物理损坏了, 重新搭建一个新的 配置服务器, 没法简单的加入已有的 分片服务器了。

终止上面的 步骤23 的 配置服务器 与 步骤24 的 mongos 进程.

重新启动 步骤1的 配置服务器 与 步骤2的  mongos 进程.

D:\mongodb\bin>mongo.exe  192.168.253.78:30000/admin
MongoDB shell version: 2.4.6
connecting to: 192.168.253.78:30000/admin


mongos> use test
switched to db test


mongos>  db.TestBasic.count()
500000


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
        {  "_id" : "Exp Shard Server 04",  "host" : "192.168.253.212:27017" }
        {  "_id" : "Exp Shard Server 05",  "host" : "192.168.253.213:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 04     1
                                Exp Shard Server 03     2
                                Exp Shard Server 05     1
                                Basic Shard Server      1
                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 04 Timestamp(5, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 03 Timestam
p(3, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : ObjectId("525660b070da9a23008cc895") } on : Exp Shard Server 05 Timestam
p(7, 0)
                        { "_id" : ObjectId("525660b070da9a23008cc895") } -->> {
"_id" : ObjectId("52567a9e70da9a2bbc76c2a9") } on : Basic Shard Server Timestamp
(8, 1)
                        { "_id" : ObjectId("52567a9e70da9a2bbc76c2a9") } -->> {
"_id" : { "$maxKey" : 1 } } on : Exp Shard Server 03 Timestamp(8, 0)

显示各分片数据都正常。

再把 前面移除掉的  第2个片, 加进来

mongos> use admin
switched to db admin


mongos>  db.runCommand({addshard : "192.168.253.210:27017",  "name" : "Exp Shard Server 02" });
{
        "ok" : 0,
        "errmsg" : "can't add shard 192.168.253.210:27017 because a local database 'test' exists in another Basic Shard Server:192.168.253.209:27017"
}

结果还是报错。

命令行 单独连接到这个 服务器上面去, 删除 分片2上面的 test 数据库。

D:\mongodb\bin>mongo 192.168.253.210:27017

use test
switched to db test

show dbs
local   0.03125GB
test    0.0625GB

db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }


show dbs
local   0.03125GB
>

回到 mongos 客户端

mongos> db.runCommand({addshard : "192.168.253.210:27017",  "name" : "Exp Shard Server 02" });
{ "shardAdded" : "Exp Shard Server 02", "ok" : 1 }
mongos>

mongos> use test
switched to db test


mongos> db.TestBasic.count()
500000


mongos> db.printShardingStatus()
--- Sharding Status ---
  sharding version: {
        "_id" : 1,
        "version" : 3,
        "minCompatibleVersion" : 3,
        "currentVersion" : 4,
        "clusterId" : ObjectId("525651ee5b9ed4426aece981")
}
  shards:
        {  "_id" : "Basic Shard Server",  "host" : "192.168.253.209:27017" }
        {  "_id" : "Exp Shard Server 02",  "host" : "192.168.253.210:27017" }
        {  "_id" : "Exp Shard Server 03",  "host" : "192.168.253.211:27017" }
        {  "_id" : "Exp Shard Server 04",  "host" : "192.168.253.212:27017" }
        {  "_id" : "Exp Shard Server 05",  "host" : "192.168.253.213:27017" }
  databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }
        {  "_id" : "test",  "partitioned" : true,  "primary" : "Basic Shard Serv
er" }
                test.TestBasic
                        shard key: { "_id" : 1 }
                        chunks:
                                Exp Shard Server 04     1
                                Exp Shard Server 02     1
                                Exp Shard Server 05     1
                                Basic Shard Server      1
                                Exp Shard Server 03     1

                        { "_id" : { "$minKey" : 1 } } -->> { "_id" : ObjectId("5
256589670da9a26988abf39") } on : Exp Shard Server 04 Timestamp(5, 0)
                        { "_id" : ObjectId("5256589670da9a26988abf39") } -->> {
"_id" : ObjectId("525658c070da9a26988ade12") } on : Exp Shard Server 02 Timestam
p(9, 0)
                        { "_id" : ObjectId("525658c070da9a26988ade12") } -->> {
"_id" : ObjectId("525660b070da9a23008cc895") } on : Exp Shard Server 05 Timestam
p(7, 0)
                        { "_id" : ObjectId("525660b070da9a23008cc895") } -->> {
"_id" : ObjectId("52567a9e70da9a2bbc76c2a9") } on : Basic Shard Server Timestamp
(8, 1)
                        { "_id" : ObjectId("52567a9e70da9a2bbc76c2a9") } -->> {
"_id" : { "$maxKey" : 1 } } on : Exp Shard Server 03 Timestamp(9, 1)

步骤35.   独立备份每一个分片的处理



mongodump.exe -h 192.168.253.209 -d test -o   d:\test\01

mongodump.exe -h 192.168.253.210 -d test -o   d:\test\02

mongodump.exe -h 192.168.253.211 -d test -o   d:\test\03

mongodump.exe -h 192.168.253.212 -d test -o   d:\test\04

mongodump.exe -h 192.168.253.213 -d test -o   d:\test\05

运行结果:

D:\mongodb\bin>mongodump.exe -h 192.168.253.209 -d test -o   d:\test\01
connected to: 192.168.253.209
Fri Oct 11 11:19:54.350 DATABASE: test   to     d:\test\01\test
Fri Oct 11 11:19:54.356         test.system.indexes to d:\test\01\test\system.in
dexes.bson
Fri Oct 11 11:19:54.361                  1 objects
Fri Oct 11 11:19:54.361         test.TestBasic to d:\test\01\test\TestBasic.bson

Fri Oct 11 11:19:56.530                  207418 objects
Fri Oct 11 11:19:56.532         Metadata for test.TestBasic to d:\test\01\test\T
estBasic.metadata.json

D:\mongodb\bin>mongodump.exe -h 192.168.253.210 -d test -o   d:\test\02
connected to: 192.168.253.210
Fri Oct 11 11:19:56.676 DATABASE: test   to     d:\test\02\test
Fri Oct 11 11:19:56.680         test.system.indexes to d:\test\02\test\system.in
dexes.bson
Fri Oct 11 11:19:56.683                  1 objects
Fri Oct 11 11:19:56.684         test.TestBasic to d:\test\02\test\TestBasic.bson

Fri Oct 11 11:19:56.727                  7897 objects
Fri Oct 11 11:19:56.728         Metadata for test.TestBasic to d:\test\02\test\T
estBasic.metadata.json

D:\mongodb\bin>mongodump.exe -h 192.168.253.211 -d test -o   d:\test\03
connected to: 192.168.253.211
Fri Oct 11 11:19:56.866 DATABASE: test   to     d:\test\03\test
Fri Oct 11 11:19:56.869         test.system.indexes to d:\test\03\test\system.in
dexes.bson
Fri Oct 11 11:19:56.874                  1 objects
Fri Oct 11 11:19:56.875         test.TestBasic to d:\test\03\test\TestBasic.bson

Fri Oct 11 11:19:57.651                  73824 objects
Fri Oct 11 11:19:57.652         Metadata for test.TestBasic to d:\test\03\test\T
estBasic.metadata.json

D:\mongodb\bin>mongodump.exe -h 192.168.253.212 -d test -o   d:\test\04
connected to: 192.168.253.212
Fri Oct 11 11:19:57.799 DATABASE: test   to     d:\test\04\test
Fri Oct 11 11:19:57.804         test.system.indexes to d:\test\04\test\system.in
dexes.bson
Fri Oct 11 11:19:57.808                  1 objects
Fri Oct 11 11:19:57.809         test.TestBasic to d:\test\04\test\TestBasic.bson

Fri Oct 11 11:19:57.813                  0 objects
Fri Oct 11 11:19:57.814         Metadata for test.TestBasic to d:\test\04\test\T
estBasic.metadata.json

D:\mongodb\bin>mongodump.exe -h 192.168.253.213 -d test -o   d:\test\05
connected to: 192.168.253.213
Fri Oct 11 11:19:57.952 DATABASE: test   to     d:\test\05\test
Fri Oct 11 11:19:57.957         test.system.indexes to d:\test\05\test\system.in
dexes.bson
Fri Oct 11 11:19:57.960                  1 objects
Fri Oct 11 11:19:57.961         test.TestBasic to d:\test\05\test\TestBasic.bson

Fri Oct 11 11:20:00.067                 Collection File Writing Progress: 172700
/210861 81%     (objects)
Fri Oct 11 11:20:00.079                  210861 objects
Fri Oct 11 11:20:00.080         Metadata for test.TestBasic to d:\test\05\test\T
estBasic.metadata.json

上面的 备份结果显示, 虽然分了5 个区, 但是每个区的数据分布, 是不均匀的。


本文转载自:http://wapapp.baidu.com/wangzhiqing999/item/06ba5babd2a9e5d15af19105?qq-pf-to=pcqq.c2c

共有 人打赏支持
sushupro
粉丝 0
博文 11
码字总数 5454
作品 0
石家庄
程序员
centos7部署Mongodb复制集结合分片(超详细)

Mongodb复制集结合分片 重点:概述、原理、实施案例 一、概述: 概述: 分片(sharding)是指将数据库拆分,将其分散在不同的机器上的过程。分片集群(sharded cluster)是一种水平扩展数据库...

壹休哥 ⋅ 06/14 ⋅ 0

MongoDB 4.0 RC 版本强势登陆

MongoDB 因其灵活的文档模型、可扩展分布式设计广受开发者喜爱,在此基础上,MongoDB 4.0 推出了更强大的功能支持,目前4.0第一个RC版本已经发布,本文将介绍 MongoDB 4.0 核心的一些新特性。...

张友东 ⋅ 05/30 ⋅ 0

MongoDB 4.0 首个 RC 版发布,支持多文档事务

MongoDB 因其灵活的文档模型、可扩展分布式设计广受开发者喜爱,在此基础上,MongoDB 4.0 推出了更强大的功能支持,目前 4.0 第一个 RC 版本已经发布。 开始体验 MongoDB 4.0 RC:下载地址 ...

局长 ⋅ 06/05 ⋅ 0

MongoDB 用户名密码登录

Mongodb enable authentication MongoDB 默认直接连接,无须身份验证,如果当前机器可以公网访问,且不注意Mongodb 端口(默认 27017)的开放状态,那么Mongodb就会产生安全风险,被利用此配...

kimoCHG ⋅ 2017/01/07 ⋅ 0

mongoDB 学习笔记纯干货(mongoose、增删改查、聚合、索引、等等)

最后更新时间:2017-07-13 11:10:49 原始文章链接:http://www.lovebxm.com/2017/07/13/mongodb_primer/ MongoDB - 简介 官网:https://www.mongodb.com/ MongoDB 是一个基于分布式文件存储的...

Airship ⋅ 06/01 ⋅ 0

如何使用MongoDB+Springboot实现分布式ID

如何实现分布式id,一般会给出这几种方案 使用数据库自增Id 使用reids的incr命令 使用UUID Twitter的snowflake算法 利用zookeeper生成唯一ID MongoDB的ObjectId mongodb如何实现分布式ID Mo...

小贱是个程序员 ⋅ 06/05 ⋅ 0

Mac和Ubuntu18.04下MongoDB的安装

Mac安装mongodb 使用安装 从默认的配置文件启动mongodb 安装完成后,MongoDB服务启动、停止、重启命令如下: Mac下的mongodb可视化管理工具,推荐使用开源免费的, 下载地址:https://robomon...

翌日千里 ⋅ 05/26 ⋅ 0

安装配置MongoDB3.6.3数据库以及启动脚本

linxu上安装mongodb3.6实战 根据linux 版本到官网下载对应mongodb版本 下载 https://fastdl.mongodb.org/linux/mongodb-linux-x8664-3.6.3.tgz 查看服务器版本:cat /proc/version 查看linux...

秦时明月路 ⋅ 06/21 ⋅ 0

mongodb的命令行操作命令详解(增删改查、高级查询)

mongodb的命令行操作命令详解(增删改查、高级查询) 本文为上文的续篇,主要讲解mongodb在cmd的直接操作命令,我的mongodb是安装在d:mongodb下 1,mongodb启动服务 : 2,mongodb停止服务 : ...

xiaocao13140 ⋅ 06/04 ⋅ 0

MongoDB 3.0新特性概述

MongoDB 在 2015年3月3日 跳过了 MongoDB 2.8版本,直接在 MongoDB 2.6版本后,发布了MongoDB 3.0版本。 随后在 2015年3月17日 发布了 MongoDB 3.0.1 版本; 在 2015年4月9日发布了 MongoDB ...

xinsir999 ⋅ 05/02 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

oAuth2 升级Spring Cloud Finchley.RELEASE踩坑分享

背景 6.19号,spring团队发布了期待已久的 Spring Cloud Finchley.RELEASE 版本。 重要变化: 基于Spring Boot 2.0.X 不兼容 Spring Boot 1.5.X 期间踩过几个坑,分享出来给大伙,主要是关于...

冷冷gg ⋅ 37分钟前 ⋅ 0

OSChina 周一乱弹 —— 理发师小姐姐的魔法

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @冰冰棒- :分享田馥甄的单曲《My Love》 《My Love》- 田馥甄 手机党少年们想听歌,请使劲儿戳(这里) @Li-Wang :哎,头发又长了。。。又要...

小小编辑 ⋅ 今天 ⋅ 4

Kafka1.0.X_消费者API详解2

偏移量由消费者管理 kafka Consumer Api还提供了自己存储offset的功能,将offset和data做到原子性,可以让消费具有Exactly Once 的语义,比kafka默认的At-least Once更强大 消费者从指定分区...

特拉仔 ⋅ 今天 ⋅ 0

个人博客的运营模式能否学习TMALL天猫质量为上?

心情随笔|个人博客的运营模式能否学习TMALL天猫质量为上? 中国的互联网已经发展了很多年了,记得在十年前,个人博客十分流行,大量的人都在写博客,而且质量还不错,很多高质量的文章都是在...

原创小博客 ⋅ 今天 ⋅ 0

JavaScript零基础入门——(十一)JavaScript的DOM操作

JavaScript零基础入门——(十一)JavaScript的DOM操作 大家好,欢迎回到我们的JavaScript零基础入门。最近有些同学问我说,我讲的的比书上的精简不少。其实呢,我主要讲的是我在开发中经常会...

JandenMa ⋅ 今天 ⋅ 0

volatile和synchronized的区别

volatile和synchronized的区别 在讲这个之前需要先了解下JMM(Java memory Model :java内存模型):并发过程中如何处理可见性、原子性、有序性的问题--建立JMM模型 详情请看:https://baike.b...

MarinJ_Shao ⋅ 今天 ⋅ 0

深入分析Kubernetes Critical Pod(一)

Author: xidianwangtao@gmail.com 摘要:大家在部署Kubernetes集群AddOn组件的时候,经常会看到Annotation scheduler.alpha.kubernetes.io/critical-pod"="",以表示这是一个关键服务,那你知...

WaltonWang ⋅ 今天 ⋅ 0

原子性 - synchronized关键词

原子性概念 原子性提供了程序的互斥操作,同一时刻只能有一个线程能对某块代码进行操作。 原子性的实现方式 在jdk中,原子性的实现方式主要分为: synchronized:关键词,它依赖于JVM,保证了同...

dotleo ⋅ 今天 ⋅ 0

【2018.06.22学习笔记】【linux高级知识 14.4-15.3】

14.4 exportfs命令 14.5 NFS客户端问题 15.1 FTP介绍 15.2/15.3 使用vsftpd搭建ftp

lgsxp ⋅ 今天 ⋅ 0

JeeSite 4.0 功能权限管理基础(Shiro)

Shiro是Apache的一个开源框架,是一个权限管理的框架,实现用户认证、用户授权等。 只要有用户参与一般都要有权限管理,权限管理实现对用户访问系统的控制,按照安全规则或者安全策略控制用户...

ThinkGem ⋅ 昨天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部