MongoDB分片存储的集群架构实现
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了MongoDB分片存储的集群架构实现，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含20944字，纯文字阅读大概需要30分钟。
内容图文
MongoDB分片存储的集群架构实现
分片的基本概念
分片（sharding）是一种水平扩展（horizontal scaling）的方式，把一个大的数据集分散到多个片服务器上，所有的片服务器将组成一个逻辑上的数据库来存储这个大的数据集。分片对用户（应用层）是透明的，用户不会知道数据很被存放到哪个片服务器上。
这种方式有两个好处：
分片之后，每个片服务器处理的请求数量将远远小于不分片的情况，这样就可以水平扩展整个分片集群的存储量和吞吐量
分片之后每个片服务器需要存储、维护的数据量将大大减少
分片以及分片集群
下面的图来自MongoDB文档，图片大概展示了分片的概念。1TB的数据被分配到四个片服务器上，四个片服务器组成了逻辑Collection I。
在MongoDB中，我们可以搭建分片集群（如下图）来实现数据分片的功能。分片集群中有三个基本部分组成：
Mongos（路由服务器）：是MongoDB中的路由进程，它将路由所有来自客户端的请求，分发到每个分片server；然后它将聚合各个分片server的结果，返回个客户端
config server（配置服务器）：该服务器存储了集群的配置信息：数据和片的对应关系。路由器将根据数据和分片的mapping，把数据操作分配到特定的分片上
shard server（片服务器）：用来保存子集合的数据容器。片服务器可以是单个的mongod服务器，也可以是一个副本集
片键
当设置分片时，需要从集合里面选择一个或几个键，把选择出来的键作为数据拆分的依据，这个键叫做片键或复合片键。
选好片键后，MongoDB将不允许插入没有片键的文档，但是允许不同文档的片键类型不一样。
块（chunk）
在一个shard server内部，MongoDB还是会把数据分为chunks，每个chunk代表这个shard server内部一部分数据。chunk的产生，会有以下两个用途：
Splitting：
当一个chunk的大小超过配置中的chunk size时，MongDB的后台进程会把这个chunk切分成更小的chunk，从而避免chunk过大的情况
Balancing：
在MongoDB中，balancer是一个后台进程，负责chunk的迁移，从而均衡各个shard server的负载
分片集群的搭建
搭建
下面我们开始单键一个分片集群，来通过一些实践体验一下分片集群。
启动分片中需要的MongDB实例，在这里为了简单，片服务器使用单个MongoDB实例，而不是副本集
启动配置服务器
mongod.exe --dbpath="C:\mongodb\db\config" --port 11110
启动路由服务器
mongos.exe --port=11111 --configdb=127.0.0.1:11110
启动片服务器
mongod.exe --dbpath="c:\mongodb\db\shard0" --port=22220 mongod.exe --dbpath="c:\mongodb\db\shard1" --port=22221
添加片服务器
通过MongoDB shell连接到mongos实例，并且通过以下命令添加
mongo.exe 127.0.0.1:11111
use admin
db.runCommand({"addshard":"127.0.0.1:22220",allowLocal:true})
db.runCommand({"addshard":"127.0.0.1:22221",allowLocal:true})
启动分片，并且设置片键
mongos> use admin
switched to db admin
mongos> db.runCommand({"enablesharding":"test"})
{ "ok" : 1 }
mongos> db.runCommand({"shardcollection":"test.student","key":{"sid":1}})
{ "collectionsharded" : "test.student", "ok" : 1 }
mongos>
查看分片集群状态
通过下面的命令可以查看分片集群的状态，可以得到以下信息：
分片集群中所有的片服务器
分片集群中所有的数据库，以及哪些数据库已经启动分片
已分片数据库的主片和片键
mongos> db.runCommand({"listShards":1})
{
"shards" : [
{
"_id" : "shard0000",
"host" : "127.0.0.1:22220"
},
{
"_id" : "shard0001",
"host" : "127.0.0.1:22221"
}
],
"ok" : 1
}
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0000", "host" : "127.0.0.1:22220" }
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0000" }
test.student
shard key: { "sid" : 1 }
chunks:
shard0000 1
{ "name" : { "$minKey" : 1 } } -->> { " sid " : { "$maxKey" : 1 } } on : shard0000 Timestamp(1, 0)
mongos>
删除分片
在上面的输出中，可以看到以下输出语句。在所有的片服务器中，都会有一个主片，这个片的删除需要特殊的命令。同时，删除分片可能需要一定的时间，因为MongoDB会把要删除分片上的数据移动到其他的分片上。
{ "_id" : "test", "partitioned" : true, "primary" : "shard0000" }
首先，从简单的开始，先删除非主片shard0001，从输出可以看到，shard0001处于draining状态，表示数据正在转移，当需要迁移的数据量很大的时候，可能就需要等待一些时间
mongos> db.runCommand({"removeshard":"127.0.0.1:22221"})
{
"msg" : "draining started successfully",
"state" : "started",
"shard" : "shard0001",
"ok" : 1
}
mongos> db.runCommand({"listShards":1})
{
"shards" : [
{
"_id" : "shard0000",
"host" : "127.0.0.1:22220"
},
{
"_id" : "shard0001",
"draining" : true,
"host" : "127.0.0.1:22221"
}
],
"ok" : 1
}
mongos>
再次使用删除操作，可以看到shard0001已经被删除
mongos> db.runCommand({"removeshard":"127.0.0.1:22221"})
{
"msg" : "removeshard completed successfully",
"state" : "completed",
"shard" : "shard0001",
"ok" : 1
}
mongos> db.runCommand({"listShards":1})
{
"shards" : [
{
"_id" : "shard0000",
"host" : "127.0.0.1:22220"
}
],
"ok" : 1
}
mongos>
下面重新添加刚才删除的分片，这次尝试删除主分片，会遇到以下错误
mongos> db.runCommand({"removeshard":"127.0.0.1:22220"})
{
"msg" : "draining started successfully",
"state" : "started",
"shard" : "shard0000",
"note" : "you need to drop or movePrimary these databases",
"dbsToMove" : [
"test"
],
"ok" : 1
}
mongos>
这时，使用moveprimary命令把shard0001设置为主分片
mongos> db.runCommand({"moveprimary":"test","to":"127.0.0.1:22221"})
{ "primary " : "shard0001:127.0.0.1:22221", "ok" : 1 }
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0000", "draining" : true, "host" : "127.0.0.1:22220" }
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0001" }
test.student
shard key: { " sid " : 1 }
chunks:
shard0001 1
{ "name" : { "$minKey" : 1 } } -->> { " sid " : { "$maxKey" : 1 } } on : shard0001 Timestamp(2, 0)
mongos>
然后就可以直接删除shard0000了
mongos> db.runCommand({"removeshard":"127.0.0.1:22220"})
{
"msg" : "removeshard completed successfully",
"state" : "completed",
"shard" : "shard0000",
"ok" : 1
}
mongos> db.runCommand({"listShards":1})
{
"shards" : [
{
"_id" : "shard0001",
"host" : "127.0.0.1:22221"
}
],
"ok" : 1
}
mongos>
最后重新添加刚才删除的分片，将遇到以下错误，提示test数据库已经存在
mongos> db.runCommand({"addshard":"127.0.0.1:22220",allowLocal:true})
{
"ok" : 0,
"errmsg" : "can‘t add shard 127.0.0.1:22220 because a local database ‘test‘ exists in another shard0001:127.0.0.1:22221"
}
mongos>
这时，就需要通过MongoDB shell连接到这个实例，删除test数据库。然后重新添加。
C:\mongodb\bin>mongo.exe --port=22220
MongoDB shell version: 2.4.6
connecting to: 127.0.0.1:22220/test
> use test
switched to db test
> db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }
>
mongos> db.runCommand({"addshard":"127.0.0.1:22220",allowLocal:true})
{ "shardAdded" : "shard0002", "ok" : 1 }
mongos> db.runCommand({"listShards":1})
{
"shards" : [
{
"_id" : "shard0001",
"host" : "127.0.0.1:22221"
},
{
"_id" : "shard0002",
"host" : "127.0.0.1:22220"
}
],
"ok" : 1
}
mongos>
在这个部分中可以看到，通过上面三个步骤，一个简单的分片集群就建立起来了。下面我们开始使用这个分片集群。
分片集群的管理
首先切换到config数据库，看看都有哪些表
mongos> use config switched to db config mongos> show collections changelog chunks collections databases lockpings locks mongos settings shards system.indexes tags version mongos>
然后看看下面几张表中的数据
chunks表：通过这张表可以看到分片集群中的数据块
databases表：表里显示了所有在分片集群中存储的数据库，同时可以看到那些数据库是启动分片的，并且指示出主分片
settings表：这张表包含分片集群的配置项，其中块大小（chunk size）就是通过这个文件设置
shards表：这张表包含了分片集群中的所有片
mongos> db.chunks.find()
{ "_id" : "test.student-sid_MinKey", "lastmod" : Timestamp(1, 0), "lastmodEpoch" : ObjectId("548c02d79355a9edbf5f0193"), "ns" : "test.studen
t", "min" : { "sid" : { "$minKey" : 1 } }, "max" : { "sid" : { "$maxKey" : 1 } }, "shard" : "shard0002" }
mongos> db.databases.find()
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0002" }
{ "_id" : "amdin", "partitioned" : false, "primary" : "shard0002" }
mongos> db.settings.find()
{ "_id" : "chunksize", "value" : 1 }
mongos> db.shards.find()
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
{ "_id" : "shard0002", "host" : "127.0.0.1:22220" }
mongos>
默认的chunk size是64MB，为了方便看到下面平衡（Balancing）的过程，我们重设chunk size为1MB
mongos> use config
switched to db config
mongos> db.settings.save({ _id:"chunksize", value: 1})
mongos> db.settings.find()
{ "_id" : "chunksize", "value" : 1 }
mongos>
分片集群的使用
基本测试
基于前面创建的分片集群，我们进行一些测试，首先插入10W条文档，然后查询分片集群的状态。从下面的输出中可以看到，10W条文档一共使用了10个chunk，2个chunk在shard0002上，8个chunk在shard0001上。
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
{ "_id" : "shard0002", "host" : "127.0.0.1:22220" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0002" }
test.student
shard key: { "sid" : 1 }
chunks:
shard0002 2
shard0001 8
{ "sid" : { "$minKey" : 1 } } -->> { "sid" : 0 } on : shard0002 Timestamp(2, 1)
{ "sid" : 0 } -->> { "sid" : 6673 } on : shard0002 Timestamp(1, 3)
{ "sid" : 6673 } -->> { "sid" : 20765 } on : shard0001 Timestamp(2, 2)
{ "sid" : 20765 } -->> { "sid" : 34839 } on : shard0001 Timestamp(2, 4)
{ "sid" : 34839 } -->> { "sid" : 48913 } on : shard0001 Timestamp(2, 6)
{ "sid" : 48913 } -->> { "sid" : 63011 } on : shard0001 Timestamp(2, 8)
{ "sid" : 63011 } -->> { "sid" : 74942 } on : shard0001 Timestamp(2, 10)
{ "sid" : 74942 } -->> { "sid" : 86877 } on : shard0001 Timestamp(2, 12)
{ "sid" : 86877 } -->> { "sid" : 98836 } on : shard0001 Timestamp(2, 14)
{ "sid" : 98836 } -->> { "sid" : { "$maxKey" : 1 } } on : shard0001 Timestamp(2, 15)
{ "_id" : "amdin", "partitioned" : false, "primary" : "shard0002" }
mongos>
经过一段时间后，再次查询分片集群的状态，可以看到，经过Balancing过程，所有的chunk基本要均匀的分布到了两个片服务器中。
MongoDB这种平衡的能力能够对各个片服务器进行负载均衡，但是如果数据特别大话则可能会非常的慢，因为数据迁移了会很大。
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
{ "_id" : "shard0002", "host" : "127.0.0.1:22220" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0002" }
test.student
shard key: { "sid" : 1 }
chunks:
shard0002 5
shard0001 5
{ "sid" : { "$minKey" : 1 } } -->> { "sid" : 0 } on : shard0002 Timestamp(2, 1)
{ "sid" : 0 } -->> { "sid" : 6673 } on : shard0002 Timestamp(1, 3)
{ "sid" : 6673 } -->> { "sid" : 20765 } on : shard0002 Timestamp(3, 0)
{ "sid" : 20765 } -->> { "sid" : 34839 } on : shard0002 Timestamp(4, 0)
{ "sid" : 34839 } -->> { "sid" : 48913 } on : shard0002 Timestamp(5, 0)
{ "sid" : 48913 } -->> { "sid" : 63011 } on : shard0001 Timestamp(5, 1)
{ "sid" : 63011 } -->> { "sid" : 74942 } on : shard0001 Timestamp(2, 10)
{ "sid" : 74942 } -->> { "sid" : 86877 } on : shard0001 Timestamp(2, 12)
{ "sid" : 86877 } -->> { "sid" : 98836 } on : shard0001 Timestamp(2, 14)
{ "sid" : 98836 } -->> { "sid" : { "$maxKey" : 1 } } on : shard0001 Timestamp(2, 15)
{ "_id" : "amdin", "partitioned" : false, "primary" : "shard0002" }
mongos>
当然，也可以通过下面命令查看某个collection的数据在分片中的分布情况
mongos> db.student.getShardDistribution() Shard shard0001 at 127.0.0.1:22221 data : 4.28MiB docs : 51087 chunks : 5 estimated data per chunk : 878KiB estimated docs per chunk : 10217 Shard shard0002 at 127.0.0.1:22220 data : 4.1MiB docs : 48913 chunks : 5 estimated data per chunk : 840KiB estimated docs per chunk : 9782 Totals data : 8.39MiB docs : 100000 chunks : 10 Shard shard0001 contains 51.08% data, 51.08% docs in cluster, avg obj size on shard : 88B Shard shard0002 contains 48.91% data, 48.91% docs in cluster, avg obj size on shard : 88B mongos>
对现有数据库分片
现在假设我们有一个”127.0.0.1:22222″的MongDB实例，我们想对上面已有的数据进行分片。
首先插入测试数据
use school
for(var i=0;i<100000;i++){
var randAge = parseInt(5*Math.random()) + 20;
var gender = (randAge%2)?"Male":"Female";
db.student.insert({"sid":i, "name":"Will"+i, "gender": gender, "age": randAge});
}
然后，在现有的分片集群中加入”127.0.0.1:22222″作为一个片服务器，从下面的输出可以看到：
分片集群已经加入片服务器”127.0.0.1:22222″
分片集群中原有的需要分片的数据库（test）的数据被Balancing到新的片服务器上
新加入的片服务器上的数据库（school）没有开启分片
mongos> use admin
switched to db admin
mongos> db.runCommand({"addshard":"127.0.0.1:22222",allowLocal:true})
{ "shardAdded" : "shard0003", "ok" : 1 }
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
{ "_id" : "shard0002", "host" : "127.0.0.1:22220" }
{ "_id" : "shard0003", "host" : "127.0.0.1:22222" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0002" }
test.student
shard key: { "sid" : 1 }
chunks:
shard0003 3
shard0002 4
shard0001 3
{ "sid" : { "$minKey" : 1 } } -->> { "sid" : 0 } on : shard0003 Timestamp(7, 0)
{ "sid" : 0 } -->> { "sid" : 6673 } on : shard0002 Timestamp(7, 1)
{ "sid" : 6673 } -->> { "sid" : 20765 } on : shard0002 Timestamp(3, 0)
{ "sid" : 20765 } -->> { "sid" : 34839 } on : shard0002 Timestamp(4, 0)
{ "sid" : 34839 } -->> { "sid" : 48913 } on : shard0002 Timestamp(5, 0)
{ "sid" : 48913 } -->> { "sid" : 63011 } on : shard0003 Timestamp(6, 0)
{ "sid" : 63011 } -->> { "sid" : 74942 } on : shard0003 Timestamp(8, 0)
{ "sid" : 74942 } -->> { "sid" : 86877 } on : shard0001 Timestamp(8, 1)
{ "sid" : 86877 } -->> { "sid" : 98836 } on : shard0001 Timestamp(2, 14)
{ "sid" : 98836 } -->> { "sid" : { "$maxKey" : 1 } } on : shard0001 Timestamp(2, 15)
{ "_id" : "amdin", "partitioned" : false, "primary" : "shard0002" }
{ "_id" : "school", "partitioned" : false, "primary" : "shard0003" }
mongos>
当我们使用以下命令开启school的分片时，会得到一个错误，提示我们sid没有索引。
根据MongDB文档，所有分片的集合在片键上都必须建索引，这是MongoDB自动执行的。所以，对已有的数据库加入分片集群中的时候，可能就需要手动建立索引了。
根据这一点我们也可以得到，片键最好是查询中经常用到的字段，因为如果选择某个字段作为片键但是基本不在这个字段做查询那么等于浪费了一个索引，而增加一个索引总是会使得插入操作变慢。
mongos> db.runCommand({"enablesharding":"school"})
{ "ok" : 1 }
mongos> db.runCommand({"shardcollection":"school.student","key":{"sid":1}})
{
"proposedKey" : {
"sid" : 1
},
"curIndexes" : [
{
"v" : 1,
"key" : {
"_id" : 1
},
"ns" : "school.student",
"name" : "_id_"
}
],
"ok" : 0,
"errmsg" : "please create an index that starts with the shard key before sharding."
}
回到刚才的错误，我们现在手动建立一个sid的索引，然后重新设置片键，这次成功了，并且school中的数据已经被Balancing到各个片服务器上。
mongos> use school
switched to db school
mongos> db.student.getIndexes()
[
{
"v" : 1,
"key" : {
"_id" : 1
},
"ns" : "school.student",
"name" : "_id_"
}
]
mongos> db.student.ensureIndex({"sid":1})
mongos> use admin
switched to db admin
mongos> db.runCommand({"shardcollection":"school.student","key":{"sid":1}})
{ "collectionsharded" : "school.student", "ok" : 1 }
mongos> db.printShardingStatus()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"version" : 3,
"minCompatibleVersion" : 3,
"currentVersion" : 4,
"clusterId" : ObjectId("548bd82b9355a9edbf5efa69")
}
shards:
{ "_id" : "shard0001", "host" : "127.0.0.1:22221" }
{ "_id" : "shard0002", "host" : "127.0.0.1:22220" }
{ "_id" : "shard0003", "host" : "127.0.0.1:22222" }
databases:
{ "_id" : "admin", "partitioned" : false, "primary" : "config" }
{ "_id" : "test", "partitioned" : true, "primary" : "shard0002" }
test.student
shard key: { "sid" : 1 }
chunks:
shard0003 3
shard0002 4
shard0001 3
{ "sid" : { "$minKey" : 1 } } -->> { "sid" : 0 } on : shard0003 Timestamp(7, 0)
{ "sid" : 0 } -->> { "sid" : 6673 } on : shard0002 Timestamp(7, 1)
{ "sid" : 6673 } -->> { "sid" : 20765 } on : shard0002 Timestamp(3, 0)
{ "sid" : 20765 } -->> { "sid" : 34839 } on : shard0002 Timestamp(4, 0)
{ "sid" : 34839 } -->> { "sid" : 48913 } on : shard0002 Timestamp(5, 0)
{ "sid" : 48913 } -->> { "sid" : 63011 } on : shard0003 Timestamp(6, 0)
{ "sid" : 63011 } -->> { "sid" : 74942 } on : shard0003 Timestamp(8, 0)
{ "sid" : 74942 } -->> { "sid" : 86877 } on : shard0001 Timestamp(8, 1)
{ "sid" : 86877 } -->> { "sid" : 98836 } on : shard0001 Timestamp(2, 14)
{ "sid" : 98836 } -->> { "sid" : { "$maxKey" : 1 } } on : shard0001 Timestamp(2, 15)
{ "_id" : "amdin", "partitioned" : false, "primary" : "shard0002" }
{ "_id" : "school", "partitioned" : true, "primary" : "shard0003" }
school.student
shard key: { "sid" : 1 }
chunks:
shard0001 6
shard0002 5
shard0003 6
{ "sid" : { "$minKey" : 1 } } -->> { "sid" : 5957 } on : shard0001 Timestamp(2, 0)
{ "sid" : 5957 } -->> { "sid" : 11915 } on : shard0002 Timestamp(3, 0)
{ "sid" : 11915 } -->> { "sid" : 17873 } on : shard0001 Timestamp(4, 0)
{ "sid" : 17873 } -->> { "sid" : 23831 } on : shard0002 Timestamp(5, 0)
{ "sid" : 23831 } -->> { "sid" : 29789 } on : shard0001 Timestamp(6, 0)
{ "sid" : 29789 } -->> { "sid" : 35747 } on : shard0002 Timestamp(7, 0)
{ "sid" : 35747 } -->> { "sid" : 41705 } on : shard0001 Timestamp(8, 0)
{ "sid" : 41705 } -->> { "sid" : 47663 } on : shard0002 Timestamp(9, 0)
{ "sid" : 47663 } -->> { "sid" : 53621 } on : shard0001 Timestamp(10, 0)
{ "sid" : 53621 } -->> { "sid" : 59579 } on : shard0002 Timestamp(11, 0)
{ "sid" : 59579 } -->> { "sid" : 65537 } on : shard0001 Timestamp(12, 0)
{ "sid" : 65537 } -->> { "sid" : 71495 } on : shard0003 Timestamp(12, 1)
{ "sid" : 71495 } -->> { "sid" : 77453 } on : shard0003 Timestamp(1, 12)
{ "sid" : 77453 } -->> { "sid" : 83411 } on : shard0003 Timestamp(1, 13)
{ "sid" : 83411 } -->> { "sid" : 89369 } on : shard0003 Timestamp(1, 14)
{ "sid" : 89369 } -->> { "sid" : 95327 } on : shard0003 Timestamp(1, 15)
{ "sid" : 95327 } -->> { "sid" : { "$maxKey" : 1 } } on : shard0003 Timestamp(1, 16)
mongos>
总结
通过本篇文章了解了分片的基本概念，同时搭建了一个简单的分片集群，进行了一些基本测试。
对于什么时候要使用分片这个问题，可以主要有下面几个参考点：
数据量很大单个存储服务器无法满需需求
系统中活动数据量的大小很快将要超过系统RAM的最大容量
系统有大量的读写请求，单个单个存储服务器不足以支持
参考来源：
MongoDB分片存储的集群架构实现
http://www.lai18.com/content/317635.html
延伸阅读
《MongoDB技术知识》系列技术文章整理收藏
1mongoDB入门需要了解的基本知识
2MongoDB入门教程（包含安装、常用命令、相关概念、使用技巧、常见操作等）
3MongoDB入门教程之分片技术详解
4MongoDB入门教程之常用的运维技术介绍
5MongoDB入门教程之C#驱动操作实例
6MongoDB入门教程之主从复制配置详解
7MongoDB入门教程之聚合和游标操作介绍
8MongoDB入门教程之细说MongoDB数据库的增删查改操作
9MongoDB入门教程之索引操作浅析
10MongoDB入门教程之Windows下的MongoDB数据库安装图解
11MongoDB查询字段没有创建索引导致的连接超时异常解案例分享
12MongoDB日志文件过大的解决方法
13MongoDB社区版和企业版的差别对照表
14MongoDB中文社区发起人带你学习mongoDB
15对MongoDB数据库性能瓶颈分析
16MongoDB 分页查询的方法及性能
17MongoDB分片存储的集群架构实现
18Mongodb批量删除gridfs文件实例
19Mongodb增加、移除Shard Server实例
20Mongodb增加、移除Arbiter节点实例
21CentOS系统下MongoDB安装及配置教程
22MongoDB修改、删除文档的域属性实例
23Python中的MongoDB基本操作：连接、查询实例
24MongoDB导出查询结果到文件例子
25MongoDB中创建索引需要注意的事项
26MongoDB中的一些坑（最好不要用）
27给MongoDB添加用户权限方法分享
28Linux系统下MongoDB的简单安装与基本操作
29MongoDB教程之基本管理命令
30MongoDB教程之聚合（count、distinct和group）
31MongoDB教程之索引介绍
32MongoDB教程之数据操作实例
33MongoDB教程之入门基础知识
34MongoDB教程之查询操作实例
35MongoDB系列教程（四）：设置用户访问权限
36MongoDB系列教程（八）：GridFS存储详解
37MongoDB数据库的特色和优点介绍
38MongoDB简介 MongoDB五大特色
39MongoDB系列教程（六）：java操作mongodb实例
40MongoDB系列教程（七）：MongoDb数据结构详解
41MongoDB系列教程（五）：mongo语法和mysql语法对比学习
42MongoDB系列教程（二）：MongoDB简介
43MongoDB系列教程（一）：NoSQL起源
44MongoDB中的MapReduce简介
45MongoDB系列教程（三）：Windows中下载和安装MongoDB
46浅谈MongoDB的备份方式
47MongoDB 常用命令总结
48MongoDB与MySQL的操作对比表及区别介绍
49MongoDB安全配置详解
50MongoDB中的bson介绍和使用实例
MongoDB分片存储的集群架构实现
标签：mongodb 数据库 存储 图片
本文系统来源：http://blog.csdn.net/u011252402/article/details/47061019
内容总结
以上是互联网集市为您收集整理的MongoDB分片存储的集群架构实现全部内容，希望文章能够帮你解决MongoDB分片存储的集群架构实现所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】