MongoDB实战_PS ： 操作性很强的入门手记

./mongo --port 27017

show dbs ----已有数据库列表

show collections ---- 已有集合列表

show users ----已有用户列表

use dbname ---- 切换数据库，系统会自动延迟创建该数据库

db.account.save({'name':'test','addr':'china'}) -- 创建集合

db.account.find() -- 查看集合数据

db.dropDatabase() -- 删除数据库

数据库组件：mongod、mongos、mongo

数据库工具：

mongodump -h dbhost -d dbname -o dbdirectory -- 数据库备份

mongorestore -h dbhost -d dbname --directoryperdb dbdirectory -- 数据库恢复

./bsondump dump/bbs/account.bson -- 查看bson对象

./mongoexport -d bbs -c account -q {} -f name,addr --csv > account.csv -- 数据导出工具，导出为csv格式

./mongoexport -d bbs -c account -q {} -f name,addr > account.json 导出为json格式

./mongoexport -d bbs -c account -q '{"name":"test2"}' -f name,addr --csv > account.csv 带查询条件导出

./mongoimport -d bbs -c account --type csv --headerline --drop < account.csv -- 数据导入工具,导入csv文件

./mongoimport -d bbs -c account --type json --drop < account.json--导入json文件

===================文档插入=======================

单个文档插入:db.account.insert({"userName" : "bbs10000001", "passwd" : "ddddddd", "acctAttr" : null })

===============文档删除=============

删除文档中所有数据：db.account.remove(),不删除索引

条件删除：db.account.remove({"userName":"bbs1100"})

删除整个集合：db.account.drop()。数据、索引一起删除，性能好

=============文档更新=====================

更新命令：db.account.update({"userName":"bbs10"},{ "_id" : "3e1fd26f4b0f8351760fcc54", "userName" : "bbs10", "passwd" : "fff", "acctAttr" : null })

$set用法，使用修改器进行局部更改：db.account.update({"_id" : "3e1fd26f4b0f8351760fcc54"},{ "$set":{"passwd":"d"}})

去掉一个键：db.account.update({"userName":"bbs10"},{ "$unset":{"passwd":1}})

$inc用法，db.account.update({"userName":"bbs10"},{ "$inc":{"age":30}})

加1：db.account.update({"userName":"bbs10"},{ "$inc":{"age":1}})

减1：db.account.update({"userName":"bbs10"},{ "$inc":{"age":-1}})

$inc的键值必须为数值。

数组修改器$push。db.account.update({"userName":"bbs10"},{$push:{"email":"1@163.com"}})

$addToSet避免重复加入：db.account.update({"userName":"bbs10"}},{$addToSet:{"email":"4@163.com"}})

pop修改器：db.account.update({"userName":"bbs10"},{$pop:{"email":1}}) 从数组尾删除一个元素

从数组头删除一个元素:db.account.update({"userName":"bbs10"},{$pop:{"email":-1}})

指定位置删除删除元素：db.account.update({"userName":"bbs10"},{$pull:{"email":"2@163.com"}})

多文档更新：db.account.update({"userName":"bbs10"},{$set:{"passwd":"a"}},false,true)

看执行结果，有多少文档被更新：db.runCommand({getLastError:1})

执行getLastError时，驱动程序会等待数据库返回结果

=====================查询========基础查询find命令==================

查询集合所有文档：db.account.find()

简单条件查询：db.account.find({"userName":"bbs10"})

多值匹配条件查询，类似"条件1 and 条件2":

db.account.find({"userName":"bbs10","passwd":"ddd"})

指定返回某些键：db.account.find({},{"userName":1,"passwd":1})

db.account.find({},{"passwd":0})

db.account.find({},{"userName":1,"_id":0})

=====================查询========复合条件查询==================

比较操作符lt、lte、gt、gte、ne分别对应<、<=、>、>=、!=

db.account.insert({"userName":"bbs2000000","age":30,"createTime":new Date()})

db.account.find({"createTime":{"$gt":start}})

db.account.find({"age":{"$gt":30,"$lt":40}})

db.account.find({"age":{"$ne":30}})

$in查询：db.account.find({"age":{"$in":[30,32]}})

db.account.find({"age":{"$nin":[30,32]}})

$or 或查询,可多键值或查询：db.account.find({"$or":[{"userName":"bbs2000000"},{"age":32}]})

组合查询db.account.find({"$or":[{"userName":"bbs2000000"},{"age":{"$in":[30,32]}}]})

$not运算符,可运用于任何条件之上，表示取非：db.account.find({"age":{"$not":{"$nin":[30,32]}}})

$mod模运算：db.account.find({"age":{"$mod":[5,0]}})

=====================查询========高级查询规则-null=================

null不仅匹配自身，还匹配不存在db.account.find({"createTime":null})

要结合$exist才能准确查出属性为null的文档：

db.account.find({"createTime":{"$in":[null],"$exists":true}})

====================查询=======正则表达式==================

正则表达式规则遵循javascript正则表达式规则db.account.find({"userName":/bbs200000/i})

带前缀正则表达式查询性能最好：db.account.find({"userName":/^bbs200000/i})

=====================查询========查询数组==================

db.food.insert({"_id":1,"fruit":["apple","banana","peach"]})

db.food.insert({"_id":2,"fruit":["apple","watermelon","orange"]})

db.food.insert({"_id":3,"fruit":["cherry","banana","apple"]})

单元素匹配任何一个就行：db.food.find({"fruit":"apple"})

多元素匹配要用$all,既有apple又有banana的文档：

db.food.find({"fruit":{$all:["apple","banana"]}})

数组下标从0开始，用数组下标指定位置查询：

db.food.find({"fruit.2":"apple"})

$size,查询指定数组长度的数组：db.food.find({"fruit":{"$size":3}})

=====================查询========查询内嵌文档==================

db.account.insert({"userName":{"first":"joe","last":"schmoe"},"age":35})

完全匹配查询：db.account.find({"userName":{"first":"joe","last":"schmoe"}})

改变文档数据模式db.account.update({},{"$set":{"userName.passwd":"ddd"}})

点表示法查询(不受文档数据模式改变影响)：db.account.find({"userName.first":"joe","userName.last":"schmoe"})

再次改变文档数据模式，增加数组元素db.account.update({},{"$push":{"comments":{"author":"joe","score":3,"comment":"test"}}})

db.account.update({},{"$push":{"comments":{"author":"tom","score":5,"comment":"test"}}})

查询作者为joe并且得分超过5分的文档：db.account.find({"comments.author":"joe","comments.score":{"$gte":5}})

正确做法,采用$elemMatch对内嵌文档多键匹配：db.account.find({"comments":{"$elemMatch":{"author":"joe","score":{"$gte":5}}}})

=====================查询========where查询==================

db.food.insert({"apple":1,"banana":6,"peach":3})

db.food.insert({"apple":8,"spinach":4,"watermelon":4})

db.food.find({"$where":function(){ for(var current in this){ for(var other in this){ if(current !=other && this[current]==this[other]){ return true; } } } return false; }});

不是逼急了不要用where 查询，能用键/值对尽量用键/值对查询方式

where查询无法使用索引，并且文档要从bson转成javascript对象，查询速度非常慢

=====================查询========游标操作==================

for(i=0;i<100;i++){ db.c.insert({x:i}); }

定义游标，不会立即执行查询：var cursor=db.c.find()

游标迭代器：while(cursor.hasNext()){ obj=cursor.next() }

执行cursor.hasNext()时，查询发往服务器，执行真正查询，shell会获取前100个结果或者4M数据（两者较小者）返回。

限制结果数据:db.c.find().limit(5);

跳过匹配文档：db.c.find().skip(5);

排序：sort用一个对象为参数，键、值对表示，键对应文档键名，值表示排序方向。1-升序，-1 - 降序。

db.c.find().sort({x:-1}) db.c.find().sort({x:1})

多键复合排序：db.account.find().sort({userName:1,age:-1})

=====================查询========游标分页==================

for(i=0;i<100;i++){ db.c.insert({x:i,y:"post"}); }

按条件查询每页20条纪录db.c.find({"y":"post"}).limit(20).sort({"x":1})

db.c.find({"y":"post"}).limit(20).sort({"x":-1})

分页参数就是skip的参数db.c.find({"y":"post"}).limit(20).skip(20).sort({"x":1})

注意，用skip跳过少量文档是可行的，数量太多就会变慢

另一种不用skip进行分页的方法

=====================查询========游标内幕==================

服务器端，游标消耗内存和其它资源，要尽快合理释放

游标遍历完或客户端发消息终止，释放游标

游标在客户端不在作用域，驱动会向服务器发消息销毁游标

超时销毁机制，游标即使是在客户端作用域内，但10分钟不用，也会自动被销毁

若关闭游标超时销毁机制(驱动immortal函数)，游标使用完，一定要显式将其关闭，否则其会一直消耗服务器资源。

====================索引创建==================

for(i=0;i<10000;i++){ db.account.insert({userName:"bbs"+i,age:i%60,createTime:new Date()}); }

单键索引：db.account.ensureIndex({"userName":1})

1--表示升序，-1 -- 表示降序

复合索引：db.account.ensureIndex({"userName":1,"age":-1})

db.account.ensureIndex({"userName":1,"age":1,"createTime":1})

只有索引前部的查询会得到优化

索引优化查询的同时，会对增删改带来额外开销

索引创建原则

应用程序会做什么查询，哪些键需要索引

每个键的索引方向是怎样的

如何应对扩展？如何通过不同键的排列使数据尽可能多的保存在内存中，增加命中率

数据量大时为排序创建索引

=====================唯一索引=================

db.account.ensureIndex({"userName":1},{"unique":true})

默认插入数据时不检查数据唯一性

安全插入时才会检查数据唯一性

_id键索引就是唯一索引，并且不能删除

也可创建唯一复合索引，单键可重复，组合后不相同即可

=====================查询分析工具==================

explain可分析查询使用索引的情况，耗时、及扫描文档数的统计

db.account.find({"userName":"bbs22"}).explain()

db.account.find({"age":30}).sort({"userName":1}).explain()

db.account.find({"age":{$gt:20,$lt:30}}).explain()索引前后比较

=====================强制指定索引使用==================

hint可以强制mongodb使用某一个索引

db.account.find({"age":{$gt:20,$lt:30}}).hint({"userName":1,"age":1,"createTime":1}).explain()

通常mongodb会智能选择最优索引使用

=====================聚合统计==================

count

统计集合总数： db.account.count()

条件统计：db.account.count({"age":30})

增加查询条件统计通常用于分页查询，但增加查询条件统计会使统计变慢

distinct

用于找出指定键的不同值

db.runCommand({"distinct":"account","key":"age"})

必须指定集合名，键名

计算distinct后的count总数：

db.runCommand({"distinct":"account","key":"age"}).values.length

db.runCommand({"distinct":"account","key":"age","query":{"age":{"$gt":30}}}).values.length

group

db.account.group({ key:{"age":true}, initial:{number:0}, reduce:function(doc,prev){prev.number+=1 },cond:{"age":{"$gt":30}}})

key关键字标识我们想要汇总的数据(类似于SQL中GROUP BY子句的参数)

initial关键字标识我们记录的关键字的关键值的初始值

reduce关键字定义了一个方法,每次遇一个文档要做的事情

cond关键字定义条件

========================高级指南==================命令的工作原理================

db.account.drop()

db.runCommand({"drop":"account"})

命令响应结果是一个文档，ok键值为true表示执行成功，为false表示执行失败。

errmsg键值表示失败原因。

MongoDB中的命令其实是作为一种特殊类型的查询来执行的。这些查询针对$cmd集合来执行，runCommand仅仅命令文档，执行等价查询。

db.$cmd.findOne({"drop":"c"})

支持的命令浏览

db.listCommands()

访问web console也可获取

版本命令:db.runCommand({"buildInfo":1})

集合统计信息 ：db.runCommand({"collStats":"account"})

修复数据库：{"repairDatabase":1} 比较耗时

删除集合：{"drop":collection}

查看对本集合最后一次操作的错误信息：db.runCommand({ "getlasterror" : 1 , "w" : 1 , "wtimeout" : 0})

删除当前数据库：{"dropDatabase":1}

删除索引：{"dropIndexes":collection,"index":name}

检查本服务器是主服务器还是从服务器：{"isMaster":1}

列出服务器上所有数据库(管理专用)：{"listDatabases":1}

重命令集合:{"renameCollection":a,"to":b} a、b均必须为完整的命令空间（管理专用）

服务器管理统计信息：{"serverStatus":1}

========================高级指南==================固定集合================

固定集合：事先创建，大小固定

类似环状队列，空间不足队列头文件被替换

不能手工删除文档，只能自动替换

特点;插入性能好，不需额外分配空间，直接插入队列尾.按插入顺利查询速度极快

创建固定大小100k的固定集合：db.createCollection("fixed",{capped:true,size:100000})

插入测试数据：for(i=0;i<10000;i++){ db.fixed.insert({userName:"bbs"+i,age:i%60,createTime:new Date()}); }

创建固定大小100K且文档数最大100的固定集合： db.createCollection("fixed",{capped:true,size:100000,max:100})

容量未满时按文档数限制，容量满时按容量限制

转换语法：db.runCommand({convertToCapped:"account",size:10000})

========================高级指南==================GridFS================

GridFS是MongoDB中存储大二进制文件的机制。

使用GridFS后不需要再使用单独的文件存储架构

可直接利用MongoDB的复制分片机制，使文件存储也具有水平扩展、故障恢复功能

不产生磁盘碎片，因为MongoDB分配数据文件空间时以2GB为一块

GridFS用法:

./mongofiles -d bbs put test.txt

./mongofiles -d bbs get test.txt

./mongofiles -d bbs delete test.txt

./mongofiles -d bbs search test

./mongofiles -d bbs list

GridFS是建立在MongoDB文档规范基础上的轻量级文件存储规范

将大文件分块，每块独立存储

db.fs.chunks.find()

db.fs.files.find()

========================高级指南=================服务端脚本================

db.eval可在MongoDB服务端执行javascript脚本。

db.eval("return 1;")

db.eval("function() {return 1;}")

参数传递：

db.eval("function(u) { print('hello,'+u+'!');}",["user1"])

========================高级指南=================服务端脚本================存储javascript:

system.js保存javascript变量及代码

db.system.js.insert({"_id":"x","value":1})

db.system.js.insert({"_id":"y","value":2})

db.system.js.insert({"_id":"z","value":3})

db.eval中可引用变量：db.eval("function() {return x+y+z;}")

========================高级指南=================服务端脚本================写一个类似log4j的日志函数：

db.system.js.insert({"_id":"log","value": function(msg,level){ var levels=["DEBUG","WARN","ERROR","FATAL"]; level =level?level:0; var now=new Date(); print(now+" "+levels[level]+msg); }})

使用示例：db.eval("x=1;log(' x is '+x);x=2;log(' x is greater than 1',1);")

db.eval("log('refactor log test',2)")

========================高级指南=================服务端脚本================DBRef数据库引用:

DBRef指向一个集合的一个文档引用

类似表关联

{"ref":collection,"$id":id_value,"$db":database}

DBRef不是必须用，通常会引入复杂性让人误解。可有其它方式建立关联。

=======================高级指南=================系统管理高级技巧-系统监控=================

MongoDB持久化配置 ：

持久化配置

journal=true

journalCommitInterval=100

正确关闭MongoDB

./mongod --shutdown或./mongod -f ../etc/mongo.conf --shutdown

不能直接kill进程，否则可能造成库文件损坏

=======================高级指南=================系统管理高级技巧-系统监控=================监控serverStatus

db.runCommand({"serverStatus":1})

参数含义简介：

"globalLock" : {

"totalTime" : NumberLong("511789041000"),--自实例启动全局锁创建以来到现在多长时间，单位微秒.

"lockTime" : NumberLong(105416165),--自全局锁创建以来锁定总时间，单位微秒

"currentQueue" : {

"total" : 0,--等待全局锁的队列中操作数目

"readers" : 0,--等待读锁的队列中操作数目

"writers" : 0--等待写锁的队列中操作数目

},

"activeClients" : {

"total" : 0,--连接到server的当前活动client数目

"readers" : 0, --执行读操作的当前活动client数目

"writers" : 0--执行写操作的当前活动client数目

}

},

"mem" : {

"bits" : 64,--64位机器

"resident" : 31,--占用物理内存量

"virtual" : 20478, --占用的虚拟内存量

"supported" : true, --是否支持扩展内存

"mapped" : 10188, --映射到内存的数据文件大小，很接近于你的所有数据库大小。

"mappedWithJournal" : 20376

},

"connections" : {

"current" : 1,--当前活动连接量。连接到server的当前活跃连接数目

"available" : 19999--剩余空闲连接量。剩余的可用连接数目

},

"backgroundFlushing" : {

"flushes" : 8527, --数据库刷新写到磁盘的次数

"total_ms" : 599904,--数据库刷新数据到磁盘花费的微秒数

"average_ms" : 70.35346546264806,--执行单次刷新花费的平均微秒数

"last_ms" : 51,--最后一次执行完成刷新数据到磁盘花费的微秒数

"last_finished" : ISODate("2012-12-26T00:41:32.013Z")-当最后一次刷新数据完成时的时间戳

},

"cursors" : {

"totalOpen" : 0, --server为client保持的游标（cursor）总数

"clientCursors_size" : 0,

"timedOut" : 0--server启动以来游标（cursor）超时的总数

},

"network" : {

"bytesIn" : 1925,--发送到数据库的数据总量（bytes）

"bytesOut" : 4294,--数据库发出的数据总量（bytes）

"numRequests" : 24--发送到数据库的请求量

},



"opcounters" : {

"insert" : 0, --server启动以来总的insert数据量

"query" : 16646, --server启动以来总的query数据量

"update" : 1,--server启动以来总的update数据量

"delete" : 0, --server启动以来总的delete数据量

"getmore" : 0, --server启动以来调用任何游标的getMore总次数

"command" : 22 --server启动以来执行其他命令的总次数

},

"asserts" : {

"regular" : 0, --server启动以来抛出正规断言（assert 类似于异常处理的形式）总数目

"warning" : 0,--server启动以来抛出的告警总数目

"msg" : 0,--消息断言数目。服务器内部定义的良好字符串错误

"user" : 0, --用户断言数目。用户产生的错误，譬如：磁盘空间满；重复键。

"rollovers" : 0--server启动以来，assert counters have rolled over的次数

},



"writeBacksQueued" : false,--是否有从mongos执行的retry操作

"dur" : {

"commits" : 29,--上一间隔journal日志发生commit的次数

"journaledMB" : 0,--上一间隔写到journal日志的数据量（单位：MB）

"writeToDataFilesMB" : 0,--上一间隔journal日志写到数据文件的数据量（单位：MB）

"compression" : 0,

"commitsInWriteLock" : 0, --写锁期间发生commits的次数

"earlyCommits" : 0,--schedule时间前请求commit的次数

"timeMs" : {

"dt" : 3004,

"prepLogBuffer" : 0,--准备写journal日志花费的时间

"writeToJournal" : 0,--写journal日志花费的实际时间

"writeToDataFiles" : 0,--journal日志后写数据文件花费的时间

"remapPrivateView" : 0

}

},

=======================高级指南=================系统管理高级技巧-系统监控=================监控mongostat

mongostat是mongdb自带的状态检测工具，在命令行下使用。它会间隔固定时间获取mongodb的当前运行状态，并输出

insert: 一秒内的插入数

query : 一秒内的查询数

update: 一秒内的更新数

delete: 一秒内的删除数

getmore: 查询时游标(cursor)的getmore操作

command: 一秒内执行的命令数

flushes: 一秒内flush的次数

mapped 所有的被mmap的数据量，单位M

vsize 虚拟内存使用量，单位M

res 物理内存使用量，单位M

faults/s 每秒访问失败数(只有Linux有)，数据被交换出物理内存，放到swap。不要超过100，否则就是机器内存太小，造成频繁swap写入。此时要升级内存或者扩展

locked % 被锁的时间百分比，不要太大

idx miss: 索引不命中所占百分比。如果太高的话就要考虑索引是不是少了

qr|qw:客户端查询等待数

ar|aw:客户端文档读写等待数，都为0的话表示mongo毫无压力。高并发时，一般队列值会升高

netIn|netOut:网络带宽压力

conn 当前连接数

time 时间戳

=======================高级指南=================系统管理高级技巧-系统监控=================MongoDB安全

默认没有设置安全认证

增加root用户：

use admin

db.addUser("root","rootabc")

给自定义库增加用户:

use bbs

db.addUser("readwrite","rw")

db.addUser("read","readabc")

增加配置项auth=true,打开库安全认证

db.auth("root","rootabc")

用户存放在数据库的system.users集合中。

use test

db.auth("read","readabc")

=======================高级指南=================系统管理高级技巧-系统监控=================备份恢复

mongodump -h dbhost -d dbname -o dbdirectory -- 数据库备份

mongorestore -h dbhost -d dbname --directoryperdb dbdirectory -- 数据库恢复

可在线实时备份

提取快照方法：db.runCommand({"fsync":1,"lock":1})

fsync强制所有缓冲区写入磁盘

备份完后解锁：db.fsyncUnlock()

缺点：耽误读写操作

=======================高级指南=================系统管理高级技巧-系统监控=================数据库修复

mongod --repair启数据库修复

或db.repairDatabase()

修复原理：将所有文档导出并马上导入，忽略无效文档，然后重建索引

修复会化点时间

=======================高级指南=================复制功能=================

复制优点

数据备份

数据恢复

读写分离

主、从节点建立:

建立启动主节点：./mongod -f ../etc/mongo.conf --master，注意--master表示主节点，可跟--port表明启动端口

建立从节点: mkdir /data/slave,启动从节点: ./mongod --dbpath /data/slave --port 10001 --slave --source localhost:27017,

注意端口必须与主节点不同，--source指明主节点

ps：一个主节点挂载从节点不超过12个

复制管理

打印主从复制集群情况：

主节点上

db.printReplicationInfo()

configured oplog size日志大小

oplog first event time日志什么时候开始记录

oplog last event time日志最后一条记录时间

从节点上

source 主节点地址

syncedTo 最后一次同步时间

日志大小调节

./mongod -f 启动配置文件路径 --oplogSize(log大小调节参数) xxxxx（值）

=======================高级指南================MongoDB数据文件内部结构=================



MongoDB数据文件内部结构

MongoDB在数据存储上按命名空间来划分，一个Collection是一个命名空间，一个索引也是一个命名空间。

同一个命名空间的数据被分成很多个Extent，Extent之间使用双向链表连接。

在每一个Extent中，保存了具体每一行的数据，这些数据也是通过双向链接来连接的。

每一行数据存储空间不仅包括数据占用空间，还可能包含一部分附加空间，这使得在数据Update变大后可以不移动位置。

索引以BTree结构实现

=======================高级指南================副本集数据同步机制=================



红色箭头表示写操作可以写到Primary上，然后异步同步到多个Secondary上。

蓝色箭头表示读操作可以从Primary或Secondary任意一个中读取。

各个Primary与Secondary之间一直保持心跳同步检测，用于判断Replica Sets的状态

=======================高级指南=================副本集=================

概念：

副本集是具有故障恢复功能的主从集群

与主从集群区别：副本集没有固定主节点

本质上是很牛X的具有HA功能的主从集群

副本集创建：

为副本集取名 (jm)

./mongod --dbpath /data/db1 --port 1111 --replSet jm

./mongod --dbpath /data/db1 --port 2222 --replSet jm

./mongod --dbpath /data/db1 --port 3333 --replSet jm

--replSet参数，创建副本集中一个节点

创建启动副本集中第二个节点

副本集初始化，初始化命令只能执行一次

config_jm={"_id":"jm",members:[{_id:0,host:"192.168.154.133:1111"},{_id:1,host:"192.168.154.143:2222"},{_id:2,host:"192.168.154.153:3333"}]}

rs.initiate(config_jm)

查看副本集状态：

rs.status()

db.isMaster()

副本集故障恢复：

副本集任何时间只有一个活跃节点

投票机制决定谁成为活跃节点,优先级最高、数据最新的节点获胜

节点类型：

standard：这种是常规节点，他存储一份完整的数据库副本，参与选举投票，有可能成为活动节点

passive：存储一份完整的数据库副本，参与选举投票，不能成为活动节点

arbiter：仲裁者只参与投票，不接收复制的数据，也不能成为活动节点

ps：注意一点：副本至少3个，因为2个的话有一个挂了另外一个不能投票了! 剩下一个会一直是secondary

=======================高级指南=================分片=================

概念：

分片是指将数据拆分，将其分散到不同机器上的过程

mongodb支持自动分片

何时分片：磁盘不够用了、单个mongd不能满足写数据性能要求、想将大量数据放在内存中提高性能

片键指从集合中挑选一个键，该键值做为数据拆分的依据

创建分片步骤：

选择合适的片键（eg：username）

1 ：建立mongodb启动配置mongo.conf文件

logpath=../log/mongodb.log

dbpath=/home/tom/data/dbfp

logappend=false

cpu=false

journal=true

journalCommitInterval=100

rest=true

fork=true

auth=false

2 ：启动mongodb

./mongod -f ../etc/mongo1.conf --port 27017

./mongod -f ../etc/mongo2.conf --port 27018

3 : 启动配置服务器

./mongod -f ../etc/mongoconf.conf --port 20000

4 ： 启动mongos

./mongos --port 30000 --configdb 配置服务器IP:20000

5 ： 配置分片节点

./mongo mongos服务器IP:30000/admin

db.runCommand({addshard:"分片服务器1:27017",allowLocal:true})

db.runCommand({addshard:"分片服务器2:27018",allowLocal:true})

6 ： 启动分片

db.runCommand({"enablesharding":"jmtest"})

7 ： 在指定列上建立片键

db.runCommand({"shardcollection":"jmtest.account","key":{"userName",1}}) 1表示升序

db.jmtest.getIndexs() 查看索引

8 ： 查看各分片状态

登录mongos服务器

./mongo mongos服务器IP:30000/admin

db.printShardingStatus()

以上操作都会保存到配置服务器里面

生产配置：

三个配置服务器

多个mongos服务器

每个片都是副本集

生产环境应建立3个配置服务器

关于分片的其他操作如：删除，请查阅另一篇文章：http://blog.csdn.net/johnstrive/article/details/24690805

=======================高级指南=================分片机制=================



MongoDB的分片是指定一个分片key来进行，数据按范围分成不同的chunk，每个chunk的大小有限制。

有多个分片节点保存这些chunk，每个节点保存一部分的chunk。

每一个分片节点都是一个Replica Sets，这样保证数据的安全性。

当一个chunk超过其限制的最大体积时，会分裂成两个小的chunk。

当chunk在分片节点中分布不均衡时，会引发chunk迁移操作。



客户端访问路由节点mongos来进行数据读写。

config服务器保存了两个映射关系，一个是key值的区间对应哪一个chunk的映射关系，另一个是chunk存在哪一个分片节点的映射关系。

路由节点通过config服务器获取数据信息，通过这些信息，找到真正存放数据的分片节点进行对应操作。

路由节点还会在写操作时判断当前chunk是否超出限定大小。如果超出，就分列成两个chunk。

对于按分片key进行的查询和update操作来说，路由节点会查到具体的chunk然后再进行相关的工作。

对于不按分片key进行的查询和update操作来说，mongos会对所有下属节点发送请求然后再对返回结果进行合并。