MongoDB

发表于 | 分类于 | | 本文总阅读量 次
字数统计: 5.5k | 阅读时长 ≈ 24

MongoDB

介绍

官方站点

MongoDB：适用海量存储，基于文档数据库，C++编写，开源产品，遵循GNU AGPL，支持OSX，Linux，Windows，Solaris。

MongoDB：适用于web站点，cacheing，高大数据量，高扩展场景，事物要求性不高的场景。

MongoDB面向集合的数据库 ：

数据库：但数据库无须创建

集合：无须事先定义，一个文档相当于mysql中的一行，集合相当于多个文档组成的，mongodb中集合是基本的操作单位

特点:

文档存储：利用json组织数据

性能好：c++，多索引支持，不支持事物（支持原子事务），基于内存（延迟写）

支持复制：类似mysql主从复制replication(废弃) 副本集复制auto-sharding

自动分片机制

支持map/reduce.可以实现并行查询处理

分布式文件系统

支持基于位置索引(空间)

商业支持，很多公司使用mongodb

MongoDB可以文档嵌套,KEY/VALUE存储，存储格式JSON，实例

1
2
3
4
5
6
7
8
9
10
{ 
	Name:tomcat 
	Age:18 
	Gender:male 
	Books:{ 
		first:linux 
		second:python 
	} 
	Birthday:1990
}
Mongodb架构
1
2
3
4
C/S架构：
mongod    server端 
mongo     client端 
mongo>use tested 创建testdb数据库

MongoDB安装

配置yum源码
1
2
3
4
5
6
vi /etc/yum.repos.d/mongodb.repo 
[mongodb] 
name=MongoDB Repository 
baseurl=http://downloads-distro.[mongodb.org/repo/redhat/os/x86_64/](http://mongodb.org/repo/redhat/os/x86_64/) 
gpgcheck=0 
enabled=1
查询MongoDB软件包
1
2
3
4
5
yum search mongod* 
mongodb-org-mongos    mongodb shareding 
mongodb-org-server    mongodb服务端 
mongodb-org-shell     mongod客户端 
mongodb-org-tools     mongodb工具
安装mongodb
1
yum install mongodb
添加权限
1
2
useradd mongod
chown -R mongod.mongod /data/mongo
启动mongodb
1
2
3
4
server mongod start 

或者:
mongod -config /etc/mongod.conf

如果想访问mongod监控端口需要启动端口27017，28017(需要开启httpinterface)
访问 http://192.168.2.21:27017 监控端口，显示mongodb信息

Mongod客户端

mongo [option][db address] [file name]

mongo 默认连接127.0.0.1:27017 默认没有用户密码认证

例子：

1
2
3
4
5
6
7
8
9
mongo 192.168.2.21 
MongoDB shell version: 2.6.12 
connecting to: 192.168.2.21/test 
Welcome to the MongoDB shell. 
For interactive help, type "help". 
For more comprehensive documentation, see 
<http://docs.mongodb.org/>
Questions? Try the support group 
<http://groups.google.com/group/mongodb-user>
MongoDB常用命令
1
2
3
4
5
mongodb常用的命令
mongodump        mongodb备份
mongorestore     mongodb恢复
mongoexport      mongodb导出
mongoimport      mongodb导入

MongoDB配置文件

mongodb配置文件在/etc/mongod.conf下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
more /etc/mongod.conf
logpath=/var/log/mongodb/mongod.log        #mongodb日志路径 
logappend=true                             #是否以追加方式存储日志 
fork=true
port=27017                                 #默认端口2701 
dbpath=/data/mongo                         #mongodb数据存储目录                
pidfilepath=/var/run/mongodb/mongod.pid    #mongodb pid文件 
bind_ip=127.0.0.1                          #绑定地址 
# Disables write-ahead journaling 
# nojournal=true 
# Enables periodic logging of CPU utilization and I/O wait 
# cpu=true 
# Turn on/off security.  Off is currently the default 
# noauth=true 
# auth=true 
# Verbose logging output. 
# verbose=true 
# Inspect all client data for validity on receipt (useful for 
# developing drivers) 
# objcheck=true 
# Enable db quota management 
# quota=true 
# Set oplogging level where n is 
#   0=off (default) 
#   1=W 
#   2=R 
#   3=both 
#   7=W+some reads 
# diaglog=0 
# Ignore query hints 
# nohints=true 
httpinterface=true                     #是否启用http监控接口，端口是28017 
# noscripting=true 
# notablescan=true 
# noprealloc=true 
# nssize=<size> 
# replSet=setname                       #mongod 副本集名称 
# oplogSize=1024                        #oplog大小 
# keyFile=/path/to/keyfile

MongoDB 使用

MongoDB基本使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
mongo 192.168.2.21
>help
db.help()                    db方法 帮助
db.mycoll.help()             集合方法 帮助
sh.help()                    sharding 帮助
rs.help()                    复制集 帮助
help admin                   administrative help
help connect                 connecting to a db help
help keys                    key shortcuts
help misc                    misc things to know
help mr                      mapreduce
show dbs                     查看数据库名
show collections             查看集合名词
show users                   show users in current database
show profile                 show most recent system.profile entries with time >= 1ms
show logs                    show the accessible logger names
show log [name]              prints out the last segment of log in memory, 'global' is default
use <db_name>                设置使用数据库
db.foo.find()                list objects in collection foo
db.foo.find( { a : 1 } )     list objects in foo where a == 1
it                           result of the last line evaluated; use to further iterate
DBQuery.shellBatchSize = x   set default number of items to display on shell


>use study                                #无须创建，直接使用数据库
>db.studycoll.insert({name:"zhuxy"})      #创建studycoll集合插入数据
>db.zhuxy.insert({name:"zhuyue"})         #创建zhuxy集合插入数据

>show collections                         #查看collections
studycoll
zhuxy
system.indexes

>db.getCollectionNames()                  #以列表方式查看collection
[ "studycoll", "system.indexes", "zhuxy" ]

>show dbs
admin  (empty)
local  0.078GB
study  0.078GB
test   (empty)

>db.studycoll.find()                                            #在studycoll集合中查询数据
{ "_id" : ObjectId("5981309eceaab5cdd6507bb9"), "name" : "zhuxy" }
#说明(id,对象id号(唯一的，如果添加逐步+1)

>db.studycoll.insert({name:"yukw',age:19,books:[211,'NJAU']})	#studycoll集合插入数据
WriteResult({ "nInserted" : 1 })

>db.studycoll.find().count()            #查找统计
2

>db.studycoll.stats()                   #查看状态
{
	"ns" : "study.studycoll",
	"count" : 4,
	"size" : 192,
	"avgObjSize" : 48,
    "storageSize" : 8192,
    "numExtents" : 1,
    "nindexes" : 1,
    "lastExtentSize" : 8192,
    "paddingFactor" : 1,
    "systemFlags" : 1,
    "userFlags" : 1,
    "totalIndexSize" : 8176,
    "indexSizes" : {
    "_id_" : 8176
},
"ok" : 1

>db.studycoll.drop()                    #删除studycoll集合
true

>show collections                       #查看集合
system.indexs

>show dbs                               #虽然删除studycoll集合，但是数据库study依然存在
admin  (empty)
local  0.078GB
study  0.078GB
test   (empty)
MySQL和MongoDB语法比较
INSERT插入
1
2
3
mysql>insert into studycoll(name, age,status) value ('zhuxy','19','A')

mongodb>db.studycoll.insert({name:'zhuxy',age:19,status:'A'})
SORT排序
1
2
3
4
mysql>select * from studycoll where age > 18

mongodb>db.studycoll.find({age:{$gt:18}}).sort({age:1})
#查询age大于18的数据，并排序(从小到大，如果-1从大到小),显示所有字段
SELECT查询
1
2
3
4
mysql>select name, gender from studycoll where age > 18 limit 5

mongodb>db.studycoll.find({age:{$gt:18}},{name:1,gender:1}).limit(5)
#显示name和gender并且年龄大约18
UPDATE更新
1
2
3
4
mysql>update studycoll set status='A' WHERE age > 18 

mongodb>db.studycoll.update({age:{$gt:18}},{$set:{gender:'body'}},{multi:true})
#如果multi不实true，只修改第一个符合条件的
DELETE删除
1
2
3
mysql>delete from studycoll where status='D' 

mongodb>db.studycoll.remove({status:'D'})
AND方法
1
2
3
4
5
mysql>select * from studycoll age > 70 and age < 75 
mysql>select name,gender from studycoll age > 70 and age < 75

mongodb>db.studycoll.find({$and:[{age:{$gt:70}},{age:{$lt:75}}]}) 
mongodb>db.studycoll.find({$and:[{age:{$gt:79}},{age:{$lt:75}]},{name:1,gender:1})
关系型数据库和MongoD
RDBMS Mongo
table.view collection
row Json Document
index index
join embedded
partition shard
partition key(分区键) shard key(分片键)

MongoDB高级操作

批量插入
1
2
3
mongodb>for(i=1;i<=100;i++) db.studycoll.insert({name:"User"+i,age:i,gender:"M",books:['linux','python']})    
mongodb>db.studycoll.find()
#只能显示20，如果像继续显示输入it
find

mongodb查询操作支持挑选机制，comparison，logical，element，javascript等几类

comparison比较运算符
1
2
3
4
5
6
7
$gt     大于{filed:{$gt:value}} 
$gte    大于等于 
$in     挑选指定字段位于指定数组{filed:{<value1>,<values2>}} 
$lt     小于 
$lte    小于等于 
$ne     不等于 
$nin    挑选指定字段的值不位于指定数组
logical逻辑运算符
1
2
3
4
$or     或{$or:[{<expression1>},{<expression2>}]} 
$and    与{$and:[{<expression1>},{<expression2>}]} 
$not    非{filed:{$not:{<operator>}}} 
$nor    反{$nor:[{<expression1>},{<expression2>}]}
element元素查询
1
2
3
4
5
$exists		#根据指定字段存在性挑选文档，语法格式{filed:{$exists:<boolean>}},指定<boolean>的值为true，则返回存在指定字段的文档，false则返回不存在指定字段的文档 

$mod		#将指定字段的值进行取模运算，并返回其余数为指定值的文档,语法{filed:{$mod:[divisor,remainder]}} 

$type		#返回指定字段的值类型为指定类型的文档，语法{filed:{$type:<BSON tye>}}    int,str...
exists

用法查询有address字段的文档

1
2
3
4
5
6
7
mongodb>db.studycoll.find({address:{$exists:true}}) 

mongodb>db.studycoll.find({$and:[{age:{$gt:80}},{address:{$exists:false}}]}) 
#查询age大于80，并且没有address字段

mongodb>db.studycoll.update({age:{$gt:70}},{$set:{gender:'F'}},{multi:true})
#将age大于70，性别改成F
update

update参数使用格式独特，其仅能包含使用update专有操作符来构建表示式，其中大致包含‘filed’,’array’,’bitwise’

filed类常用操作

1
2
3
4
5
6
7
$inc     #增大指定字段,格式{field:value},{$inc:{field1:amount}},其中{field"value}用于指定挑选标准，{$inc:{filed:amunt}}指定要提升其字段及提升大小amount 

$rename  #更改字段名,格式{$rename:{<old name1>:<new name1>,<old name2>:<new name2>}}       

$set     #修改字段值为新指定值,格式{field:value1},{$set:{filed1:value1}} 

$unset   #删除指定字段,格式{filed:value},{$unset:{filed1:""}}
总结
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1，mongodb常用方法CRUD 
db.COLL_NAME.METHOD 
C:insert() 
R:find() 
U:update() 
D:remove() 

2，用JSON格式文档:{key:value,key:value} 
insert({}) 
find({},{}). 
	limit() 
	sort() 
	count() 
	skip() 

update({},{},{},{multi:true}) 
remove({}) 

3,删除collection 
db.collName.drop 

4,删除database 
use databasename 
db.dropDatabase() 

mysql 
database-->table-->row 

mongodb 
database-->collection-->document

索引

假设从一百万条数据，在关系型数据库中，找到一个数值改怎么办？难道全表扫描？

推荐读:“关系型数据库索引设计与优化”

这本书介绍如何设计索引：(索引也会带来坏处)，数据库使用索引，保存的索引文件占用资源，如果数据被修改，索引也应该需要修改，降低写入性能，有利必有弊。

需要根据现有的环境来确定是否使用索引：

如果数据量小，无需索引，如果创建索引反而变慢

如果数据量多，需要根据查询的条件来决定是否创建 简单索引 或者 组合索引

如果数据量海量，创建索引没有意义

索引是什么

在关系型数据库中，索引是一种单独的，物理的对数据库表中一列或多列的值进行排序的一种存储结构，是某个表中一列或者若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单

作用相当于图书目录，可根据目录中的页码快速找到所需内容

索引优点

1，减少服务器需要扫描的数据量

2，索引可以帮助服务器避免排序或者使用临时表

3，可以将随机i/o转化成顺序i/o

索引级别

1星：索引如果能将相关的记录放置在一起，降低I/O，入门级别

2星：索引中数据的存储顺序与查找标准中顺序一致。

3星：如果索引中保护查询中所需要的全部数据，(覆盖索引)。

索引类别：

顺序索引

散列索引:将索引映射至散列桶上，映射是通过散列函数进行的

评估索引标准：

访问类型：范围查找用顺序索引，等值查找用散列

访问时长

插入时长

删除时长

空间开销

顺序索引

聚集索引。如果某记录文件中的记录顺序是按照对应的搜索码指定的顺序排序，聚集索引也叫主索引。不需要二次i/o，找到键就找到行了。

非聚集索引。搜索码中的指定次序与记录文件中的记录次序不一致，叫非聚集索引，需要找到键，在寻找指针指定的行。

有聚集索引的数据文件，也叫做索引的顺序文件。

根据索引中是否为每个记录相应的创建索引项：稠密索引 和 稀疏索引

多级索引:

一级索引指向二级索引，二级索引指向行

辅助索引必须是稠密索引

B+树索引:

Balance Tree:平衡树索引

MYISAM是非聚集索引

InnoDB是聚集索引(数据文件和索引文件在一个文件中)

顺序索引的特性：

全值匹配：Name=”user12”

匹配最左前缀：Name like “User1%”, 无效：Name LIKE “%User1%”

匹配列前缀：Name like “User1%”, 无效：Name LIKE “%User1%”

匹配范围值：

精确匹配某一列并范围匹配另一列

只访问索引的查询：覆盖查询

组合索引特性：

如果索引是这样的(Name,Age), 那么Age > 80无效，最左查找的;

如果Age>80 and Name = “user12”有效

散列索引：

不适合范围查询，适合精确值查询

散列函数

分布要随机

分布要均匀

适用场景：

​ 精确匹配： =,IN(),<=>

MySQL索引

只有MyISAM存储引擎支持，可以借助sphinx,lucense实现

空间索引，必须使用空间索引函数获取相应的查询结果，MyISAM支持

主键（值不能相同，也不能为空）

唯一键（值不能相同，可以为空）

mysql创建索引
1
2
3
4
5
创建索引：CREATE INDEX index_name ON table (col1,...)
添加索引：ALTER TABLE ADD INDEX 
删除索引：ALTER TABLE DROP INDEX
        DROP INDEX index_name FROM TABLE
查看索引：SHOW INDEXS FROM TABLE
MongoDB支持的索引

简单索引

组合索引

多键索引

空间索引

全文索引

哈希索引

MongoDB索引操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
db.studycoll.find({name:"User49"}).explain()
#explain()语法说明,如果没创建索引会全表扫描

db.studycoll.ensureIndex({name:1})
#创建name索引

db.studycoll.find({name:'User49'}).explain()
#再次查看不会全表扫描了

db.studycoll.find({name:'user49'}).hint({name:1}).explain()
#指定什么索引查询

db.studycoll.ensureIndex({name:1,age:1},{unique:true})
#创建组合索引name和age. 1表示升序排序，-1表示降序排序

db.studycoll.ensureIndex({name:1},{background:true})
#background:true表示后台执行索引(如果数据量大的情况下使用该选项)

db.studycoll.getIndexes()
{
"v" : 1,
"unique" : true,
"key" : {
    "name" : 1,
    "age" : 1
},
    "name" : "name_1_age_1",
    "ns" : "study.studycoll"
}

MongoDB复制

mongodb复制架构

早期mongodb使用类似mysql复制功能，但是发现主不能故障转移

Replica Set复制集(副本集)，类似mysql复制功能，可实现故障转移功能

mongodb官方不建议使用主从方式

Replication Options

副本集相关选项：

replSet #指定副本集名称

oplogsize #操作日志大小，在64位系统下，默认是可用磁盘空间的5%，如果mongodb初始化后，后期修改oplog是不生效的

fastsync #快速同步，类似后台复制

replIndexPrefetch #mongodb2.2才能实现，指定副本集的索引预取，可以让复制过程更为高效

​ replIndexPrefetch {none | _id_only | all} non 不预取任何索引，_id_only预取id索引，all预取所有索引

副本集架构时间要同步，replset名称一致，确保mongodb能交互

部署配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
环境：
192.168.2.10    主
192.168.2.11    从
192.168.2.12    从
三台需要时间同步，需要安装mongod,配置文件需要添加

#vi /etc/mongod.conf
bind_ip = 192.168.2.10 #监听端口，每个服务器绑定自己的ip
replSet = MyRs0        #三台保持一致,副本名称

启动mongod群集，三台都需要启动
192.168.2.10
>rs.help()
>rs.initiate()       #初始化rs
{
"info2" : "no configuration explicitly specified -- making one",
"me" : "192.168.2.10:27017",
"info" : "Config now saved locally.  Should come online in about a minute.",
"ok" : 1
}
MyRs0:PRIMARY>rs.status()                     #查看rs状态
MyRs0:PRIMARY>rs.isMaster()                   #查看是否是主节点
MyRs0:PRIMARY>rs.add("192.168.2.11:27017")    #添加2.11节点
MyRs0:PRIMARY>rs.add("192.168.2.12:27017")    #添加2.12节点

添加从节点后，开始插入数据，只有PRIMARY可以添加数据
MyRs0:PRIMARY>use study
MyRs0:PRIMARY>for(i=1;i<1000;i++) db.studycoll.insert({name:'user'+i,age:i,gender:'F'})

192.168.2.11    注意从节点不可写
MyRs0:SECONDARY>rs.isMaster()        #在从节点查看主从信息
 {
    "setName" : "MyRs0",
    "setVersion" : 3,
    "ismaster" : false,                    #是否是主节点
    "secondary" : true,                    #是否是从节点
    "hosts" : [
    "192.168.2.10:27017",
    "192.168.2.11:27017",
    "192.168.2.12:27017"
],
    "primary" : "192.168.2.10:27017",       #主节点地址
    "me" : "192.168.2.11:27017",            #从节点本身
    "maxBsonObjectSize" : 16777216,
    "maxMessageSizeBytes" : 48000000,
    "maxWriteBatchSize" : 1000,
    "localTime" : ISODate("2017-08-04T06:26:25.430Z"),
    "maxWireVersion" : 2,
    "minWireVersion" : 0,
    "ok" : 1
}

MyRs0:SECONDARY> rs.slaveOk()               #如果从需要访问数据，需要输入rs.slaveOk()
MyRs0:SECONDARY> use study
MyRs0:SECONDARY> db.studycoll.find().count()
MyRs0:SECONDARY> db.studycoll.insert({name:"hello"})    #这里从不可以写
WriteResult({ "writeError" : { "code" : undefined, "errmsg" : "not master" } })


注意：
如果192.168.2.10下线，这里会自动选举PRIMARY,
如果192.168.2.10上线，不会将其转变成PRIMARY, 上线后变成SECONDARY，需要rs.slaveOk()才可以读取数据

如果需要将192.168.2.10下线后，再次上线自动提升PRIMARY需要修改优先级
需要在PRIMARY修改配置文件
MyRs0:PRIMARY>mycnf = rs.conf()                #rs.conf是配置主从的配置文件，mycnf是自定义配置文件
    {
        "_id" : "testrs0",
        "version" : 3,
        "members" : [
            {
                "_id" : 0,
                "host" : "192.168.2.21:27017"
            },
            {
                "_id" : 1,
                "host" : "192.168.2.23:27017"
            },
            {
                "_id" : 2,
                "host" : "192.168.2.25:27017"
            }
       ]
    }
MyRs0:PRIMARY>mycnf.members[0].priority=2        #members指定_id号码，priority是优先级
MyRs0:PRIMARY>rs.reconfig(mycnf)                 #重现加载自定义配置文件mycnf
MyRs0:PRIMARY>rs.conf()                          #查看配置文件

Mongod Sharding

mongod副本集 不能降低I/O的请求，只是把数据复制一份到另外一台机器，考虑到后期高并发高吞吐量场景或者数据大于物理磁盘的时候，就需要使用sharding分片

shareding只是将大数据切割成小数据分散至其他机器上。降低i/o压力

Sharding目的：

数据系统巨大和高吞吐量高

高并发的查询会耗尽cpu的资源

sharding可以降低单台服务器的I/O压力

Sharding架构

router 跟config server通讯(router可以有一个，可以有多个)

config server 存储元数据(分区键)，在生产环节中建议使用三个config server，一个单点故障，两个不方便选举

share 数据

注意事项：

做sharding对写操作最好做到分散,降低写压力, 对读操作最好不要做到分散,才能降低i/o压力

所以最好做到，写尽可能离散，读尽可能不离散。选择一个合理的分区键(通常使用组合键进行切割)。

环境部署
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
环境说明：
router(mongos) 1个    192.168.2.10 
config server  1个    192.168.2.11 
shard          2个    192.168.2.12:27017 / 192.168.2.12:27018
(需要注释httpinterface,因为这里只是用做测试) 

1、配置config server
192.168.2.11
默认监听端口27019端口，可以使用如下命令启动mongod进程
#mongod --configsvr --dbpath <path> --port <port>

也可以编辑配置文件
#vi /etc/mongod.conf
dbpath = /data/mongo
configsvr = true

启动mongod后使用的端口是27019
#mongod -f /etc/mongod.conf

2、配置mongos实例
192.168.2.10
mongos属于轻量级应用，完全可以与其他服务运行同一节点，启动时，需要为mongos实例指明各config服务器访问地址
默认情况下，mongos监听27017端口，可以使用如下命令启动mongos实例
#mongos --configdb <config server hostnames((ip|hostname):port)>

也可以直接编辑配置文件
#vi /etc/mongod.conf
#dbpath = /data/mongo    #需要注释该选项，这里只是用到mongos
configdb = 192.168.2.11:27019

启动mongos, 使用27017
#mongos -f /etc/mongod.conf


3、配置各副本集或独立的mongod实例
配置192.168.2.12:27017
    192.168.2.12:27018


4、向分区集群中添加各shard服务器或副本集
192.168.2.11
mongo -host 192.168.2.11

4.1、添加方式
使用mongo命令连入mongos实例，命令如下
#mongo --host <hostname of machine running mongos> --port <port mongos listens on>
>sh.addShard()     #方法添加各shard至群集中

如果添加shard是副本集，则需要使用
>sh.addShard("RS_NAME/RS_SERVER:PORT")
    >sh.addShard("MyRS/192.168.2.10:27017")

如果添加shard是独立的mongod实例，则需要使用
>sh.addShard("RS_SERVER:PORT")
    >sh.addShard("192.168.2.12:27017")
    >sh.addShard("192.168.2.12:27018")

>sh.status()                                                     #查看状态
>sh.enableSharding('database')                                   #sharding那个数据库
>sh.sharedCollection('database.collection',{filed:1,filed1:1})   #sharding那个集合,集合的索引是那个字段
>sh.status()
>for(i=1;i<=100000;i++) db.collection.insert                     #批量插入数据
({name:'user'+i,age:(i%150),address:i+"#"+"nanjing",book:['linux','python']})

>sh.help()                                                        #查看shared的帮助命令
>sh.setBalancerState()                                            #设置均衡
>h.getBalancerState()                                             #查看是否是均衡状态

总结

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
重复索引：
    避免重复索引选择合适的索引，比如一个表有"name,age,gender,address"，那么通常查询name和age，则可以使用组合索引name和age，不要只创建name索引在创建一个age索引

覆盖索引:
    name,age  能在索引中直接查到数据的叫覆盖索引。


查看有没有用索引
mongod>db.mycoll.find().hint().explain()    #hint()指明什么索引，explain()分析查找
    
mysql>explain select * from tables;


通常mongod所需要做的工作
#复制集群
    master/slave
    replica /set
        arbiter:仅参与选举，不持有数据，
        0优先级节点：持有数据，参与选举，单不能成为主节点，
        
        Replica/set群集需要注意
        配置文件replSet=RsName
        初始化，添加节点。
        
#sharding分片
	目的:单个节点数据集太大
    	如果单个节点读写请求，并发请求量较大
    
    读，写
        读，不离散
        写，离散

mongodb，collection级别
sharding key；colletion索引

选择sharding key需要考虑的标准
    应该在哪存数据？
    应该在哪得到希望的数据？
    
基本法则
    sharding key应该是主键
    sharding key应该能尽量保证跨分片查询
    
chunk：64m    越小越容易迁移

rebalance：重新均衡

sharding:新增shard，移除shard

mongodb常用的命令
mongodump        mongodb备份
mongorestore     mongodb恢复
mongoexport      mongodb导出
mongoimport      mongodb导入

mongodb的监控信息
mongostat\mongotop
insert  query update delete getmore command  vsize    res faults  netIn netOut  conn repl       time
vsize虚拟内存
res实际内存集
                                             
mongooplog mongodb的日志
mongoperf性能评估
mongofiles修改GridFS文件系统
看完了?赏个鸡腿钱,谢谢老板!