(*)Mongodb的分片配置

这里介绍的是Mongodb的分片配置，如果想配置主主或主从对，以实现数据备份，可见mongodb分布式之数据复制。

1、启动相关进程

在shard server上启动mongod，使用--shardsvr 命令行参数。对于主从对，使用--pairwith命令行选项。建议一个shard server只运行一个mongod进程。

在config server上启动mongod，使用--configsvr命令行参数。如果config server不是一台独立的服务器，为其分配一个独立的dbpath，--dbpath命令行参数。

启动mongos，使用--configdb参数指明配置的数据库地址。

2、shell配置分片

      在启动好的mongos服务器上运行这些命令，然后通过它运行所有的配置命令。注：应该使用特定的admin数据库来存储这些命令，尽管通过mongos运行时，数据会存储在config server上，所以在集群的生命周期内这些命令只需运行一次即可。

./mongo <mongos-hostname>:<mongos-port>/admin
> db
admin
>

3、增加一个分片，每个分片包括两台服务器（一对主从）或单机（Alpha 2只支持单机）。

> db.runCommand( { addshard : "<serverhostname>[:<port>]" } );
{"ok" : 1 , "added" : ...}

多台配置用逗号分隔（alpha3及以上版本）。

可选参数maxSize可用户设置该分片可使用的磁盘空间，默认为整个磁盘。该参数目前1.4及1.4以前的版本是无效的，1.5版本及以后才会有效。

> db.runCommand( { listshards : 1 } );

查看已存在的分片。

4、enable一个数据库，必须为分片enable一个数据库，否则数据将全被存在分片上。

> db.runCommand( { enablesharding : "<dbname>" } );

一旦enable了个数据库，mongos将会把数据库里的不同数据集放在不同的分片上。除非数据集被分片，否则一个数据集的所有数据将放在一个分片上。

5、数据集分片，使用shardcollection 命令分隔数据集，key自动生成。

> db.runCommand( { shardcollection : "<namespace>",
key : <shardkeypatternobject>
} )

比如，分片测试数据库中的GridFS块集。

> db.runCommand( { shardcollection : "test.fs.chunks", key : { _id : 1 } } )
{"ok" : 1}

配置shard key唯一：

db.runCommand( { shardcollection : "test.users" , key : { email : 1 } , unique : true } );

6、相关操作命令，官方操作命令

1)、db.createCollection(name, { size : ..., capped : ..., max : ... } )创建非分布式数据集，相当于关系型数据库中的表，别看后面一堆参数，其实通常用的就db.createCollection(name)这个命令，比如 db.createCollection(“coll_1”)。

2)、db.coll_1.drop()，删数据集。

3)、db.coll_1.ensureIndex({"id":1})，第一个参数为字段名，第二参数值为1则索引为升序；-1则为降序。 db.coll_1.dropIndex(name) 删除指定的索引；db.coll_1.dropIndexes()删除所有索引；db.coll_1.getIndexes()查看索引信息。

4)、db.coll_1.count(query)；db.coll_1.find(query )；db.coll_1.insert(obj)；db.coll_1.update(query, object[, upsert_bool])；db.coll_1.save(obj)；db.coll_1.remove(query)。query 表达式的文档

7、案例：

两组分片（一组两台，一组一台）、三个config db、一个mongos，一台测试服务器。

首先建立数据库存放位置，这里只为测试，所以就在当前目录了，mkdir data

分别到mongodb的安装目录的bin/目录下启动mongodb
$ ./mongod --pairwith 10.13.127.212:18020 --dbpath data --port 18020    //启动第一组分片（10.13.127.211:18020）
$ ./mongod --pairwith 10.13.127.211:18020 --dbpath data --port 18020    //启动第一组分片（10.13.127.212:18020）
$ ./mongod --dbpath data --port 18020    //启动第二组分片（10.13.127.210:18020）
$ ./mongod --configsvr --dbpath /var/mongodb/sky/18022 --port 18022 //启动config server（10.13.127.210:18022，10.13.127.211:18022，10.13.127.212:18022）
$ ./mongos --configdb 10.13.127.210:18022,10.13.127.211:18022,10.13.127.212:18022 //启动mongos，指定config server

ps：config server可以配置多台，mongos启动时指定config server，多个config server之间用英文逗号隔开，中间注意不要有空格，而且你会发现config server的台数只能为单数不能是双数。在这里需要提的是，v1.4有个bug，如果一开始就mongos配置多台config，是有问题的。这时你执行./mongo命令，在执行show dbs时就会报错：

JS Error: uncaught exception: error { "$err" : "mongos: SyncClusterConnection::call can't handle $cmd" }.

解决方案有两个：
1）启动mongos时先只连一台config，貌似是可以初始化一下config，然后kill掉mongos再启动连多台config，就OK了。
2）这个bug已经在nightly修正了，下载版本时下载v1.4的nightly版本就行了。

言归正传，服务启动好了之后，可使用 ps -ef|grep mongo查看运行情况，开始使用mongodb了。
$ ./mongo --host 10.13.127.211      // 连接到mongos上，可使用--port指定端口

> show dbs
admin
config
Local
> use admin

> db.runCommand( { addshard : "10.13.127.211:18020,10.13.127.212:18020", allowLocal : true } ) //增加第一组分片  
> db.runCommand( { addshard : "10.13.127.210:18020", allowLocal : true } )   //增加第二个分片

> db.runCommand({listshards:1}) //查看分片情况，会看到分片的信息，共两块

{
"_id" : ObjectId("4bd27bb39e2b00a5f7d5f0dd"),
"host" : "10.13.127.210:18020"
},
{
"_id" : ObjectId("4bd27bd39e2b00a5f7d5f0de"),
"host" : "10.13.127.211:18020,10.13.127.212:18020"
}

> config = connect("10.13.127.210:18022")         //连接config server，需要在mongos服务器上操作
> config = config.getSisterDB("config")    //获取配置信息

> test = db.getSisterDB("test")       //新增数据库test

> db.runCommand( { enablesharding : "test" } )
> db.runCommand( { shardcollection : "test.people", key : {name : 1} } )    //建立分片数据集people

> db.printShardingStatus();     //查看分片状态信息，会看到shards和databases的详细信息，包括刚建立的test的主分片信息和test.people的分片信息。

my chunks
{ "name" : "test", "partitioned" : true, "primary" : "10.13.127.211:18020,10.13.127.212:18020", "sharded" : { "test.people" : { "key" : { "name" : 1 }, "unique" : false } }, "_id" : ObjectId("4bd2813fbaaa646853a4b33a") }
my chunks
test.people { "name" : { $minKey : 1 } } -->> { "name" : { $maxKey : 1 } } on :10.13.127.211:18020,10.13.127.212:18020 { "t" : 1272086852000, "i" : 1 }10.13.126.173:18020 { "t" : 1272086192000, "i" : 1 }

> use test     //进入test数据库
switched to db test
> db.createCollection("user_001")     //建立数据集user_001，该数据集与people数据集不一样，它不分片
{ "ok" : 1 }
> show collections     //查看数据集情况
people
system.indexes
user_001

> db.people.insert({name:"sky_people",sex:"male",age:25});      //插入一条记录了
> db.people.find()
{ "_id" : ObjectId("4bbc38a39e8b5e76dcf4c5a3"), "name" : "sky_people", "sex" : "male", "age" : 25 }
> db.user_001.insert({name:"Falcon.C",sex:"male",age:25});   
> db.user_001.find();          //查看记录
{ "_id" : ObjectId("4bbc371c9e8b5e76dcf4c5a2"), "name" : "sky", "sex" : "female", "age" : 25 }

>db.people.stats()       //查看people数据集信息 ，刚才插入的数据放在 10.13.127.210:18020分片上                                                 
{
"sharded" : true,
"ns" : "test.people",
"count" : 1,
"size" : 72,
"storageSize" : 8192,
"nindexes" : 2,
"nchunks" : 1,
"shards" : {
"10.13.127.211:18020,10.13.127.212:18020" : {
"ns" : "test.people",
"count" : 1,
……

> db.user_001.stats()       //查看user_001数据集信息
{
"sharded" : false,
"ns" : "test.user_001",
"count" : 1,
"size" : 68,
……
}

当数据量增大到一定程度的时候（貌似是64M，即一个数据块的大小），数据块chunks开始分块，由一开始的一块变成多块时，数据块chunks就会开始迁移到其他分片了。

> db.printShardingStatus();   //查看分片状态信息

{ "name" : "test", "partitioned" : true, "primary" : "10.13.127.211:18020,10.13.127.212:18020", "sharded" : { "test.people" : { "key" : { "name" : 1 }, "unique" : false } }, "_id" : ObjectId("4bbc3524314b8edcaebd990f") }
my chunks
test.people { "name" : { $minKey : 1 } } -->> { "name" : 1103 } on : 10.13.127.211:18020,10.13.127.212:18020 { "t" : 1270627397000, "i" : 1 }
test.people { "name" : 1103 } -->> { "name" : 1259408 } on : 10.13.127.211:18020,10.13.127.212:18020 { "t" : 1270627921000, "i" : 2 }
test.people { "name" : "sky_people" } -->> { "name" : { $maxKey : 1 } } on : 10.13.127.210:18020 { "t" : 1270627404000, "i" : 3 }
test.people { "name" : 20130082 } -->> { "name" : 21392803 } on : 10.13.127.210:18020 { "t" : 1270627924000, "i" : 2 }
....

>db.people.stats()
{
"sharded" : true,
"ns" : "test.people",
"count" : 3384868,
"size" : 5293932968,
"storageSize" : 5942890496,
"nindexes" : 2,
"nchunks" : 33,
"shards" : {
"10.13.127.211:18020,10.13.127.212:18020" : {
"ns" : "test.people",
"count" : 3265179,
"size" : 5106739036,
"storageSize" : 5722345728,
"numExtents" : 32,
"nindexes" : 2,
"lastExtentSize" : 960247296,
"paddingFactor" : 1,
"flags" : 1,
"totalIndexSize" : 312467456,
"indexSizes" : {
"_id_" : 177045504,
"name_1" : 135421952
},
"ok" : 1
},
"10.13.127.210:18020" : {
"ns" : "test.people",
"count" : 119689,
"size" : 187193932,
"storageSize" : 220544768,
"numExtents" : 15,
"nindexes" : 2,
"lastExtentSize" : 43281920,
"paddingFactor" : 1,
"flags" : 1,
"totalIndexSize" : 12025856,
"indexSizes" : {
"_id_" : 7159808,
"name_1" : 4866048
},
"ok" : 1
}
},
"ok" : 1
}

在单个服务器上，安装2个shards（shard:通常的datanode,这里也可以是一个目录），1个config db 和 一个mongos处理器。

步骤一：创建Shard
首先要启动两个mongod服务
$ mkdir /data/db/a /data/db/b
$ ./mongod --shardsvr --dbpath /data/db/a --port 27020 > /tmp/sharda.log &
$ cat /tmp/sharda.log
$ ./mongod --shardsvr --dbpath /data/db/b --port 27021 > /tmp/shardb.log &
$ cat /tmp/shardb.log

其次要启动配置服务器(configuration server)和mongos
$ mkdir /data/db/config
$ ./mongod --configsvr --dbpath /data/db/config --port 27022 > /tmp/configdb.log &
$ cat /tmp/configdb.log
$ ./mongos --configdb localhost:27022 > /tmp/mongos.log &
$ cat /tmp/mongos.log

mongos不需要一个数据存放的文件夹，但是需要将config server的port传递给它。
注意了：
在一个真实的应用场景里，mongod 、mongos和configs应该在不同的服务器上。这里面的“localhost”,最好用
ip地址或者hostname代替。这里只是单机举个例子。
mongos 通过追加 --chunkSize (单位是M 例如 --chunkSize 1 代表每个chunk大小为1M)
$ ./mongos --configdb localhost:27022 --chunkSize 1 > /tmp/mongos.log &

步骤二：建立集群喽
启动shell,需要连接到mongos上（这个默认的连接是 localhost:27017）

现在我们把两个shard加入到集群中：
$ ./mongo --port 27017
MongoDB shell version: 1.6.3
connecting to: test
> use admin
switched to db admin
> db.runCommand( { addshard : "localhost:10000" } )
{ "shardadded" : "shard0000", "ok" : 1 }
> db.runCommand( { addshard : "localhost:10001" } )
{ "shardadded" : "shard0001", "ok" : 1 }

下面你需要告诉数据库你想在数据库和数据集的级别来分散存放你的数据。
这个时候，你需要分配一个key(或分配多个keys)来划分partition.
这个和对一个collection建立一个索引是类似的。

> db.runCommand( { enablesharding : "test" } )
{"ok" : 1}
> db.runCommand( { shardcollection : "test.people", key : {name : 1} } )
{"ok" : 1}

步骤三：管理
通过config数据库，来查看集群状况
> use config
switched to db config
> show collections
chunks
databases
lockpings
locks
mongos
settings
shards
system.indexes
version
这些collects包含了所有额sharding配置信息