mongodb的监控与性能优化

古城微笑少年丶 2022-08-08 11:56 137阅读 0赞

## 一.mongodb的监控 ##

mongodb可以通过profile来监控数据，进行优化。

查看当前是否开启profile功能用命令

db.getProfilingLevel()  返回level等级，值为0|1|2，分别代表意思：0代表关闭，1代表记录慢命令，2代表全部

开始profile功能为

db.setProfilingLevel(level);  \#level等级，值同上

level为1的时候，慢命令默认值为100ms，更改为db.setProfilingLevel(level,slowms)如db.setProfilingLevel(1,50)这样就更改为50毫秒

通过db.system.profile.find() 查看当前的监控日志。

如：

Js代码   ![收藏代码][icon_star.png]

1.  > db.system.profile.find(\{millis:\{$gt:500\}\})  
2.  \{ "ts" : ISODate("2011-07-23T02:50:13.941Z"), "info" : "query order.order reslen:11022 nscanned:672230  \\nquery: \{ status: 1.0 \} nreturned:101 bytes:11006 640ms", "millis" : 640 \}  
3.  \{ "ts" : ISODate("2011-07-23T02:51:00.096Z"), "info" : "query order.order reslen:11146 nscanned:672302  \\nquery: \{ status: 1.0, user.uid: \{ $gt: 1663199.0 \} \}  nreturned:101 bytes:11130 647ms", "millis" : 647 \}

这里值的含义是

ts：命令执行时间

info：命令的内容

query：代表查询

order.order： 代表查询的库与集合

reslen：返回的结果集大小，byte数

nscanned：扫描记录数量

nquery：后面是查询条件

nreturned：返回记录数及用时

millis：所花时间

如果发现时间比较长，那么就需要作优化。

比如nscanned数很大，或者接近记录总数，那么可能没有用到索引查询。

reslen很大，有可能返回没必要的字段。

nreturned很大，那么有可能查询的时候没有加限制。

mongo可以通过db.serverStatus()查看mongod的运行状态

Js代码   ![收藏代码][icon_star.png]

1.  > db.serverStatus()  
2.  \{  
3.      "host" : "baobao-laptop",\#主机名  
4.      "version" : "1.8.2",\#版本号  
5.      "process" : "mongod",\#进程名  
6.      "uptime" : 15549,\#运行时间  
7.      "uptimeEstimate" : 15351,  
8.      "localTime" : ISODate("2011-07-23T06:07:31.220Z"),当前时间  
9.      "globalLock" : \{  
10.         "totalTime" : 15548525410,\#总运行时间（ns）  
11.         "lockTime" : 89206633,  \#总的锁时间（ns）  
12.         "ratio" : 0.005737305027178137,\#锁比值  
13.         "currentQueue" : \{  
14.             "total" : 0,\#当前需要执行的队列  
15.             "readers" : 0,\#读队列  
16.             "writers" : 0\#写队列  
17.         \},  
18.         "activeClients" : \{  
19.             "total" : 0,\#当前客户端执行的链接数  
20.             "readers" : 0,\#读链接数  
21.             "writers" : 0\#写链接数  
22.         \}  
23.     \},  
24.     "mem" : \{\#内存情况  
25.         "bits" : 32,\#32位系统  
26.         "resident" : 337,\#占有物理内存数  
27.         "virtual" : 599,\#占有虚拟内存  
28.         "supported" : **true**,\#是否支持扩展内存  
29.         "mapped" : 512  
30.     \},  
31.     "connections" : \{  
32.         "current" : 2,\#当前链接数  
33.         "available" : 817\#可用链接数  
34.     \},  
35.     "extra\_info" : \{  
36.         "note" : "fields vary by platform",  
37.         "heap\_usage\_bytes" : 159008,\#堆使用情况字节  
38.         "page\_faults" : 907 \#页面故作  
39.     \},  
40.     "indexCounters" : \{  
41.         "btree" : \{  
42.             "accesses" : 59963, \#索引被访问数  
43.             "hits" : 59963, \#所以命中数  
44.             "misses" : 0,\#索引偏差数  
45.             "resets" : 0,\#复位数  
46.             "missRatio" : 0\#未命中率  
47.         \}  
48.     \},  
49.     "backgroundFlushing" : \{      
50.         "flushes" : 259,  \#刷新次数  
51.         "total\_ms" : 3395, \#刷新总花费时长  
52.         "average\_ms" : 13.108108108108109, \#平均时长  
53.         "last\_ms" : 1, \#最后一次时长  
54.         "last\_finished" : ISODate("2011-07-23T06:07:22.725Z")\#最后刷新时间  
55.     \},  
56.     "cursors" : \{  
57.         "totalOpen" : 0,\#打开游标数  
58.         "clientCursors\_size" : 0,\#客户端游标大小  
59.         "timedOut" : 16\#超时时间  
60.     \},  
61.     "network" : \{  
62.         "bytesIn" : 285676177,\#输入数据（**byte**）  
63.         "bytesOut" : 286564,\#输出数据（**byte**）  
64.         "numRequests" : 2012348\#请求数  
65.     \},  
66.     "opcounters" : \{  
67.         "insert" : 2010000, \#插入操作数  
68.         "query" : 51,\#查询操作数  
69.         "update" : 5,\#更新操作数  
70.         "delete" : 0,\#删除操作数  
71.         "getmore" : 0,\#获取更多的操作数  
72.         "command" : 148\#其他命令操作数  
73.     \},  
74.     "asserts" : \{\#各个断言的数量  
75.         "regular" : 0,  
76.         "warning" : 0,  
77.         "msg" : 0,  
78.         "user" : 2131,  
79.         "rollovers" : 0  
80.     \},  
81.     "writeBacksQueued" : **false**,  
82.     "ok" : 1  
83. \}

db.stats()查看某一个库的原先状况

Java代码   ![收藏代码][icon_star.png]

1.  > db.stats()  
2.  \{  
3.      "db" : "order",\#库名  
4.      "collections" : 4,\#集合数  
5.      "objects" : 2011622,\#记录数  
6.      "avgObjSize" : 111.92214441878245,\#每条记录的平均值  
7.      "dataSize" : 225145048,\#记录的总大小  
8.      "storageSize" : 307323392,\#预分配的存储空间  
9.      "numExtents" : 21,\#事件数  
10.     "indexes" : 1,\#索引数  
11.     "indexSize" : 74187744,\#所以大小  
12.     "fileSize" : 1056702464,\#文件大小  
13.     "ok" : 1  
14. \}

查看集合记录用

Java代码   ![收藏代码][icon_star.png]

1.  > db.order.stats()  
2.  \{  
3.      "ns" : "order.order",\#命名空间  
4.      "count" : 2010000,\#记录数  
5.      "size" : 225039600,\#大小  
6.      "avgObjSize" : 111.96,  
7.      "storageSize" : 307186944,  
8.      "numExtents" : 18,  
9.      "nindexes" : 1,  
10.     "lastExtentSize" : 56089856,  
11.     "paddingFactor" : 1,  
12.     "flags" : 1,  
13.     "totalIndexSize" : 74187744,  
14.     "indexSizes" : \{  
15.         "\_id\_" : 74187744\#索引为\_id\_的索引大小  
16.     \},  
17.     "ok" : 1  
18. \}

mongostat命令查看运行中的实时统计，表示每秒实时执行的次数

mongodb还提供了一个机遇http的监控页面，可以访问http://ip:28017来查看，这个页面基本上是对上面的这些命令做了一下综合，所以这里不细述了。

## 二.mongodb的优化 ##

根据上面这些监控手段，找到问题后，我们可以进行优化

上面找到了某一下慢的命令，现在我们可以通过执行计划跟踪一下，如

Java代码   ![收藏代码][icon_star.png]

1.  > db.order.find(\{ "status": 1.0, "user.uid": \{ $gt: 2663199.0 \} \}).explain()  
2.  \{  
3.      "cursor" : "BasicCursor",\#游标类型  
4.      "nscanned" : 2010000,\#扫描数量  
5.      "nscannedObjects" : 2010000,\#扫描对象  
6.      "n" : 337800,\#返回数据  
7.      "millis" : 2838,\#耗时  
8.      "nYields" : 0,  
9.      "nChunkSkips" : 0,  
10.     "isMultiKey" : **false**,  
11.     "indexOnly" : **false**,  
12.     "indexBounds" : \{\#使用索引（这里没有）  
13.           
14.     \}  
15. \}

对于这样的，我们可以创建索引

可以通过  db.collection.ensureIndex(\{"字段名":1\}) 来创建索引，1为升序，-1为降序，在已经有多数据的情况下，可用后台来执行，语句db.collection.ensureIndex(\{"字段名":1\} , \{backgroud:true\})

获取索引用db.collection.getIndexes() 查看

这里我们创建一个user.uid的索引 >db.order.ensureIndex(\{"user.uid":1\})

创建后重新执行

Java代码   ![收藏代码][icon_star.png]

1.  db.order.find(\{ "status": 1.0, "user.uid": \{ $gt: 2663199.0 \} \}).explain()  
2.  \{  
3.      "cursor" : "BtreeCursor user.uid\_1",  
4.      "nscanned" : 337800,  
5.      "nscannedObjects" : 337800,  
6.      "n" : 337800,  
7.      "millis" : 1371,  
8.      "nYields" : 0,  
9.      "nChunkSkips" : 0,  
10.     "isMultiKey" : **false**,  
11.     "indexOnly" : **false**,  
12.     "indexBounds" : \{  
13.         "user.uid" : \[  
14.             \[  
15.                 2663199,  
16.                 1.7976931348623157e+308  
17.             \]  
18.         \]  
19.     \}  
20. \}

扫描数量减少，速度提高。mongodb的索引设计类似与关系数据库，按索引查找加快书读，但是多了会对写有压力，所以这里就不再叙述了。

2.其他优化可以用hint强制索引查找，返回只是需要的数据，对数据分页等。

原文：http://lavafree.iteye.com/blog/1131312

[icon_star.png]: /images/20220805/e48d0d0f9d8c478da0d58c3838d5afc6.png