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

关注

原创最新推荐文章于 2026-10-01 15:09:45 发布 4.5k 阅读 AI 写同款· GEO 优化 ›

MongoDB find getmore操作慢问题排查本文介绍一次帮助业务排查线上查询操作慢的问题的详细过程以及解决方法。阅读详情

./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.youkuaiyun.com/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会对所有下属节点发送请求然后再对返回结果进行合并。

收录于