数据php
程序: 指令+数据html
关系型mysql
非关系型linux
https://db-engines.com/en/rankingweb
NoSQL是什么？算法
NoSQL=Not Only SQLsql
1998年Carlo Strozzi首次提出（不提供SQL功能的关系型数据库）mongodb
2009年Eric Evans再次提出NoSQL概念shell
NoSQL、Relational Database相铺相成数据库
NoSQL数据库四你们族：
列存储：Hbase
键值(Key-Value)存储：Redis
图像存储：Neo4J
文档存储:MongoDB
RDBMS即关系数据库管理系统(Relational Database Management System)，是将数据组织成相关的行和列的系统，而管理关系数据库的计算机软件就是关系数据库管理系统，经常使用软件有Oracle、SQL Server等
高可扩展性
横向扩展 也叫 水平扩展，用更多的节点支撑更大量的请求。 如成千上万的蚂蚁完成一项搬运工做
纵向扩展 又叫 垂直扩展，扩展一个点的能力支撑更大的请求。如利用1我的的能力，如蜘蛛侠逼停火车
分布式计算
没有复杂的关系
低成本
架构灵活
半结构化数据
开源
MongoDB是有开源产品的
On GitHub
Licensed under the AGPL
起源& 赞助by MongoDB公司
提供商业版licenses 许可
MongoDB与RDBMS最大的区别在于：没有固定的行列组织数据结构
RDBMS MongoDB
table,view表格,视图 collection 集合
row 行 document 文档
index 索引 index
join 加入,链接,接合点 embedded document嵌套文档
foreign key 外键 reference 参考,引用
partition 拆分,分区 shard分片 .
有外向里: 数据库à集合à文档
层次关系:
--文档(document)
--集合(collection)
--数据库(database)
层次关系图:
文档型
--JSON
MongoDB 使用JSON（JavaScript ObjectNotation）文档存储记录。
JSON数据库语句能够容易被解析
Web 应用大量使用
NAME-VALUE 配对，例如：
{
product: “car”,
brand: “Benz”,
color: “blue” }
--BSON
二进制的JSON，JSON文档的二进制编码存储格式. 弱点是最大存取单元不能够超过16M
BSON有JSON没有的Date和BinData
MongoDB中document以BSON形式存放
> db.meeting.insert({meeting:"SHOUG June",Date:"2015-06-15"});
--灵活的数据格式
灵活归灵活. 可是要符合应用逻辑规则
跨平台
--Linux、Unix、Mac、Windows
--总体架构相同
MongoDB Server
--实例、数据库及其对应关系
数据逻辑结构
--文档、集合、数据库
数据存储
--元数据、实际数据
网站数据
缓存
大尺寸、低价值的数据
高伸缩性的场景
用于对象及JSON数据的存储
下载地址：
文档地址：
docs.mongodb.com
mongoing.com ##中文社区
版本支持平台表
https://docs.mongodb.com/manual/installation/
http://www.mongoing.com/docs/installation.html#supported-platforms
mgdb3.2.8安装步骤：
建立所需用户和组
useradd mongodb
passwd mongod
（2）建立mongodb所需目录结构
mkdir -p /mongodb/bin
mkdir -p /mongodb/conf
mkdir -p /mongodb/log
mkdir -p /mongodb/data
（3）上传并解压软件到指定位置
mongodb-linux-x86_64-3.2.8.tgz
cd mongodb-linux-x86_64-3.2.8/bin/
cp * /mongodb/bin
（4）设置目录结构权限
chown -R mongod:mongod /mongodb
（5）设置用户环境变量
su - mongod
vi .bash_profile
export PATH=/mongodb/bin:$PATH
source .bashprofile
（6）启动mongodb
mongod --dbpath=/mongodb/data --logpath=/mongodb/log/mongodb.log --port=27017 --logappend --fork
（7）登陆mongodb
[mongod@server2 ~]$ mongo
MongoDB shell version: 3.2.8
connecting to: test
>
>
（8）使用配置文件
mongod -f /mongodb/config/mongodb.conf
------------
vi /mongodb/config/mongodb.conf
logptah=
dbpath=
port=
logappend=
fork=
auth=
+++++++++++++++++++
（YAML模式：）
--
NOTE：
YAML does not support tab characters for indentation: use spaces instead.
--
systemLog:
destination: file
path: "/mongodb/log/mongod.log"
logAppend: true
storage:
journal:
enabled: true
dbPath: "<PATH>"
processManagement:
fork: true
pidFilePath: <string>
net:
bindIp: <ip>
port: <port>
setParameter:
enableLocalhostAuthBypass: false
security:
authorization: enabled
replication:
oplogSizeMB: <NUM>
replSetName: "<REPSETNAME>"
secondaryIndexPrefetch: "all"
sharding:
clusterRole: <string>
archiveMovedChunks: <boolean>
---for mongos only
replication:
localPingThresholdMs: <int>
sharding:
configDB: <string>
---
.........
++++++++++++++++++++++
（9）mongodb的关闭方式
---kill进程形式
$ kill -2 PID
原理：-2表示向mongod进程发送SIGINT信号。
或
$ kill -4 PID
原理：-4表示向mognod进程发送SIGTERM信号。
---自带模式
admin> db.shutdownServer()
或
admin> db.adminCommand({shutdown:1})
或
$ mongod -f mongodb.conf --shutdown
killing process with pid: 1621
注：mongod进程收到SIGINT信号或者SIGTERM信号，会作一些处理
> 关闭全部打开的链接
> 将内存数据强制刷新到磁盘
> 当前的操做执行完毕
> ...
> 安全中止
！！！切记不可kill -9
> 数据库直接关闭
> 数据丢失
> 数据文件损失
> 修复数据库（成本高，有风险）
（1）redhat或cnetos6.2以上系统
（2）系统开发包完整
（3）ip地址和hosts文件解析正常
（4）iptables防火墙&SElinux关闭
（5）关闭hugepage大页内存机制 https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/
########################################################################
root用户下
在vi /etc/rc.local最后添加以下代码
if test -f /sys/kernel/mm/transparent_hugepage/enabled; then
echo never > /sys/kernel/mm/transparent_hugepage/enabled
fi
if test -f /sys/kernel/mm/transparent_hugepage/defrag; then
echo never > /sys/kernel/mm/transparent_hugepage/defrag
fi
检查一下
[root@wu ~]# cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never
[root@wu ~]# cat /sys/kernel/mm/transparent_hugepage/defrag
[always] madvise never
[root@wu ~]# . /etc/rc.local ###从新加载下 . 或source下文件
[root@wu ~]# cat /sys/kernel/mm/transparent_hugepage/enabled
always madvise [never]
[root@wu ~]# cat /sys/kernel/mm/transparent_hugepage/defrag
always madvise [never]
其余系统关闭参照官方文档：https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/
为何要关闭？
透明大页面（THP）是一种Linux内存管理系统，经过使用更大的内存页面，能够减小具备大量内存的计算机上的Translation Lookaside Buffer（TLB转译后备缓冲区 ）查找的开销。可是，数据库工做负载一般在THP上表现不佳，由于它们每每具备稀疏而不是连续的内存访问模式。您应该在Linux机器上禁用THP以确保使用MongoDB得到最佳性能。
############################################################################
加一块20G的新磁盘备用 ######备选
/dev/sdb ,设置挂载点/mongodb，并将新磁盘挂在到
[root@web01 ~]# mkfs.ext4 /dev/sdb
[root@web01 ~]# mkdir /mongodb
[root@web01 ~]# mount /dev/sdb /mongodb/
[root@web01 ~]# blkid
/dev/sda1: UUID="2c37d13b-6fc4-4ef3-b178-aae2270e3b34" TYPE="ext4"
/dev/sda2: UUID="fcada1c8-bc9f-4a7b-b6d6-c45cc27d0e15" TYPE="swap"
/dev/sda3: UUID="8708eb7e-b0e9-4217-9ee6-920800d2c55f" TYPE="ext4"
/dev/sdb: UUID="07001c98-3ac3-46db-9b13-8463627f3d89" TYPE="ext4"
vi /etc/fstab
UUID=07001c98-3ac3-46db-9b13-8463627f3d89 /mongodb etxt4 defaults 0 0
mount -a
[root@web01 mongodb]# tar -zxvf mongodb-linux-x86_64-3.2.8.tgz
要求，自定义设置用户、组ID
[root@web01 bin]# groupadd -g 801 mongod
[root@web01 bin]# useradd -u 802 -g mongod mongod
[root@web01 bin]# passwd mongod -------》123456
#### 注意：必定要mount以后再作----不挂新磁盘不用管
[root@web01 ~]# mkdir /mongodb/bin
[root@web01 ~]# mkdir /mongodb/data
[root@web01 ~]# mkdir /mongodb/log
[root@web01 ~]# mkdir /mongodb/conf
[root@web01 bin]# pwd
/mongodb/mongodb-linux-x86_64-3.2.8/bin
[root@web01 bin]# cp * /mongodb/bin/
[root@web01 bin]# chown -R mongod:mongod /mongodb/
------------------
[root@web01 ~]# su - mongod
[mongod@web01 ~]$ cd /mongodb/bin/
[mongod@web01 bin]$ ./mongod --logpath=/mongodb/log/mongodb.log --dbpath=/mongodb/data/ --fork --logappend
about to fork child process, waiting until server is ready for connections.
forked process: 1900
child process started successfully, parent exiting
[mongod@web01 ~]$ vi .bash_profile
export PATH=/mongodb/bin:$PATH
[mongod@web01 ~]$ . ./.bash_profile
或者
[mongod@web01 ~]$ source .bash_profile
[mongod@web01 ~]$ vi /mongodb/conf/mongod.conf
[mongod@web01 ~]$ cat /mongodb/conf/mongod.conf
dbpath=/mongodb/data
logpath=/mongodb/log/mongodb.log
logappend=true
fork=true
[mongod@web01 ~]$ mongo
MongoDB shell version: 3.2.8
connecting to: 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
Server has startup warnings:
2018-08-29T17:16:25.133+0800 I CONTROL [initandlisten]
2018-08-29T17:16:25.133+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
>
kill -2 PID
kill -4 PID
---kill进程形式
$ kill -2 PID
原理：-2表示向mongod进程发送SIGINT信号。
或
$ kill -4 PID
原理：-4表示向mognod进程发送SIGTERM信号。
admin> db.shutdownServer()
或
admin> db.adminCommand({shutdown:1})
或
$ mongod -f mongodb.conf --shutdown
---自带模式
admin> db.shutdownServer()
或
admin> db.adminCommand({shutdown:1})
或
$ mongod -f mongodb.conf --shutdown
killing process with pid: 1621
注：mongod进程收到SIGINT信号或者SIGTERM信号，会作一些处理
> 关闭全部打开的链接
> 将内存数据强制刷新到磁盘
> 当前的操做执行完毕
> ...
> 安全中止
> 数据库直接关闭
> 数据丢失
> 数据文件损失
> 修复数据库（成本高，有风险）
####有时上传格式不对 用dos2unix -k 文件名 转换下内容格式 -k --keepdate 保持时间戳一致
能够把脚本放在/etc/init.d/下 加权限执行
#!/bin/bash
#
#chkconfig: 2345 80 90
#description:mongodb
mongo_user=mongodb
MONGODIR=/mongodb
MONGOD=$MONGODIR/bin/mongod
#MONGO=$MONGODIR/bin/mongo
#DBDIR=$MONGODIR/data/data27017
#LOGPATH=$MONGODIR/log/mongodb.log
MONGOCONF=$MONGODIR/conf/mongod.conf
start() {
su - $mongo_user -c "$MONGOD -f $MONGOCONF"
}
stop() {
su - $mongo_user -c "$MONGOD -f $MONGOCONF --shutdown"
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
stop
sleep 2
start
;;
*)
echo $"Usage: $0 {start|stop|restart}"
exit 1
esac
MongoDB数据库默认是没有用户名及密码的，即无权限访问限制。为了方便数据库的管理和安全，需建立数据库用户.
https://www.mongodbmanager.com/
或者用 MongoVUE, 云盘有破解包
su - mongod
mongo
mongo 127.0.0.1:port ### 其余端口
++++++可能会出现的警告，说明大页内存未关闭。
Server has startup warnings:
2017-09-09T11:49:58.483+0800 I CONTROL [initandlisten]
2017-09-09T11:49:58.483+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2017-09-09T11:49:58.484+0800 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2017-09-09T11:49:58.484+0800 I CONTROL [initandlisten]
2017-09-09T11:49:58.484+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2017-09-09T11:49:58.484+0800 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2017-09-09T11:49:58.484+0800 I CONTROL [initandlisten]
++++++
一、db类：当前实例管理
二、rs类： 复制集管理
三、sh类： 分片管理
[db/rs/sh].[关键字]()
db.[collection].xxx
db.log.drop()
show collections
use wordpress
db.[collection].[insert/delete/update/find]
(
)
for(i=0;i<10000;i++){ db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new Date()}); }
建立
$ mongo
use admin
db.createUser(
{
user: "root",
pwd: "root123",
roles: [ { role: "root", db: "admin" } ]
}
)
验证
db.auth('root','root123')
修改配置文件
vim mongod.conf
auth=true
重启mongodb
注意顺序；
不能先改配置文件重启再加用户，必须先建立用户再 改配置文件重启
登陆
[mongod@web01 ~]$ mongo -uroot admin -p
[mongod@web01 ~]$ mongo -uroot -p --authenticationDatabase admin
[mongod@web01 ~]$ mongo
> use admin
switched to db admin
> db.auth('root','root123')
mongo --help
mongo里有命令补全功能, 自动切换大小写字母
http://www.javashuo.com/article/p-kwsyehem-ko.html
help
KEYWORDS.help
KEYWORDS.[TAB]
> help
db.help() help on db methods db方法上的db.help()帮助
db.mycoll.help() help on collection methods 帮助收集方法
sh.help() sharding helpers sh.help()分片帮手
rs.help() replica set helpers 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 database names 显示dbs显示数据库名称
show collections show collections in current database 显示集合显示当前数据库中的集合
show users show users in current database 显示用户显示当前数据库中的用户
show profile show most recent system.profile entries with time >= 1ms显示配置文件显示最新系统。时间>= 1ms的概要条目
show logs show the accessible logger names 显示日志，显示可访问的日志记录器名称
show log [name] prints out the last segment of log in memory, 'global' is default 显示log [name]在内存中打印出日志的最后一部分，'global'是默认值
use <db_name> set current database 使用<db_name>设置当前数据库
db.foo.find() list objects in collection foo find()列表集合foo中的对象
db.foo.find( { a : 1 } ) list objects in foo where a == 1 db.foo。查找foo中a == 1的对象({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 设置默认显示的项目数量
exit quit the mongo shell
查看当前db版本
test> db.version()
3.2.6
显示当前数据库
test> db
test
或
> db.getName()
test
查询全部数据库
test> show dbs
local 0.000GB
切换数据库
> use local
switched to db local
显示当前数据库状态
查看local数据
test> use local
switched to db local
local> db.stats()
查看当前数据库的链接机器地址
查看当前链接的数据库地址
> db.getMongo()
connection to 127.0.0.1
# mongo 192.168.1.24/admin
[mongod@mongodb ~]$ mongo 192.168.1.24/admin
MongoDB shell version: 3.2.6
connecting to: 192.168.1.24/admin
admin>
当use的时候，系统就会自动建立一个数据库。若是use以后没有建立任何集合。系统就会删除这个数据库。
//删除test数据库
test> show dbs
local 0.000GB
test 0.000GB
test> use test
switched to db test
test> db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }
方法1:
admin> use app
switched to db app
app> db.createCollection('a')
{ "ok" : 1 }
app> db.createCollection('b')
{ "ok" : 1 }
> show collections 或者 show tables //查看当前数据库下的全部集合
a
b
或
> db.getCollectionNames()
[ "a", "b" ]
方法2：当插入一个文档的时候，一个集合就会自动建立。
admin> use app
switched to db app
app> db.c.insert({username:"mongodb"})
WriteResult({ "nInserted" : 1 })
app> show collections
a
b
c
app> db.c.find() ###查看数据
{ "_id" : ObjectId("5743c9a9bf72d9f7b524713d"), "username" : "mongodb" }
app> use app
switched to db app
app> db.createCollection('log')
{ "ok" : 1 }
app> db.log.drop() //删除集合
//把log更名为log1
app> db.log.renameCollection("log1")
{ "ok" : 1 }
app> show collections
a
b
c
log1
app>
app> for(i=0;i<10000;i++){ db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new Date()}); }
app> db.log.find() //查询全部记录
注：默认每页显示20条记录，当显示不下的的状况下，可使用it迭代命令查询下一页数据。
设置每页显示数据的大小：
> DBQuery.shellBatchSize=50; //每页显示50条记录
50
app> db.log.findOne() //查看第1条记录
app> db.log.count() //查询总的记录数量
app> db.log.remove({}) //删除集合中全部记录
> db.log.distinct("name") //查询去掉当前集合中某列的重复数据：按照给定的条件除重查询
[ "mm" ]
> db.yt.find()
{ "_id" : ObjectId("5b8763af7fdaa92f03ac0282"), "uid" : 3, "name" : "mongodb", "age" : 6, "date" : ISODate("2018-08-30T03:25:35.855Z") }
{ "_id" : ObjectId("5b8788577fdaa92f03ac0289"), "uid" : 2, "name" : "mongodb", "age" : 6, "date" : ISODate("2018-08-30T03:25:35.855Z") }
> db.yt.distinct('name')
[ "mongodb" ]
> db.yt.find()
{ "_id" : ObjectId("5b8763af7fdaa92f03ac0282"), "uid" : 3, "name" : "mongodb", "age" : 6, "date" : ISODate("2018-08-30T03:25:35.855Z") }
{ "_id" : ObjectId("5b8788577fdaa92f03ac0289"), "uid" : 2, "name" : "mongodb", "age" : 6, "date" : ISODate("2018-08-30T03:25:35.855Z") }
执行计划（使用explain）
> db.students.find().explain()
{
"cursor" : "BasicCursor",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 1,
"nscanned" : 1,
"nscannedObjectsAllPlans" : 1,
"nscannedAllPlans" : 1,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"server" : "SYNC-1:27017",
"filterSet" : false
}
注：
"cursor"：BasicCursor表示没有使用索引,BtreeCursor表示使用了索引。
"n"：表示返回的文档数量。
"nscanned"：表示查询了多少个文档。
"millis"：耗时（毫秒）。
"indexBounds"：所用的索引。
app> db.log.stats()
app> db.log.dataSize() //集合中数据的原始大小
app> db.log.totalIndexSize() //集合中索引数据的原始大小
app> db.log.totalSize() //集合中索引+数据压缩存储以后的大小
app> db.log.storageSize() //集合中数据压缩存储的大小
MongoDB数据库默认是没有用户名及密码的，即无权限访问限制。为了方便数据库的管理和安全，需建立数据库用户
----- admin数据库 建立超级管理员,管理全部数据库
语法含义:
user字段：用户的名字;
pwd字段：用户的密码;
cusomData字段：为任意内容，例如能够为用户全名介绍;
roles字段：指定用户的角色，能够用一个空数组给新用户设定空角色； roles 字段,能够指定内置角色和用户定义的角色。
###经常使用角色说明见官方文档 https://docs.mongodb.com/manual/reference/built-in-roles/
注意: 删除超级管理员也要删除后修改配置再重启
[root@wu ~]# mongo
use admin
db.createUser(
{
user: "root",
pwd: "root",
roles: [ { role: "root", db: "admin" } ]
}
)
注: 用户建立完成后需在配置文件打开auth验证并重启后生效
> db.auth("root","root")
1
vi mongodb.conf
auth=true
[root@wu ~]# mongo -uroot -proot
MongoDB shell version: 3.2.8
connecting to: test
2018-08-31T15:09:19.992+0800 E QUERY [thread1] Error: Authentication failed. :
DB.prototype._authOrThrow@src/mongo/shell/db.js:1441:20
@(auth):6:1
@(auth):1:2
exception: login failed
[root@wu ~]# mongo -uroot -proot admin
MongoDB shell version: 3.2.8
connecting to: admin
Server has startup warnings:
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten]
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
>
[root@wu ~]# mongo -uroot admin -p
MongoDB shell version: 3.2.8
Enter password:
connecting to: admin
Server has startup warnings:
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten]
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
> exit
bye
[root@wu ~]# mongo -uroot -p --authenticationDatabase admin 或者-p放后面 mongo -uroot --authenticationDatabase admin -p
MongoDB shell version: 3.2.8
Enter password:
connecting to: test
Server has startup warnings:
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten]
2018-08-30T17:41:51.606+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
>
--test
use test
db.createUser(
{
user: "test",
pwd: "test",
roles: [ { role: "read", db: "test" } ]
}
)
db.auth("test","test")
登陆test用户，并测试
db.createCollection('b')
或者
> use app
switched to db app
> db.createUser(
... {
... user: "app02",
... pwd: "app02",
... roles: [ "read" ] ####这里也能够readWrite 读写权限
... }
... )
Successfully added user: { "user" : "app02", "roles" : [ "read" ] }
db.createUser(
{
user: "test1",
pwd: "test1",
roles: [ { role: "readWrite", db: "test" } ]
}
)
db.auth("test1","test1")
use app
db.createUser(
{
user: "app03",
pwd: "app03",
roles: [ { role: "readWrite", db: "app" },
{ role: "read", db: "test" }
]
}
)
db.auth("app03","app03")
mongo -uapp03 -papp03 app ###登陆命令, 下面是错误命令
[root@wu ~]# mongo -uapp03 -papp03
connecting to: test
2018-08-31T19:39:26.712+0800 E QUERY [thread1] Error: Authentication failed. :
exception: login failed
[root@wu ~]# mongo -uapp03 -papp03 test
connecting to: test
2018-08-31T19:41:25.217+0800 E QUERY [thread1] Error: Authentication failed. :
exception: login failed
这个管理员应该是不能建立和删除用户
先用root用户登陆到admin数据库,再进入到对应的库
> use app
switched to db app
> db.createUser(
... {user:"appadmin",pwd:"appadmin",
... roles:[{role:"dbAdmin",db:"app"}]})
Successfully added user: {
"user" : "appadmin",
"roles" : [
{
"role" : "dbAdmin",
"db" : "app"
}
]
}
> db.auth("appadmin","appadmin")
删除app01用户：先登陆到admin数据库
# mongo -uroot –proot 192.168.1.24/admin
use app
db.dropUser("app01")
只能是root用户,而且进入到用户所对应的库里才能删除用户
> use admin
switched to db admin
> db.dropUser("test")
false
> use test
switched to db test
> db.dropUser("test")
true
use app
db.createUser(
{
user: "app04",
pwd: "app04",
roles: [ { role: "readWrite", db: "app" },
{ role: "clusterAdmin", db: "admin" }
]
}
)
> db.test111.find()
{ "_id" : ObjectId("5b9767eb495282f21844e4cd"), "uid" : 0, "name" : "mongodb", "age" : 0, "date" : ISODate("2018-09-11T06:59:55.531Z") }
{ "_id" : ObjectId("5b9767eb495282f21844e4cf"), "uid" : 2, "name" : "mongodb", "age" : 2, "date" : ISODate("2018-09-11T06:59:55.533Z") }
{ "_id" : ObjectId("5b9767eb495282f21844e4d0"), "uid" : 3, "name" : "mongodb", "age" : 3, "date" : ISODate("2018-09-11T06:59:55.533Z") }
> db.test111.update( {uid: 2}, {$set : {age: 222}} )
> db.test111.find()
{ "_id" : ObjectId("5b9767eb495282f21844e4cd"), "uid" : 0, "name" : "mongodb", "age" : 0, "date" : ISODate("2018-09-11T06:59:55.531Z") }
{ "_id" : ObjectId("5b9767eb495282f21844e4cf"), "uid" : 2, "name" : "mongodb", "age" : 222, "date" : ISODate("2018-09-11T06:59:55.533Z") }
{ "_id" : ObjectId("5b9767eb495282f21844e4d0"), "uid" : 3, "name" : "mongodb", "age" : 3, "date" : ISODate("2018-09-11T06:59:55.533Z") }
一、apache+mysql+php都在一台机器上
|||
这种架构的问题？
安全、性能、可扩展性？
二、apache+php， Mysql单独存放
| -----------------------
| |
|
------------ ------------------------
三、 lvs\haproxy\keepalive 主从复制----》MHA+KA xxproxy
-----------------------------
一、apache+mongodb+php都在一台机器上
二、apache+php， mongodb单独存放
----------------------- -----------------------
| |
| |
| |
-----------------------------------------------------------
RS复制集：
一、故障转移 ------》内部心跳，投票机制{一、状态侦测，二、选主切换}
二、应用链接的问题 ---》客户端驱动
分担负载：
sharding技术
raft
使得多个进程或服务器在某方面保持相同
必须处理一系列大范围的故障节点
磁盘故障( disk failure)
网络分区( network partitions)
机器冻结( machine freezes )
时钟脉冲相位差( clock skews )
mongodb 3.2的改进:
目标及raft一致性算法的启发
避免二次投票
监控节点状态
申请选举
Raft概念
术语(选举)
使用现有数据复制集渠道监控节点状态
非对称的选举超时
一组Mongodb复制集，就是一组mongod进程，这些进程维护同一个数据集合。复制集提供了数据冗余和高等级的可靠性，这是生产部署的基础。
保证数据在生产部署时的冗余和可靠性，经过在不一样的机器上保存副原本保证数据的不会由于单点损坏而丢失。可以随时应对数据丢失、机器损坏带来的风险，牛逼到不行。
换一句话来讲，还能提升读取能力，用户的读取服务器和写入服务器在不一样的地方，并且，由不一样的服务器为不一样的用户提供服务，提升整个系统的负载，简直就是云存储的翻版...
一组复制集就是一组mongod实例掌管同一个数据集，实例能够在不一样的机器上面。实例中包含一个主导，接受客户端全部的写入操做，其余都是副本实例，从主服务器上得到数据并保持同步。
主服务器很重要，包含了全部的改变操做（写）的日志。可是副本服务器集群包含有全部的主服务器数据，所以当主服务器挂掉了，就会在副本服务器上从新选取一个成为主服务器。
每一个复制集还有一个仲裁者，仲裁者不存储数据，只是负责经过心跳包来确认集群中集合的数量，并在主服务器选举的时候做为仲裁决定结果。
MongoDB的单实例模式下，一个mongod进程为一个实例，一个实例中包含若干db，每一个db包含若干张表。
MongoDB经过一张特殊的表local.oplog.rs存储oplog，该表的特色是：固定大小，满了会删除最旧记录插入新记录，并且只支持append操做，所以能够理解为一个持久化的ring-buffer。oplog是MongoDB复制集的核心功能点。
MongoDB复制集是指MongoDB实例经过复制并应用其余实例的oplog达到数据冗余的技术。
一个包含3个mongod的复制集架构以下所示
若是主服务器失效, 会变成:
若是加上可选的仲裁者：
此时主服务器失效:
客户端将不会把读请求分发到隐藏节点上，即便咱们设定了 复制集读选项 。这些隐藏节点将不会收到来自应用程序的请求。咱们能够将隐藏节点专用于报表节点或是备份节点。 延时节点也应该是一个隐藏节点。
延时节点的数据集是延时的，所以它能够帮助咱们在人为误操做或是其余意外状况下恢复数据。举个例子，当应用升级失败，或是误操做删除了表和数据库时，咱们能够经过延时节点进行数据恢复。
{
"_id" : <num>, "host" : <hostname:port>,
"priority" : 0,
"slaveDelay" : <seconds>, "hidden" : true
}
搭建三节点MongoDB复制集
一、准备三套MongoDB数据库（能够多台，单台能够多实例）
二、配置复制集
三、测试复制集
四、模拟故障切换
准备三台机器，分别搭建mongod单实例.
1台机器3个实例，不一样的目录结构（dbpath、logpath、conf【不一样的conf文件】），不一样的端口号
-----配置准备----规划：
实例一：
port:27017
/mongodb/data/db17
/mongodb/log/db17.log
/mongodb/conf/db17.conf
实例二：
port:27018
/mongodb/data/db18
/mongodb/log/db18.log
/mongodb/conf/db18.conf
实例三：
port:27019
/mongodb/data/db19
/mongodb/log/db19.log
/mongodb/conf/db19.conf
（建立所需目录和文件）##注意文件的属主得是mongod
[mongod@web01 ~]$ mkdir /mongodb/data/db17
[mongod@web01 ~]$ mkdir /mongodb/data/db18
[mongod@web01 ~]$ mkdir /mongodb/data/db19
[mongod@web01 ~]$ touch /mongodb/conf/db17.conf
[mongod@web01 ~]$ touch /mongodb/conf/db18.conf
[mongod@web01 ~]$ touch /mongodb/conf/db19.conf
（修改各个实例配置文件）
vi /mongodb/conf/db17.conf ---------->/mongodb/conf/db18.conf,/mongodb/conf/db19.conf
systemLog:
destination: file
path: /mongodb/log/db17.log ------>18,19
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db17 -------->18,19
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
processManagement:
fork: true
net:
port: 27017 ------>27018,27019
replication:
oplogSizeMB: 2048
replSetName: my_repl
vi /mongodb/conf/db18.conf
dbpath=/mongodb/data/db18
port=27018
logpath=/mongodb/log/db18.log
fork=true
logappend=true
vi /mongodb/conf/db19.conf
dbpath=/mongodb/data/db19
port=27019
logpath=/mongodb/log/db19.log
fork=true
logappend=true
######################问题###由于刚才用简单的配置文件启动了,如今启动不了, 无数据的环境直接删除数据文件新建
[mongodb@wu ~]$ mongod -f /mongodb/conf/db7.conf
about to fork child process, waiting until server is ready for connections.
forked process: 13692
ERROR: child process failed, exited with error number 100
[mongodb@wu ~]$ logout
[root@wu ~]# cd /mongodb/data/
[root@wu data]# rm -rf db7 db8 db9
[root@wu data]# mkdir db7 db8 db9
[root@wu mongodb]# chown -R mongodb.mongodb .
[mongod@web01 ~]$ mongod -f /mongodb/conf/db17.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1754
child process started successfully, parent exiting
[mongod@web01 ~]$ mongod -f /mongodb/conf/db18.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1772
child process started successfully, parent exiting
[mongod@web01 ~]$ mongod -f /mongodb/conf/db19.conf
about to fork child process, waiting until server is ready for connections.
forked process: 1790
child process started successfully, parent exiting
[mongod@web01 ~]$ ps aux|grep mongo
mongo --port=27017
use admin
config = {_id: 'my_repl', members: [
{_id: 0, host: '10.0.0.8:27017'},
{_id: 1, host: '10.0.0.8:27018'},
{_id: 2, host: '10.0.0.8:27019',}]
}
config = {_id: 'my_repl', members: [
{_id: 0, host: '10.0.0.8:27017'},
{_id: 1, host: '10.0.0.8:27018'},
{_id: 2, host: '10.0.0.8:27019',"arbiterOnly":true}]
}
config = {_id: 'my_repl', members: [
{_id: 0, host: '10.0.0.8:27017'},
{_id: 1, host: '10.0.0.8:27018'},
{_id: 2, host: '10.0.0.8:27019',hidden : true,priority : 0,slaveDelay : NumberLong(120)}]
}
rs.initiate(config)
[root@wu data]# mongo --port 27017
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27017/test
Server has startup warnings:
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten]
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
> config = {_id: 'my_repl', members: [
... {_id: 0, host: '10.0.0.10:27017'},
... {_id: 1, host: '10.0.0.10:27018'},
... {_id: 2, host: '10.0.0.10:27019'},
... ]}
{
"_id" : "my_repl",
"members" : [
{
"_id" : 0,
"host" : "10.0.0.10:27017"
},
{
"_id" : 1,
"host" : "10.0.0.10:27018"
},
{
"_id" : 2,
"host" : "10.0.0.10:27019"
}
]
}
> rs.initiate(config)
{ "ok" : 1 }
my_repl:OTHER> exit
bye
[root@wu data]# mongo --port 27017
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27017/test
Server has startup warnings:
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten]
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:PRIMARY> exit
bye
[root@wu data]# mongo --port 27018
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27018/test
Server has startup warnings:
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten]
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:SECONDARY> exit
bye
[root@wu data]# mongo --port 27019
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27019/test
Server has startup warnings:
2018-09-03T10:31:36.047+0800 I CONTROL [initandlisten]
2018-09-03T10:31:36.047+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:SECONDARY> exit
bye
[root@wu data]#
在主节点插入数据，去从节点验证
[mongod@web01 data]$ mongo --port=27017
use app
db.movies.insert([ { "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 },
... { "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 },
... ] )
[root@wu data]# mongo --port 27017
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27017/test
Server has startup warnings:
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten]
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:PRIMARY> use app
switched to db app
my_repl:PRIMARY> db.movies.insert([ { "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 },
... ... { "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 },
... ... ] )
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
my_repl:PRIMARY> show tables
movies
my_repl:PRIMARY> db.movies.find()
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86383"), "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 }
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86384"), "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 }
my_repl:PRIMARY> db.movies.find().pretty();
{
"_id" : ObjectId("5b8cd819e4bddfd9f8c86383"),
"title" : "Jaws",
"year" : 1975,
"imdb_rating" : 8.1
}
{
"_id" : ObjectId("5b8cd819e4bddfd9f8c86384"),
"title" : "Batman",
"year" : 1989,
"imdb_rating" : 7.6
}
my_repl:PRIMARY>
[mongod@web01 data]$ mongo --port=27018
use app
my_repl:SECONDARY> db.movies.find(); ---->报错？为何？ ↓↓↓
my_repl:SECONDARY> rs.slaveOk();
[mongodb@wu ~]$ mongo --port 27018
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27018/test
Server has startup warnings:
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten]
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:SECONDARY> use app
switched to db app
my_repl:SECONDARY> show tables
2018-09-03T14:54:43.087+0800 E QUERY [thread1] Error: listCollections failed: { "ok" : 0, "errmsg" : "not master and slaveOk=false", "code" : 13435 } :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
DB.prototype._getCollectionInfosCommand@src/mongo/shell/db.js:773:1
DB.prototype.getCollectionInfos@src/mongo/shell/db.js:785:19
DB.prototype.getCollectionNames@src/mongo/shell/db.js:796:16
shellHelper.show@src/mongo/shell/utils.js:754:9
shellHelper@src/mongo/shell/utils.js:651:15
@(shellhelp2):1:1
my_repl:SECONDARY> rs.slaveOk()
my_repl:SECONDARY> show tables
movies
my_repl:SECONDARY> db.movies.find()
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86383"), "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 }
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86384"), "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 }
[root@wu ~]# mongo --port 27019
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27019/test
Server has startup warnings:
2018-09-03T10:31:36.047+0800 I CONTROL [initandlisten]
2018-09-03T10:31:36.047+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:SECONDARY> show dbs
2018-09-03T15:07:21.554+0800 E QUERY [thread1] Error: listDatabases failed:{ "ok" : 0, "errmsg" : "not master and slaveOk=false", "code" : 13435 } :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
Mongo.prototype.getDBs@src/mongo/shell/mongo.js:62:1
shellHelper.show@src/mongo/shell/utils.js:761:19
shellHelper@src/mongo/shell/utils.js:651:15
@(shellhelp2):1:1
my_repl:SECONDARY> rs.s
rs.slaveOk( rs.status( rs.stepDown( rs.syncFrom(
my_repl:SECONDARY> rs.slaveOk()
my_repl:SECONDARY> show dbs
app 0.000GB
local 0.000GB
my_repl:SECONDARY> use app
switched to db app
my_repl:SECONDARY> show tables
movies
my_repl:SECONDARY> db.movies.find()
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86383"), "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 }
{ "_id" : ObjectId("5b8cd819e4bddfd9f8c86384"), "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 }
my_repl:SECONDARY>
rs.add("ip:port"); // 新增从节点
rs.addArb("ip:port"); // 新增仲裁节点
rs.remove("ip:port"); // 删除一个节点
rs.isMaster(); // 查看当前是不是主节点
rs.addArb("10.0.0.8:27020");
--查看副本集的配置信息
admin> rs.config()
--查看副本集各成员的状态
admin> rs.status()
--副本集角色切换
admin> rs.stepDown()
注：
admin> rs.freeze(300) //锁定从，使其不会转变成主库
freeze()和stepDown单位都是秒。
--设置副本节点可读：在副本节点执行
admin> rs.slaveOk()
eg：
admin> use app
switched to db app
app> db.createCollection('a')
{ "ok" : 0, "errmsg" : "not master", "code" : 10107 }
--查看副本节点
admin> rs.printSlaveReplicationInfo()
source: 192.168.1.22:27017
syncedTo: Thu May 26 2016 10:28:56 GMT+0800 (CST)
0 secs (0 hrs) behind the primary
[root@wu ~]# su - mongodb
[mongodb@wu ~]$ cd /mongodb/data/
[mongodb@wu data]$ mkdir db20
[mongodb@wu data]$ ll |grep ^d
drwxrwxr-x 2 mongodb mongodb 4096 Sep 3 15:38 db20
drwxr-xr-x 6 mongodb mongodb 4096 Sep 3 15:33 db7
drwxr-xr-x 6 mongodb mongodb 4096 Sep 3 15:33 db8
drwxr-xr-x 6 mongodb mongodb 4096 Sep 3 15:32 db9
drwxrwxr-x 2 mongodb mongodb 4096 Sep 3 09:20 diagnostic.data
drwxrwxr-x 2 mongodb mongodb 4096 Aug 31 18:11 journal
[mongodb@wu data]$ touch /mongodb/conf/db20.conf
[mongodb@wu data]$ cat /mongodb/conf/db7.conf >/mongodb/conf/db20.conf
[mongodb@wu data]$ vim /mongodb/conf/db20.conf
systemLog:
destination: file
path: /mongodb/log/db20.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db20
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
processManagement:
fork: true
net:
port: 27020
replication:
oplogSizeMB: 2048
replSetName: my_repl
~
"/mongodb/conf/db20.conf" 26L, 481C written
[mongodb@wu data]$ mongod -f /mongodb/conf/db20.conf
about to fork child process, waiting until server is ready for connections.
forked process: 14806
child process started successfully, parent exiting
[mongodb@wu data]$ netstat -lntp
(Not all processes could be identified, non-owned process info
will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 127.0.0.1:9000 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:27017 0.0.0.0:* LISTEN 14301/mongod
tcp 0 0 0.0.0.0:27018 0.0.0.0:* LISTEN 13775/mongod
tcp 0 0 0.0.0.0:27019 0.0.0.0:* LISTEN 13889/mongod
tcp 0 0 0.0.0.0:27020 0.0.0.0:* LISTEN 14806/mongod
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN -
tcp 0 0 :::22 :::* LISTEN -
[mongodb@wu data]$
[mongodb@wu data]$ mongo --port=27020
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27020/test
> exit
bye
[mongodb@wu data]$ mongo --port=27017
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27017/test
Server has startup warnings:
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten]
2018-09-03T14:20:03.124+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:PRIMARY> use admin
switched to db admin
my_repl:PRIMARY> rs.add
rs.add( rs.addArb(
my_repl:PRIMARY> rs.addArb("10.0.0.10:27020")
{ "ok" : 1 }
my_repl:PRIMARY>
my_repl:PRIMARY> rs.status()
{
"set" : "my_repl",
"date" : ISODate("2018-09-03T07:46:39.238Z"),
"myState" : 1,
"term" : NumberLong(1),
"heartbeatIntervalMillis" : NumberLong(2000),
"members" : [
{
"_id" : 0,
"name" : "10.0.0.10:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 5196,
"optime" : {
"ts" : Timestamp(1535960682, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T07:44:42Z"),
"electionTime" : Timestamp(1535956326, 1),
"electionDate" : ISODate("2018-09-03T06:32:06Z"),
"configVersion" : 2,
"self" : true
},
{
"_id" : 1,
"name" : "10.0.0.10:27018",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 4484,
"optime" : {
"ts" : Timestamp(1535960682, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T07:44:42Z"),
"lastHeartbeat" : ISODate("2018-09-03T07:46:38.535Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T07:46:38.563Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27017",
"configVersion" : 2
},
{
"_id" : 2,
"name" : "10.0.0.10:27019",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 4484,
"optime" : {
"ts" : Timestamp(1535960682, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T07:44:42Z"),
"lastHeartbeat" : ISODate("2018-09-03T07:46:38.535Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T07:46:38.553Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27017",
"configVersion" : 2
},
{
"_id" : 3,
"name" : "10.0.0.10:27020",
"health" : 1,
"state" : 7,
"stateStr" : "ARBITER",
"uptime" : 116,
"lastHeartbeat" : ISODate("2018-09-03T07:46:38.535Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T07:46:37.499Z"),
"pingMs" : NumberLong(0),
"configVersion" : 2
}
],
"ok" : 1
}
my_repl:PRIMARY>
my_repl:ARBITER> rs.isMaster()
{
"hosts" : [
"10.0.0.10:27017",
"10.0.0.10:27018",
"10.0.0.10:27019"
],
"arbiters" : [
"10.0.0.10:27020"
],
"setName" : "my_repl",
"setVersion" : 2,
"ismaster" : false,
"secondary" : false,
"primary" : "10.0.0.10:27017",
"arbiterOnly" : true,
"me" : "10.0.0.10:27020",
"maxBsonObjectSize" : 16777216,
"maxMessageSizeBytes" : 48000000,
"maxWriteBatchSize" : 1000,
"localTime" : ISODate("2018-09-03T10:32:23.466Z"),
"maxWireVersion" : 4,
"minWireVersion" : 0,
"ok" : 1
}
格式:
cfg=rs.conf() /*找到须要改成延迟性同步的数组号*/;
cfg.members[N].priority=0
cfg.members[N].slaveDelay=120
cfg.members[N].hidden=true
rs.reconfig(cfg)
实验:
cfg=rs.conf()
cfg.members[2].priority=0
cfg.members[2].slaveDelay=120
cfg.members[2].hidden=true
rs.reconfig(cfg)
[root@wu data]# mongo --port 27017
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27017/test
my_repl:PRIMARY> cfg=rs.conf()
{
"_id" : "my_repl",
"version" : 2,
"protocolVersion" : NumberLong(1),
"members" : [
{
"_id" : 0,
"host" : "10.0.0.10:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "10.0.0.10:27018",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "10.0.0.10:27019",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 3,
"host" : "10.0.0.10:27020",
"arbiterOnly" : true,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],
"settings" : {
"chainingAllowed" : true,
"heartbeatIntervalMillis" : 2000,
"heartbeatTimeoutSecs" : 10,
"electionTimeoutMillis" : 10000,
"getLastErrorModes" : {
},
"getLastErrorDefaults" : {
"w" : 1,
"wtimeout" : 0
},
"replicaSetId" : ObjectId("5b8cd55a8425ac85a30e09aa")
}
}
my_repl:PRIMARY> cfg.members[2].priority=0
0
my_repl:PRIMARY> cfg.members[2].slaveDelay=120
120
my_repl:PRIMARY> cfg.members[2].hidden=true
true
my_repl:PRIMARY> rs.reconfig(cfg)
{ "ok" : 1 }
my_repl:PRIMARY> cfg=rs.conf()
{
"_id" : "my_repl",
"version" : 3,
"protocolVersion" : NumberLong(1),
"members" : [
{
"_id" : 0,
"host" : "10.0.0.10:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "10.0.0.10:27018",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "10.0.0.10:27019",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : true,
"priority" : 0,
"tags" : {
},
"slaveDelay" : NumberLong(120),
"votes" : 1
},
{
"_id" : 3,
"host" : "10.0.0.10:27020",
"arbiterOnly" : true,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],
"settings" : {
"chainingAllowed" : true,
"heartbeatIntervalMillis" : 2000,
"heartbeatTimeoutSecs" : 10,
"electionTimeoutMillis" : 10000,
"getLastErrorModes" : {
},
"getLastErrorDefaults" : {
"w" : 1,
"wtimeout" : 0
},
"replicaSetId" : ObjectId("5b8cd55a8425ac85a30e09aa")
}
}
my_repl:ARBITER> rs.conf()
{
"_id" : "my_repl",
"version" : 3,
"protocolVersion" : NumberLong(1),
"members" : [
{
"_id" : 0,
"host" : "10.0.0.10:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "10.0.0.10:27018",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "10.0.0.10:27019",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : true,
"priority" : 0,
"tags" : {
},
"slaveDelay" : NumberLong(120),
"votes" : 1
},
{
"_id" : 3,
"host" : "10.0.0.10:27020",
"arbiterOnly" : true,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],
"settings" : {
"chainingAllowed" : true,
"heartbeatIntervalMillis" : 2000,
"heartbeatTimeoutSecs" : 10,
"electionTimeoutMillis" : 10000,
"getLastErrorModes" : {
},
"getLastErrorDefaults" : {
"w" : 1,
"wtimeout" : 0
},
"replicaSetId" : ObjectId("5b8cd55a8425ac85a30e09aa")
}
}
my_repl:ARBITER>
my_repl:PRIMARY> rs.status() ####如今是27017实例
{
"set" : "my_repl",
"date" : ISODate("2018-09-03T10:50:10.261Z"),
"myState" : 1,
"term" : NumberLong(1),
"heartbeatIntervalMillis" : NumberLong(2000),
"members" : [
{
"_id" : 0,
"name" : "10.0.0.10:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 16207,
"optime" : {
"ts" : Timestamp(1535971765, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T10:49:25Z"),
"electionTime" : Timestamp(1535956326, 1),
"electionDate" : ISODate("2018-09-03T06:32:06Z"),
"configVersion" : 3,
"self" : true
},
{
"_id" : 1,
"name" : "10.0.0.10:27018",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 15495,
"optime" : {
"ts" : Timestamp(1535971765, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T10:49:25Z"),
"lastHeartbeat" : ISODate("2018-09-03T10:50:09.653Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T10:50:09.651Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27017",
"configVersion" : 3
},
{
"_id" : 2,
"name" : "10.0.0.10:27019",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 15495,
"optime" : {
"ts" : Timestamp(1535971765, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T10:49:25Z"),
"lastHeartbeat" : ISODate("2018-09-03T10:50:09.653Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T10:50:09.653Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27017",
"configVersion" : 3
},
{
"_id" : 3,
"name" : "10.0.0.10:27020",
"health" : 1,
"state" : 7,
"stateStr" : "ARBITER",
"uptime" : 11127,
"lastHeartbeat" : ISODate("2018-09-03T10:50:09.651Z"),
"lastHeartbeatRecv" : ISODate("2018-09-03T10:50:05.568Z"),
"pingMs" : NumberLong(0),
"configVersion" : 3
}
],
"ok" : 1
}
my_repl:PRIMARY>
my_repl:PRIMARY> rs.isMaster()
{
"hosts" : [
"10.0.0.10:27017",
"10.0.0.10:27018"
],
"arbiters" : [
"10.0.0.10:27020"
],
"setName" : "my_repl",
"setVersion" : 3,
"ismaster" : true,
"secondary" : false,
"primary" : "10.0.0.10:27017",
"me" : "10.0.0.10:27017",
"electionId" : ObjectId("7fffffff0000000000000001"),
"maxBsonObjectSize" : 16777216,
"maxMessageSizeBytes" : 48000000,
"maxWriteBatchSize" : 1000,
"localTime" : ISODate("2018-09-05T01:33:29.062Z"),
"maxWireVersion" : 4,
"minWireVersion" : 0,
"ok" : 1
}
my_repl:PRIMARY> exit
bye
[root@wu data]# ps aux|grep mongo
root 13730 0.0 0.0 163408 1976 pts/1 S Sep03 0:00 su - mongodb
mongodb 13731 0.0 0.0 108360 1824 pts/1 S Sep03 0:00 -bash
mongodb 13775 0.6 2.6 890420 54304 ? Sl Sep03 17:28 mongod -f /mongodb/conf/db8.conf
mongodb 13889 0.6 2.6 887360 53848 ? Sl Sep03 17:24 /mongodb/bin/mongod -f /mongodb/conf/db9.conf
mongodb 14301 0.6 2.5 904916 51320 ? Sl Sep03 17:25 /mongodb/bin/mongod -f /mongodb/conf/db7.conf
root 14771 0.0 0.0 163408 1976 pts/2 S Sep03 0:00 su - mongodb
mongodb 14772 0.0 0.0 108360 1836 pts/2 S Sep03 0:00 -bash
mongodb 14806 0.4 2.4 466640 49644 ? Sl Sep03 10:57 mongod -f /mongodb/conf/db20.conf
mongodb 14874 0.0 0.9 193092 18664 pts/2 Sl+ Sep03 0:00 mongo --port=27020
mongodb 15079 0.0 0.8 192000 18016 pts/1 Sl+ Sep03 0:00 mongo --port 27018
root 18423 0.0 0.0 103332 836 pts/0 S+ 09:34 0:00 grep mongo
[root@wu data]#
[root@wu data]# kill -2 14301
[root@wu data]# ps aux|grep mongo
root 13730 0.0 0.0 163408 1976 pts/1 S Sep03 0:00 su - mongodb
mongodb 13731 0.0 0.0 108360 1824 pts/1 S Sep03 0:00 -bash
mongodb 13775 0.6 2.6 890420 54368 ? Sl Sep03 17:29 mongod -f /mongodb/conf/db8.conf
mongodb 13889 0.6 2.6 887360 53900 ? Sl Sep03 17:24 /mongodb/bin/mongod -f /mongodb/conf/db9.conf
root 14771 0.0 0.0 163408 1976 pts/2 S Sep03 0:00 su - mongodb
mongodb 14772 0.0 0.0 108360 1836 pts/2 S Sep03 0:00 -bash
mongodb 14806 0.4 2.4 466640 49660 ? Sl Sep03 10:57 mongod -f /mongodb/conf/db20.conf
mongodb 14874 0.0 0.9 193092 18664 pts/2 Sl+ Sep03 0:00 mongo --port=27020
mongodb 15079 0.0 0.8 192000 18016 pts/1 Sl+ Sep03 0:00 mongo --port 27018
root 18431 0.0 0.0 103332 840 pts/0 S+ 09:35 0:00 grep mongo
[root@wu data]# mongo --port 27018
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27018/test
Server has startup warnings:
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten]
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:PRIMARY> rs.isMaster()
{
"hosts" : [
"10.0.0.10:27017",
"10.0.0.10:27018"
],
"arbiters" : [
"10.0.0.10:27020"
],
"setName" : "my_repl",
"setVersion" : 3,
"ismaster" : true,
"secondary" : false,
"primary" : "10.0.0.10:27018",
"me" : "10.0.0.10:27018",
"electionId" : ObjectId("7fffffff0000000000000002"),
"maxBsonObjectSize" : 16777216,
"maxMessageSizeBytes" : 48000000,
"maxWriteBatchSize" : 1000,
"localTime" : ISODate("2018-09-05T01:35:35.920Z"),
"maxWireVersion" : 4,
"minWireVersion" : 0,
"ok" : 1
}
my_repl:PRIMARY> rs.status()
{
"set" : "my_repl",
"date" : ISODate("2018-09-05T01:35:58.868Z"),
"myState" : 1,
"term" : NumberLong(2),
"heartbeatIntervalMillis" : NumberLong(2000),
"members" : [
{
"_id" : 0,
"name" : "10.0.0.10:27017",
"health" : 0,
"state" : 8,
"stateStr" : "(not reachable/healthy)",
"uptime" : 0,
"optime" : {
"ts" : Timestamp(0, 0),
"t" : NumberLong(-1)
},
"optimeDate" : ISODate("1970-01-01T00:00:00Z"),
"lastHeartbeat" : ISODate("2018-09-05T01:35:57.617Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:34:58.517Z"),
"pingMs" : NumberLong(0),
"lastHeartbeatMessage" : "Connection refused",
"configVersion" : -1
},
{
"_id" : 1,
"name" : "10.0.0.10:27018",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 170022,
"optime" : {
"ts" : Timestamp(1536111310, 1),
"t" : NumberLong(2)
},
"optimeDate" : ISODate("2018-09-05T01:35:10Z"),
"infoMessage" : "could not find member to sync from",
"electionTime" : Timestamp(1536111309, 1),
"electionDate" : ISODate("2018-09-05T01:35:09Z"),
"configVersion" : 3,
"self" : true
},
{
"_id" : 2,
"name" : "10.0.0.10:27019",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 155041,
"optime" : {
"ts" : Timestamp(1535971765, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-09-03T10:49:25Z"),
"lastHeartbeat" : ISODate("2018-09-05T01:35:57.617Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:35:58.393Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27018",
"configVersion" : 3
},
{
"_id" : 3,
"name" : "10.0.0.10:27020",
"health" : 1,
"state" : 7,
"stateStr" : "ARBITER",
"uptime" : 150676,
"lastHeartbeat" : ISODate("2018-09-05T01:35:57.601Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:35:54.477Z"),
"pingMs" : NumberLong(0),
"configVersion" : 3
}
],
"ok" : 1
}
my_repl:PRIMARY>
[mongodb@wu ~]$ mongod -f /mongodb/conf/db7.conf
about to fork child process, waiting until server is ready for connections.
forked process: 18454
child process started successfully, parent exiting
[mongodb@wu ~]$ mongo --port 27018
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27018/test
Server has startup warnings:
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten]
2018-09-03T10:22:17.049+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.
my_repl:PRIMARY> rs.isMaster()
{
"hosts" : [
"10.0.0.10:27017",
"10.0.0.10:27018"
],
"arbiters" : [
"10.0.0.10:27020"
],
"setName" : "my_repl",
"setVersion" : 3,
"ismaster" : true,
"secondary" : false,
"primary" : "10.0.0.10:27018",
"me" : "10.0.0.10:27018",
"electionId" : ObjectId("7fffffff0000000000000002"),
"maxBsonObjectSize" : 16777216,
"maxMessageSizeBytes" : 48000000,
"maxWriteBatchSize" : 1000,
"localTime" : ISODate("2018-09-05T01:46:33.963Z"),
"maxWireVersion" : 4,
"minWireVersion" : 0,
"ok" : 1
}
my_repl:PRIMARY> rs.status()
{
"set" : "my_repl",
"date" : ISODate("2018-09-05T01:47:08.547Z"),
"myState" : 1,
"term" : NumberLong(2),
"heartbeatIntervalMillis" : NumberLong(2000),
"members" : [
{
"_id" : 0,
"name" : "10.0.0.10:27017",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 106,
"optime" : {
"ts" : Timestamp(1536111310, 1),
"t" : NumberLong(2)
},
"optimeDate" : ISODate("2018-09-05T01:35:10Z"),
"lastHeartbeat" : ISODate("2018-09-05T01:47:08.096Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:47:08.057Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27018",
"configVersion" : 3
},
{
"_id" : 1,
"name" : "10.0.0.10:27018",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 170692,
"optime" : {
"ts" : Timestamp(1536111310, 1),
"t" : NumberLong(2)
},
"optimeDate" : ISODate("2018-09-05T01:35:10Z"),
"electionTime" : Timestamp(1536111309, 1),
"electionDate" : ISODate("2018-09-05T01:35:09Z"),
"configVersion" : 3,
"self" : true
},
{
"_id" : 2,
"name" : "10.0.0.10:27019",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 155711,
"optime" : {
"ts" : Timestamp(1536111310, 1),
"t" : NumberLong(2)
},
"optimeDate" : ISODate("2018-09-05T01:35:10Z"),
"lastHeartbeat" : ISODate("2018-09-05T01:47:08.011Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:47:06.750Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "10.0.0.10:27018",
"configVersion" : 3
},
{
"_id" : 3,
"name" : "10.0.0.10:27020",
"health" : 1,
"state" : 7,
"stateStr" : "ARBITER",
"uptime" : 151346,
"lastHeartbeat" : ISODate("2018-09-05T01:47:07.951Z"),
"lastHeartbeatRecv" : ISODate("2018-09-05T01:47:04.648Z"),
"pingMs" : NumberLong(0),
"configVersion" : 3
}
],
"ok" : 1
}
my_repl:PRIMARY>
mgdb水平扩展使用了分片技术, 有点相似mysql里的分库分表.
高数据量和吞吐量的数据库应用会对单机的性能形成较大压力,大的查询量会将单机的CPU耗尽,大的数据量对单机的存储压力较大,最终会耗尽系统的内存而将压力转移到磁盘IO上。为了解决这些问题,有两个基本的方法: 垂直扩展和水平扩展。
垂直扩展：增长更多的CPU和存储资源来扩展容量。
水平扩展：将数据集分布在多个服务器上。水平扩展即分片。
Config Server
存储集群全部节点、分片数据路由信息。默认须要配置3个Config Server节点。
Mongos
提供对外应用访问，全部操做均经过mongos执行。通常有多个mongos节点。数据迁移和数据自动平衡。
Mongod
存储应用数据记录。通常有多个Mongod节点，达到数据分片目的。
初始1个chunk
缺省chunk 大小：64MB
MongoDB自动拆分& 迁移chunks
适合业务的chunksize是最好的。
chunk的分裂和迁移：很是消耗IO资源。
chunk分裂的时机：插入和更新，读数据不会分裂。
chunksize的选择：
> 小的chunksize：数据均衡是迁移速度快，数据分布更均匀。数据分裂频繁，路由节点消耗更多资源。
> 大的chunksize：数据分裂少。数据块移动集中消耗IO资源。
一般100-200M
当数据写入时，MongoDB Cluster根据分片键设计写入数据。
当外部语句发起数据查询时，MongoDB根据数据分布自动路由至指定节点返回数据。
Sharded Cluster支持将单个集合的数据分散存储在多shard上，用户能够指定根据集合内文档的某个字段即shard key来分布数据。
范围分片:
如图，第一个chunk的范围就是uid从-∞到12000范围内的数据。第二个就是12000到58000 。以此类推。对于一个刚配置为Sharding的collection ，最开始只有一个chunk，范围是从-∞到+∞。
随着数据的增加，其中的数据大小超过了配置的chunk size，默认是64M，则这个chunk就会分裂成两个。数据的增加会让chunk分裂得愈来愈多。这时候，各个shard 上的chunk数量就会不平衡。这时候，mongos中的一个组件balancer就会执行自动平衡。把chunk从chunk数量最多的shard节点挪动到数量最少的节点。
Hash分片与范围分片互补，能将文档随机的分散到各个chunk，充分的扩展写能力，弥补了范围分片的不足，但不能高效的服务范围查询，全部的范围查询要分发到后端全部的Shard才能找出知足条件的文档。
必须为分片collection 定义分片键。
基于一个或多个列（相似一个索引）。
分片键定义数据空间。
想象key space 相似一条线上一个点数据。
一个key range 是一条线上一段数据。
分片键是不可变。
分片键必须有索引。
分片键大小限制512bytes。
分片键用于路由查询。
MongoDB不接受已进行collection级分片的collection上插入无分片键的文档（也不支持空值插入）
递增的sharding key
数据文件挪动小。（优点）
由于数据文件递增，因此会把insert的写IO永久放在最后一片上，形成最后一片的写热点。
同时，随着最后一片的数据量增大，将不断的发生迁移至以前的片上。
随机的sharding key
数据分布均匀，insert的写IO均匀分布在多个片上。（优点）
大量的随机IO，磁盘不堪重荷。
混合型key
大方向随机递增。
小范围随机分布。
注: 能够参考shard+rs.txt 文档
性能问题
sharding集群=shrd+RS
mongos： 接收请求，响应请求，请求config
config server ： 元数据，分片的位置、分片的策略、分片节点信息、chunk位置信息
shard节点： 真实数据
-----------------
准备10个mongod实例
端口：27030-27039
目录规划：
mkdir /mongodb/data/db{30..39}
touch /mongodb/conf/db{30..39}.conf
[mongodb@wu data]$ mkdir /mongodb/data/db{30..39}
[mongodb@wu data]$ ll |grep ^d
[mongodb@wu data]$ touch /mongodb/conf/db{30..39}.conf
角色规划:
configserver RS: db30->db32
mongos : db33
shard节点：
shard1 RS:
db34\db35\db36
shard2 RS:
db37\db38\db39
---------------------------------
vi /mongodb/conf/db30.conf
systemLog:
destination: file
path: /mongodb/log/db30.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db30
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
##bindIp:10.0.0.10
port: 27030
replication:
oplogSizeMB: 2048
replSetName: configReplSet
sharding:
clusterRole: configsvr
processManagement:
fork: true
vi /mongodb/conf/db31.conf
systemLog:
destination: file
path: /mongodb/log/db31.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db31
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27031
replication:
oplogSizeMB: 2048
replSetName: configReplSet
sharding:
clusterRole: configsvr
processManagement:
fork: true
vi /mongodb/conf/db32.conf
systemLog:
destination: file
path: /mongodb/log/db32.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db32
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27032
replication:
oplogSizeMB: 2048
replSetName: configReplSet
sharding:
clusterRole: configsvr
processManagement:
fork: true
[mongod@web01 ~]$ mongod -f /mongodb/conf/db30.conf
[mongod@web01 ~]$ mongod -f /mongodb/conf/db31.conf
[mongod@web01 ~]$ mongod -f /mongodb/conf/db32.conf
mongo --port=27030
use admin
config = {_id: 'configReplSet', members: [
{_id: 0, host: '10.0.0.8:27030'},
{_id: 1, host: '10.0.0.8:27031'},
{_id: 2, host: '10.0.0.8:27032'}]}
注：mongodb 2.4以后，虽然要求config server为replica set，可是不支持arbiter
rs.initiate(config)
[mongodb@wu data]$ mongo --port=27030
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27030/test
> use admin
switched to db admin
> config = {_id: 'configReplSet', members: [
... {_id:0,host:'10.0.0.10:27030'},
... {_id:1,host:'10.0.0.10:27031'},
... {_id:2,host:'10.0.0.10:27032'}]}
{
"_id" : "configReplSet",
"members" : [
{
"_id" : 0,
"host" : "10.0.0.10:27030"
},
{
"_id" : 1,
"host" : "10.0.0.10:27031"
},
{
"_id" : 2,
"host" : "10.0.0.10:27032"
}
]
}
> rs.initiate(config)
{ "ok" : 1 }
configReplSet:OTHER> rs.status()
configReplSet:SECONDARY> exit
bye
[mongodb@wu data]$ mongo --port=27030
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27030/test
configReplSet:PRIMARY> rs.config()
configReplSet:PRIMARY> rs.isMaster()
vi /mongodb/conf/db33.conf
systemLog:
destination: file
path: /mongodb/log/db33.log
logAppend: true
net:
port: 27033
sharding:
configDB: configReplSet/10.0.0.8:27030,10.0.0.8:27031,10.0.0.8:27032
processManagement:
fork: true
[mongodb@wu data]$ mongos -f /mongodb/conf/db33.conf
about to fork child process, waiting until server is ready for connections.
forked process: 19196
child process started successfully, parent exiting
[mongodb@wu data]$ ps -ef|grep mongos
mongodb 19196 1 0 13:38 ? 00:00:02 mongos -f /mongodb/conf/db33.conf
mongodb 19275 14772 0 14:05 pts/2 00:00:00 grep mongos
vi /mongodb/conf/db34.conf
systemLog:
destination: file
path: /mongodb/log/db34.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db34
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27034
replication:
oplogSizeMB: 2048
replSetName: sh1RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
vi /mongodb/conf/db35.conf
systemLog:
destination: file
path: /mongodb/log/db35.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db35
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27035
replication:
oplogSizeMB: 2048
replSetName: sh1RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
vi /mongodb/conf/db36.conf
systemLog:
destination: file
path: /mongodb/log/db36.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db36
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27036
replication:
oplogSizeMB: 2048
replSetName: sh1RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
vi /mongodb/conf/db37.conf
systemLog:
destination: file
path: /mongodb/log/db37.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db37
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27037
replication:
oplogSizeMB: 2048
replSetName: sh2RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
vi /mongodb/conf/db38.conf
systemLog:
destination: file
path: /mongodb/log/db38.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db38
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27038
replication:
oplogSizeMB: 2048
replSetName: sh2RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
vi /mongodb/conf/db39.conf
systemLog:
destination: file
path: /mongodb/log/db39.log
logAppend: true
storage:
journal:
enabled: true
dbPath: /mongodb/data/db39
directoryPerDB: true
#engine: wiredTiger
wiredTiger:
engineConfig:
cacheSizeGB: 1
directoryForIndexes: true
collectionConfig:
blockCompressor: zlib
indexConfig:
prefixCompression: true
net:
port: 27039
replication:
oplogSizeMB: 2048
replSetName: sh2RS
sharding:
clusterRole: shardsvr
processManagement:
fork: true
配置完成后启动6个节点。
[mongod@web01 conf]$ mongod -f db34.conf
[mongod@web01 conf]$ mongod -f db35.conf
[mongod@web01 conf]$ mongod -f db36.conf
[mongod@web01 conf]$ mongod -f db37.conf
[mongod@web01 conf]$ mongod -f db38.conf
[mongod@web01 conf]$ mongod -f db39.conf
配置shard1 RS：
mongo --port=27034
use admin
config = {_id: 'sh1RS', members: [
{_id: 0, host: '10.0.0.8:27034'},
{_id: 1, host: '10.0.0.8:27035'},
{_id: 2, host: '10.0.0.8:27036'}]}
rs.initiate(config)
--------------------
配置shard2 RS：
mongo --port=27037
use admin
config = {_id: 'sh2RS', members: [
{_id: 0, host: '10.0.0.8:27037'},
{_id: 1, host: '10.0.0.8:27038'},
{_id: 2, host: '10.0.0.8:27039'}]}
rs.initiate(config)
---------
链接到其中一个mongos进程，作如下配置
# su - mongod
$ mongo --port=27033 admin
> db.runCommand( { addshard : "sh1RS/10.0.0.8:27034,10.0.0.8:27035,10.0.0.8:27036",name:"shard1"} )
> db.runCommand( { addshard : "sh2RS/10.0.0.8:27037,10.0.0.8:27038,10.0.0.8:27039",name:"shard2"} )
mongos> db.runCommand( { listshards : 1 } )
到此为止分片集群搭建成功。
[mongodb@wu data]$ mongo --port=27033 admin
MongoDB shell version: 3.2.8
connecting to: 127.0.0.1:27033/admin
mongos> db.runCommand( { addshard : "sh1RS/10.0.0.10:27034,10.0.0.10:27035,10.0.0.10:27036",name:"shard1"})
{ "shardAdded" : "shard1", "ok" : 1 }
mongos> db.runCommand( { addshard : "sh2RS/10.0.0.10:27034,10.0.0.10:27035,10.0.0.10:27039",name:"shard2"})
{
"ok" : 0,
"errmsg" : "in seed list sh2RS/10.0.0.10:27034,10.0.0.10:27035,10.0.0.10:27039, host 10.0.0.10:27034 does not belong to replica set sh2RS; found { hosts: [ \"10.0.0.10:27037\", \"10.0.0.10:27038\", \"10.0.0.10:27039\" ], setName: \"sh2RS\", setVersion: 1, ismaster: true, secondary: false, primary: \"10.0.0.10:27037\", me: \"10.0.0.10:27037\", electionId: ObjectId('7fffffff0000000000000001'), maxBsonObjectSize: 16777216, maxMessageSizeBytes: 48000000, maxWriteBatchSize: 1000, localTime: new Date(1536130591092), maxWireVersion: 4, minWireVersion: 0, ok: 1.0 }",
"code" : 96
}
mongos> db.runCommand( { addshard : "sh2RS/10.0.0.10:27037,10.0.0.10:27038,10.0.0.10:27039",name:"shard2"})
{ "shardAdded" : "shard2", "ok" : 1 }
mongos> db.runCommand({listshards:1})
{
"shards" : [
{
"_id" : "shard1",
"host" : "sh1RS/10.0.0.10:27034,10.0.0.10:27035,10.0.0.10:27036"
},
{
"_id" : "shard2",
"host" : "sh2RS/10.0.0.10:27037,10.0.0.10:27038,10.0.0.10:27039"
}
],
"ok" : 1
}
mongos>
登录admin数据库：
mongo -uroot -p123456 192.168.88.53:30000/admin
一、激活数据库分片功能
admin> ( { enablesharding : "数据库名称" } )
eg：
admin> db.runCommand( { enablesharding : "test" } )
二、指定分片建对集合分片
eg：范围片键
--建立索引
admin> db.vast.ensureIndex( { id: 1 } )
admin> db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )
三、集合分片验证
admin> use test
test> for(i=0;i<2000000;i++){ db.vast.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); }
test> db.vast.stats()
三、分片键
--范围片键
admin> sh.shardCollection("数据库名称.集合名称",key : {分片键: 1} )
或
admin> db.runCommand( { shardcollection : "数据库名称.集合名称",key : {分片键: 1} } )
eg：
admin > sh.shardCollection("test.vast",key : {id: 1} )
或
admin> db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )
--哈希片键
admin > sh.shardCollection( "数据库名.集合名", { 片键: "hashed" } )
eg：
建立哈希索引
admin> db.vast.ensureIndex( { a: "hashed" } )
admin > sh.shardCollection( "test.vast", { a: "hashed" } )
四、判断是否Shard集群
admin> db.runCommand({ isdbgrid : 1})
五、列出全部分片信息
admin> db.runCommand({ listshards : 1})
六、列出开启分片的数据库
admin> use config
config> db.databases.find( { "partitioned": true } )
config> db.databases.find() //列出全部数据库分片状况
七、查看分片的片键
config> db.collections.find()
{
"_id" : "test.vast",
"lastmodEpoch" : ObjectId("58a599f19c898bbfb818b63c"),
"lastmod" : ISODate("1970-02-19T17:02:47.296Z"),
"dropped" : false,
"key" : {
"id" : 1
},
"unique" : false
}
八、查看分片的详细信息
admin> db.printShardingStatus()
或
admin> sh.status()
主分片
> db.adminCommand({"connPoolStats" : 1})
{
"createdByType": {
"sync": 857,
"set": 4
},
"numDBClientConnection": 35,
"numAScopedConnection": 0,
"hosts": {
"config-01:10005,config-02:10005,config-03:10005": {
"created": 857,
"available": 2
},
"spock/spock-01:10005,spock-02:10005,spock-03:10005": {
"created": 4,
"available": 1
}
},
"totalAvailable": 3,
"totalCreated": 861,
"ok": 1
}
注：
1）形如"host1，host2，host3"的主机名是来自配置服务器的链接，也就是用于“同步”的链接。
形如"name/host1, host2,...,hostN"的主机是来自分片的链接。available的值代表当前实例的链接池中有多少可用链接。
2）在一个分片上执行connPoolStats，输出信息中可看到该分片与其余分片间的链接，包括链接到其余分片作数据迁移的链接。
分片的主链接会直接链接到另外一分片的主链接上，而后从目标分片吸收数据。
3）进行迁移时，分片会创建一个ReplicaSetMonitor（该进程用于监控副本集的健康情况），
用于追踪记录迁移另外一端分片的健康情况。因为mongod不会销毁这个监控器，
因此有时会在一个副本集的日志中看到其余副本集成员的信息。这是很正常的，不会对应用程序形成任何影响。
对于mgdb的shard集群来讲,添加一个分片很简单, AddShard就能够了.
可是缩减集群(删除分片)通常不多用到. 因为某服务器挂了,因此送修前必须把它上面的数据自动迁移到其余shard上.
一、执行RemoveShard命令
db.runCommand( { removeshard: "your_shard_name" } )
{ msg : "draining started successfully" , state: "started" , shard :"mongodb0" , ok : 1 }
上面这句会当即返回，实际在后台执行。
二、查看迁移状态
咱们能够反复执行上面语句，查看执行结果。
db.runCommand( { removeshard: "your_shard_name" } )
{ msg: "draining ongoing" , state: "ongoing" , remaining: { chunks: 42, dbs : 1 }, ok: 1 }
从上面能够看到, 正在迁移，还剩下42块没迁移完。
当remain为0以后, 这一步就结束了。
三、移出非shard数据
db.runComand({movePrimary:”myapp”, to:’’mongodb1’’})
此次就不是当即返回了，要好久，而后会返回以下：
{“primary”:”mongodb1”,”ok”:1}
四、上面步骤完成后，还须要再执行一次RemoveShard,清理残余数据
db.runCommand({removeshard:”mongodb0”})
执行成功后，会以下结果．
{msg：’’remove shard completed succesfully，stage: completed",host："mongodb0",ok：1}
显示completed后，就能够安心的关閉mongod的进程了。
官方文档: http://docs.mongodb.org/manual/tutorial/remove-shards-from-cluster
注意官方关因而否须要运行movePrimary的说明
----------------------------
三个中心
北京核心机房（公司）： vm1
北京亦庄灾备机房： vm2
上海分部IDC： vm3
--------------------------------
configserver的灾备：
vm1：config1+config2+config3====》ConfigRS
vm2：config4 =====》ConfigRS
vm ：config5 =====》ConfigRS
------------------------------
shard的灾备：shard1
vm1：S1+S2+S3 ---》shard1
vm2：s4 =====》shard1
vm3 ：s5 =====》shard1
-------------------
mongos
vm1 mongos1
vm2 mongos2
vm3 mongos3
----------------------
逻辑
mongoexport/mongoimport
mongodump/mongorestore
物理
拷贝文件
卷/磁盘快照
若是mongod实例中日志功能未开启，或者是日志在另外的卷上，得到一致状态的备份是比较困难的。
刷新内存数据到硬盘，而且中止写操做：
db.fsyncLock()
Copy / snapshot
db.fsyncUnlock()
Mongodb自带了mongodump和mongorestore这两个工具来实现对数据的备份和恢复还原。
mongodump可以在Mongodb运行时进行备份，它的工做原理是对运行的Mongodb作查询，而后将全部查到的文档写入磁盘。可是存在的问题时使用mongodump产生的备份不必定是数据库的实时快照，若是咱们在备份时对数据库进行了写入操做，则备份出来的文件可能不彻底和Mongodb实时数据相等。另外在备份时可能会对其它客户端性能产生不利的影响。
mongodump用法以下：
$ mongodump --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
-j, --numParallelCollections= number of collections to dump in parallel (4 by default) 并行转储的集合的数量
具体使用示例以下：
$ cd /home/mongod/backup/
--备份test库
$ mongodump -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -o /home/mongod/backup/
--备份test库下的vast集合
$ mongodump -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -c vast -o /home/mongod/backup/
--压缩备份
$ mongodump -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -o /home/mongod/backup/ --gzip
$ mongodump -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -c vast -o /home/mongod/backup/ --gzip
压缩备份的结果
[root@wu wu]# mongodump -h 127.0.0.1:27017 -o /wu/ --gzip
2018-09-11T12:00:54.107+0800 writing admin.system.users to
2018-09-11T12:00:54.108+0800 done dumping admin.system.users (2 documents)
2018-09-11T12:00:54.134+0800 writing admin.system.version to
2018-09-11T12:00:54.135+0800 done dumping admin.system.version (1 document)
2018-09-11T12:00:54.135+0800 writing mapList.examMapId to
2018-09-11T12:00:54.135+0800 writing app.movies to
2018-09-11T12:00:54.136+0800 writing mapList.resMapId to
2018-09-11T12:00:54.136+0800 writing app.xxxxx to
2018-09-11T12:00:54.137+0800 done dumping mapList.examMapId (11 documents)
2018-09-11T12:00:54.137+0800 writing app.888 to
2018-09-11T12:00:54.137+0800 done dumping app.movies (2 documents)
[root@wu wu]# ll
total 16
drwxr-xr-x 2 root root 4096 Sep 11 12:00 admin
drwxr-xr-x 2 root root 4096 Sep 11 12:00 app
drwxr-xr-x 2 root root 4096 Sep 11 12:00 mapList
-rw-r--r-- 1 root root 108 Aug 30 15:14 test.sh
[root@wu wu]# ll app/
-rw-r--r-- 1 root root 23 Sep 11 12:00 888.bson.gz
-rw-r--r-- 1 root root 94 Sep 11 12:00 888.metadata.json.gz
-rw-r--r-- 1 root root 23 Sep 11 12:00 bbbb.bson.gz
-rw-r--r-- 1 root root 93 Sep 11 12:00 bbbb.metadata.json.gz
-rw-r--r-- 1 root root 23 Sep 11 12:00 cccccc.bson.gz
-rw-r--r-- 1 root root 93 Sep 11 12:00 cccccc.metadata.json.gz
mongorestore是Mongodb从备份中恢复数据的工具，它主要用来获取mongodump的输出结果，并将备份的数据插入到运行的Mongodb中。
mongorestore命令使用方法以下：
$ mongorestore --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-j, --numParallelCollections= number of collections to restore in parallel (4 by default) 并行恢复的集合数
--恢复test库
$ mongorestore -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test /home/mongod/backup/test/
--恢复test库下的vast集合
$ mongorestore -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -c vast /home/mongod/backup/test/vast.bson
注：--drop表示恢复的时候把以前的集合drop掉
$ mongorestore -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test --drop /home/mongod/backup/test/
$ mongorestore -h 192.168.1.21:30000 -uroot -proot --authenticationDatabase admin -d test -c vast --drop /home/mongod/backup/test/vast.bson
[root@iZuf62o440hd7ir1f41ahdZ mongo-bak]# pwd
/mongo-bak
[root@iZuf62o440hd7ir1f41ahdZ mongo-bak]# ll dump/
total 24
drwxr-xr-x 2 root root 20480 Sep 10 18:02 eduStatistics
drwxr-xr-x 2 root root 4096 Sep 10 18:01 mapList
[root@iZuf62o440hd7ir1f41ahdZ mongo-bak]# mongorestore -h 10.27.120.82:9012 -d eduStatistics --drop dump/eduStatistics/
1. 经常使用命令格式
mongoexport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 -f 字段 -q 条件导出 --csv -o 文件名
参数重点说明：
-f 导出指定字段，以逗号分割，-f uid,name,age导出uid,name,age这三个字段
-q 能够根据查询条件导出，-q '{ "uid" : "100" }' 导出uid为100的数据
--csv 表示导出的文件格式为csv的。这个比较有用，由于大部分的关系型数据库都是支持csv，在这里有共同点
2. 导出整张表
mongoexport -d SERVERLOG -c users -o /data/mongobak/SERVERLOG.bak/users.dat
connected to: 127.0.0.1
exported 4 records
3. 导出表中部分字段
mongoexport -d SERVERLOG -c users --csv -f uid,name,age -o /data/mongobak/SERVERLOG.bak/users.csv
connected to: 127.0.0.1
exported 4 records
4. 根据条件导出数据
mongoexport -d SERVERLOG -c users -q '{uid:{$gt:1}}' -o /data/mongobak/SERVERLOG.bak/users.json
connected to: 127.0.0.1
exported 3 records
1. 经常使用命令格式
恢复整表导出的非csv文件
mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --upsert --drop 文件名
--upsert:插入或者更新现有数据
恢复部分字段的导出文件
mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --upsertFields 字段 --drop 文件名
--upsertFields:更新部分的查询字段，必须为索引,以逗号分隔.
恢复导出的csv文件
mongoimport -h IP --port 端口 -u 用户名 -p 密码 -d 数据库 -c 表名 --type 类型 --headerline --upsert --drop 文件名
--type：导入的文件类型（默认json）
2. 恢复导出的表数据
mongoimport -d SERVERLOG -c users --upsert /data/mongobak/SERVERLOG.bak/users.dat
connected to: 127.0.0.1
Tue Dec 3 08:26:52.852 imported 4 objects
3. 部分字段的表数据导入
mongoimport -d SERVERLOG -c users --upsertFields uid,name,age /data/mongobak/SERVERLOG.bak/users.dat
connected to: 127.0.0.1
Tue Dec 3 08:31:15.179 imported 4 objects
4. 恢复csv文件
mongoimport -d SERVERLOG -c users --type csv --headerline --file /data/mongobak/SERVERLOG.bak/users.csv
connected to: 127.0.0.1
Tue Dec 3 08:37:21.961 imported 4 objects
--file:须要导入的文件
mongodump能够backup整个数据库，而mongoexport要对每一个collection进行操做，
最主要的区别也是选择的标准是mongoexport输出的JSON比Mongodump的BSON可读性更高，
进而能够直接对JSON文件进行操做而后还原数据（BSON转换JSON存在潜在兼容问题）。
为何要监控？
监控及时得到应用的运行状态信息，在问题出现时及时发现。
--被动监控、主动监控
--没有监控（不能及时掌握线上应用情况、问题不能及时发现）
监控什么？
机器资源
--CPU、内存、磁盘I/O
应用程序（MongoDB）
--进程监控（ps -aux）
--错误日志监控
。。。
--查看实例运行状态（内存使用、锁、用户链接等信息）
--经过比对先后快照进行性能分析
db.serverStatus()重要指标：
"connections"
"activeClients"
"locks"
"opcounters"
"opcountersRepl"
"storageEngine" ：查看数据库的存储引擎
"mem"
my_repl:SECONDARY> db.serverStatus().connections
{ "current" : 3, "available" : 816, "totalCreated" : NumberLong(6) }
--查看当前数据库状态。
my_repl:SECONDARY> use app
switched to db app
my_repl:SECONDARY> db.stats()
{
"db" : "app",
"collections" : 8,
"objects" : 2,
"avgObjSize" : 74,
"dataSize" : 148,
"storageSize" : 45056,
"numExtents" : 0,
"indexes" : 8,
"indexSize" : 45056,
"ok" : 1
}
my_repl:SECONDARY>
--实时数据库状态，读写、加锁、索引命中、缺页中断、读写等待队列等状况。
--每秒刷新一次状态值，并能提供良好的可读性，经过这些参数能够观察到MongoDB系统总体性能状况。
mongostat重要指标：
insert：每秒插入量
query：每秒查询量
update：每秒更新量
delete：每秒删除量
command：一秒内执行的命令数
flushes：一秒内flush的次数通常都是0，或者1，经过计算两个1之间的间隔时间，能够大体了解多长时间 flush一次。flush开销是很大的，若是频繁的flush，可能就要找找缘由了。
conn：当前链接数
qr|qw：客户端查询排队长度（读|写）
最好为0，若是有堆积，数据库处理慢。
ar|aw：活跃客户端数量（读|写）
time：当前时间
mongostat -h 192.168.0.3:9012 -uroot -ppasswd --authenticationDatabase admin
[root@local ~]# mongostat -h 192.168.0.3 --port 9012
connected to: 192.168.0.3:9012
insert query update delete getmore command flushes mapped vsize res faults locked db idx miss % qr|qw ar|aw netIn netOut conn time
*0 *0 *0 *0 0 7|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 404b 6k 32 18:20:44
*0 *0 *0 *0 0 2|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 120b 5k 32 18:20:45
*0 *0 *0 *0 0 1|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 62b 5k 32 18:20:46
*0 *0 *0 *0 0 1|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 62b 5k 32 18:20:47
*0 *0 *0 *0 0 3|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 170b 5k 32 18:20:48
*0 *0 *0 *0 0 1|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 62b 5k 32 18:20:49
*0 *0 *0 *0 0 1|0 0 18.7g 37.8g 2.18g 0 local:0.0% 0 0|0 0|0 62b 5k 32 18:20:50
*0 *0 *0 *0 0 2|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 120b 5k 32 18:20:51
*0 *0 *0 *0 0 4|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 233b 5k 32 18:20:52
*0 *0 *0 *0 0 1|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 62b 5k 32 18:20:53
insert query update delete getmore command flushes mapped vsize res faults locked db idx miss % qr|qw ar|aw netIn netOut conn time
*0 *0 *0 *0 0 7|0 0 18.7g 37.8g 2.18g 0 .:0.0% 0 0|0 0|0 404b 6k 32 18:20:54
--提供结合层的统计信息，默认每秒返回值。
mongotop重要指标：
ns：数据库命名空间，后者结合了数据库名称和集合。
total：mongod在这个命令空间上花费的总时间。
read：在这个命令空间上mongod执行读操做花费的时间。
write：在这个命名空间上mongod进行写操做花费的时间。
[root@local ~]# mongotop -h 192.168.0.3:9012
connected to: 192.168.0.3:9012
ns total read write 2018-09-06T10:45:15
eduStatistics.oneExamCnt 0ms 0ms 0ms
eduStatistics.oneExamClassTestRateCnt 0ms 0ms 0ms
eduStatistics.oneExamClassTestRate 0ms 0ms 0ms
eduStatistics.oneExamClassTestOpCnt 0ms 0ms 0ms
eduStatistics.knowledgeUserSubjectRateCnt 0ms 0ms 0ms
eduStatistics.knowledgeUserSubjectRate 0ms 0ms 0ms
eduStatistics.knowledgeUserRateCnt 0ms 0ms 0ms
eduStatistics.knowledgeUserRate 0ms 0ms 0ms
eduStatistics.knowledgeUserCnt 0ms 0ms 0ms
--查看数据库当前执行什么操做。
--用于查看长时间运行进程。
--经过（执行时长、操做、锁、等待锁时长)等条件过滤。
db.currentOp(
{
"waitingForLock" : true,
$or: [
{ "op" : { "$in" : [ "insert", "update", "remove" ] } },
{ "query.findandmodify": { $exists: true } }
]
}
)
--设置server级别慢日志。
一、打开profiling： 0不保存， 1保存慢查询日志， 2保存全部查询日志
注意级别是对应当前的数据库，而阈值是全局的。
二、查看profiling状态
三、查看慢查询：system.profile
四、关闭profiling
硬件。。。（内存、SSD）
收缩数据
增长新的机器、新的副本集
集群分片键选择
chunk大小设置
预分片（预先分配存储空间）
优化查询语句（慢查询日志--分析执行计划）
执行计划（使用explain）
> db.students.find().explain()
{
"cursor" : "BasicCursor",
"isMultiKey" : false,
"n" : 1,
"nscannedObjects" : 1,
"nscanned" : 1,
"nscannedObjectsAllPlans" : 1,
"nscannedAllPlans" : 1,
"scanAndOrder" : false,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 0,
"server" : "SYNC-1:27017",
"filterSet" : false
}
注：
"cursor"：BasicCursor表示没有使用索引,BtreeCursor表示使用了索引。
"n"：表示返回的文档数量。
"nscanned"：表示查询了多少个文档。
"millis"：耗时（毫秒）。
"indexBounds"：所用的索引。