mongodb 的使用

install：

1、ubuntu用deb安装。

2、下载压缩文件，绿色的，不用安装。   推荐此方法。

配置dbpath：

1、用deb安装的，会在 /etc 目录下 创建mongodb.conf (若没自动创建，可以自己创建)，这是默认的配置文件，可以配置默认的 dbpath 路径等。

2、若是用的解压版，则即使在 /etc 目录创建 mongodb.conf 文件也无效，只有在命令行用 --dbpath /Volumes/Data/mongodb 指定。或者用 -f /path/to/mongodb.conf  指定配置文件，配置文件里设置 dbpath

 运行mongodb的方式：

./bin/mongod -f mongodb.conf

以下是我自己的 mongodb.conf 文件：

# https://docs.mongodb.com/v3.2/reference/configuration-options/#security.authorization

storage:
    # 注意dbPath的大小写
    dbPath: "/home/hzh/hzh/soft/mongodb_dbpath" 

security:
    authorization: "enabled"

退出mongodb daemon server的方式：

$ ./mongo
> use admin
> db.shutdownServer()

或者：

$ ./mongod -f ../mongodb.conf  --shutdown

或者：

$ mongo --eval "db.getSiblingDB('admin').shutdownServer()"

或者：

kill  pid_number

用户主目录 ~ 下的 ~/.mongorc.js 配置文件（以下是我的示例）:

prompt = function() {
    var db_user = "error occured";
    try {
    var dbname = db.getName();
    var user = db.runCommand({connectionStatus : }).authInfo.authenticatedUsers;

    var user_name = "";
    if (user) {
        user.forEach(function(element) {
            if ( == user_name.length) {
                user_name = element.user;
            } else {
                user_name = user_name + "|" + element.user;
            }
        });
    }

    var dbname_show = "notSelDb";
    if (dbname) {
        dbname_show = dbname;
    }

    var user_show = "noAuth";
    if (user_name.length > ) {
        user_show = user_name;
    }

    db_user = dbname_show + "[" + user_show + "] > ";
    } catch (e) {
    }

    // 捕捉写入错误并打印; 同时有可能在连接断开时自动重连。
    try {
        db.runCommand({getLastError: });
    } catch (e) {
        print(e);
    }

    return db_user;
}

忘记管理密码后怎么恢复：

If you have locked yourself out then you need to do the following:

1、Stop your MongoDB instance
2、Remove the --auth and/or --keyfile options from your MongoDB config to disable authentication
3、Start the instance without authentication
4、Edit the users as needed
5、Restart the instance with authentication enabled

如果你删掉了 admin 数据库：

Deleting admin db means loosing access to all the databases.  how to solve?   Enable localhost authentication bypass(if not enabled) and restart mongod. Now create the users again.

从上可看出，安装完mongodb后，若进而定义了用户，需要在 MongoDB config 文件里指定启动mongodb后必须认证登录才能访问数据库，这才安全。 怎么启用认证，只需要在conf配置文件里加入：

security:
    authorization: enabled

mongodb的管理工具：

1、https://github.com/Studio3T/robomongo

Robo 3T (formerly Robomongo *) is a shell-centric cross-platform MongoDB management tool. Unlike most other MongoDB admin UI tools, Robo 3T embeds the actual mongo shell in a tabbed interface with access to a shell command line as well as GUI interaction.

2、https://github.com/mrvautin/adminMongo

adminMongo is a Web based user interface (GUI) to handle all your MongoDB connections/databases needs

mongodb 的用户管理：

https://docs.mongodb.com/v3.0/tutorial/manage-users-and-roles/

https://docs.mongodb.com/v3.0/reference/built-in-roles/#clusterAdmin

任何database都需要一个用户来对它进行访问，如果没有任何用户对应此database，你就无法访问该database。而任何user都不可能无限制的取得database的权限，因此必须有一个权限系统，也就是role管理。role规定了user对数据库的访问权限。一个user可以被授予多个角色，因而被赋予了对mongodb的资源访问能力和能实施的行为。

The admin database includes the following roles for administering the whole system rather than just a single database.

admin 数据库里包含一系列的角色（如： clusterAdmin， clusterManager， clusterMonitor， hostManager），专为管理整个系统而不管理单个数据库。

The admin database provides the following roles that apply to all databases in a mongod instance and are roughly equivalent to their single-database equivalents

admin 数据库里包含一系列的角色（如： readAnyDatabase， readWriteAnyDatabase， userAdminAnyDatabase， dbAdminAnyDatabase），来管理mongod实例中的所有数据库，相当于把它当成自己的数据库来管理。

注意：在哪个database下创建的user，则这个user就只属于这个database，不属于其它的任何database，在其它database里显示不出不属于自己的user。

mongoDB 3.0 用户权限系统:

MongoDB 3.0 安全权限访问控制，在添加用户上面3.0版本和之前的版本有很大的区别，这里就说明下3.0的添加用户的方法。

环境、测试：

在安装MongoDB之后，先在conf文件里关闭auth认证，进入查看数据库，只有一个local库，admin库是不存在的（也有可能存在）：

root@zhoujinyi:/usr/local/mongo4# mongo --port=
MongoDB shell version: 3.0.
connecting to: 127.0.0.1:/test
--29T09::08.673- I CONTROL  [initandlisten]
> show dbs;
local  .078GB

现在需要创建一个帐号，该账号需要有grant权限，即：账号管理的授权权限。注意一点，帐号是跟着数据库走的，所以在某数据库里授权，必须也在该库里验证(auth)（即登录）。

> use admin
switched to db admin
> db.createUser(
...   {
...     user: "dba",
...     pwd: "dba",
...     roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
...   }
... )
Successfully added user: {
    "user" : "dba",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}

上面加粗的就是执行的命令：

user：用户名

pwd：密码

roles：指定用户的角色，可以用一个空数组给新用户设定空角色；在roles字段,可以指定内置角色和用户定义的角色。role里的角色可以选：

Built-In Roles（内置角色）：
    . 数据库用户角色：read、readWrite;
    . 数据库管理角色：dbAdmin、dbOwner、userAdmin；
    . 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
    . 备份恢复角色：backup、restore；
    . 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
    . 超级用户角色：root
    // 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
    . 内部角色：__system

具体角色：

Read：允许用户读取指定数据库
readWrite：允许用户读写指定数据库
dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile
userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户
clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。
readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限
readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限
userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。
root：只在admin数据库中可用。超级账号，超级权限

刚建立了 userAdminAnyDatabase 角色，用来管理用户，可以通过这个角色来创建、删除用户。验证：需要开启auth参数。

root@zhoujinyi:/usr/local/mongo4# mongo --port=
MongoDB shell version: 3.0.
connecting to: 127.0.0.1:/test
> show dbs;               ####没有认证，导致没权限。
--29T10::16.634- E QUERY    Error: listDatabases failed:{
    "ok" : ,
    "errmsg" : "not authorized on admin to execute command { listDatabases: 1.0 }",
    "code" :
}
    at Error (<</span>anonymous>)
    at Mongo.getDBs (src/mongo/shell/mongo.js::)
    at shellHelper.show (src/mongo/shell/utils.js::)
    at shellHelper (src/mongo/shell/utils.js::)
    at (shellhelp2):: at src/mongo/shell/mongo.js:
> use admin        #认证，因为在admin下面添加的帐号，所以要到admin下面认证。
switched to db admin
> db.auth('dba','dba')               # db.logout() 是登出当前认证了的用户 (##注意，每个用户都是只属于某个数据库的，没切换到哪个数据库，你无法对属于该数据库的用户进行登录与登出)

> show dbs;
admin  .078GB
local  .078GB
> use test        #在test库里创建帐号
switched to db test
> db.createUser(
...     {
...       user: "zjyr",
...       pwd: "zjyr",
...       roles: [
...          { role: "read", db: "test" }    #只读帐号
...       ]
...     }
... )
Successfully added user: {
    "user" : "zjyr",
    "roles" : [
        {
            "role" : "read",
            "db" : "test"
        }
    ]
}
> db.createUser(
...     {
...       user: "zjy",
...       pwd: "zjy",
...       roles: [
...          { role: "readWrite", db: "test" }   #读写帐号
...       ]
...     }
... )
Successfully added user: {
    "user" : "zjy",
    "roles" : [
        {
            "role" : "readWrite",                #读写账号
            "db" : "test"
        }
    ]
}
> show users;                                    #查看当前库下的用户
{
    "_id" : "test.zjyr",
    "user" : "zjyr",
    "db" : "test",
    "roles" : [
        {
            "role" : "read",
            "db" : "test"
        }
    ]
}
{
    "_id" : "test.zjy",
    "user" : "zjy",
    "db" : "test",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        }
    ]
}

上面创建了2个帐号，现在验证下：验证前提需要一个集合（collection）

> db.abc.insert({"a":,"b":})              #插入失败，没有权限，userAdminAnyDatabase 权限只是针对用户管理的，对其他是没有权限的。
WriteResult({
    "writeError" : {
        "code" : ,
        "errmsg" : "not authorized on test to execute command { insert: "abc", documents: [ { _id: ObjectId('55915185d629831d887ce2cb'), a: 1.0, b: 2.0 } ], ordered: true }"
    }
})
>
bye
root@zhoujinyi:/usr/local/mongo4# mongo --port=
MongoDB shell version: 3.0.
connecting to: 127.0.0.1:/test
> use test
switched to db test
> db.auth('zjy','zjy')       #用创建的readWrite帐号进行写入

> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })
> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })
> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })
> db.abc.find()
{ "_id" : ObjectId("559151a1b78649ebd8316853"), "a" : , "b" :  }
{ "_id" : ObjectId("559151cab78649ebd8316854"), "a" : , "b" :  }
{ "_id" : ObjectId("559151ceb78649ebd8316855"), "a" : , "b" :  }
> db.auth('zjyr','zjyr')       #切换到只有read权限的帐号

> db.abc.insert({"a":,"b":})  #不能写入
WriteResult({
    "writeError" : {
        "code" : ,
        "errmsg" : "not authorized on test to execute command { insert: "abc", documents: [ { _id: ObjectId('559151ebb78649ebd8316856'), a: 1111.0, b: 2222.0 } ], ordered: true }"
    }
})
> db.abc.find()        #可以查看
{ "_id" : ObjectId("559151a1b78649ebd8316853"), "a" : , "b" :  }
{ "_id" : ObjectId("559151cab78649ebd8316854"), "a" : , "b" :  }
{ "_id" : ObjectId("559151ceb78649ebd8316855"), "a" : , "b" :  }

有没有一个超级权限？不仅可以授权，而且也可以对集合进行任意操作？答案是肯定的，只是不建议使用。那就是role角色设置成root。

> db.auth('dba','dba')

> db.createUser(
...  {
...    user: "zhoujinyi",
...    pwd: "zhoujinyi",
...    roles: [
...       { role: "root", db: "admin" }      #超级root帐号
...    ]
...  }
... )
Successfully added user: {
    "user" : "zhoujinyi",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
>
> show users;              #查看当前库下的用户
{
    "_id" : "admin.dba",
    "user" : "dba",
    "db" : "admin",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.zhoujinyi",
    "user" : "zhoujinyi",
    "db" : "admin",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
> use admin
switched to db admin
> db.auth('zhoujinyi','zhoujinyi')

> use test
switched to db test
> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })
> db.abc.insert({"a":,"b":})          #权限都有
WriteResult({ "nInserted" :  })
> db.abc.find()
{ "_id" : ObjectId("5591539bb78649ebd8316857"), "a" : , "b" :  }
{ "_id" : ObjectId("559153a0b78649ebd8316858"), "a" : , "b" :  }
> db.abc.remove({})
WriteResult({ "nRemoved" :  })

因为帐号都是在当前需要授权的数据库下授权的，那要是不在当前数据库下会怎么样？

> db
admin
> db.createUser(
...  {
...    user: "dxy",
...    pwd: "dxy",
...    roles: [
...       { role: "readWrite", db: "test" },     #在当前库下创建其他库的帐号，在admin库下创建test、abc库的帐号
...       { role: "readWrite", db: "abc" }
...    ]
...  }
... )
Successfully added user: {
    "user" : "dxy",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        },
        {
            "role" : "readWrite",
            "db" : "abc"
        }
    ]
}
>
> show users;
{
    "_id" : "admin.dba",
    "user" : "dba",
    "db" : "admin",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.zhoujinyi",
    "user" : "zhoujinyi",
    "db" : "admin",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.dxy",
    "user" : "dxy",
    "db" : "admin",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        },
        {
            "role" : "readWrite",
            "db" : "abc"
        }
    ]
}
> use test
switched to db test
> db.auth('dxy','dxy')          #在admin下创建的帐号，不能直接在其他库验证，
Error:  Authentication failed.

> use admin
switched to db admin            #只能在帐号创建库下认证，再去其他库进行操作。
> db.auth('dxy','dxy')

> use test
switched to db test
> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })
> use abc
switched to db abc
> db.abc.insert({"a":,"b":})
WriteResult({ "nInserted" :  })

上面更加进一步说明数据库的用户帐号(user)是跟着数据库走的，哪个数据库里创建的用户必须到哪个数据库下去认证登录登出。

创建了这么多帐号，怎么查看所有帐号？

>  use admin
switched to db admin
> db.auth('dba','dba')

> db.system.users.find().pretty()
{
    "_id" : "admin.dba",
    "user" : "dba",
    "db" : "admin",
    "credentials" : {
        "SCRAM-SHA-1" : {
            "iterationCount" : ,
            "salt" : "KfDUzCOIUo7WVjFr64ZOcQ==",
            "storedKey" : "t4sPsKG2dXnZztVYj5EgdUzT9sc=",
            "serverKey" : "2vCGiq9NIc1zKqeEL6VvO4rP26A="
        }
    },
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "test.zjyr",
    "user" : "zjyr",
    "db" : "test",
    "credentials" : {
        "SCRAM-SHA-1" : {
            "iterationCount" : ,
            "salt" : "h1gOW3J7wzJuTqgmmQgJKQ==",
            "storedKey" : "7lkoANdxM2py0qiDBzFaZYPp1cM=",
            "serverKey" : "Qyu6IRNyaKLUvqJ2CAa/tQYY36c="
        }
    },
    "roles" : [
        {
            "role" : "read",
            "db" : "test"
        }
    ]
}
{
    "_id" : "test.zjy",
    "user" : "zjy",
    "db" : "test",
    "credentials" : {
        "SCRAM-SHA-1" : {
            "iterationCount" : ,
            "salt" : "afwaKuTYPWwbDBduQ4Hm7g==",
            "storedKey" : "ebb2LYLn4hiOVlZqgrAKBdStfn8=",
            "serverKey" : "LG2qWwuuV+FNMmr9lWs+Rb3DIhQ="
        }
    },
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        }
    ]
}
{
    "_id" : "admin.zhoujinyi",
    "user" : "zhoujinyi",
    "db" : "admin",
    "credentials" : {
        "SCRAM-SHA-1" : {
            "iterationCount" : ,
            "salt" : "pE2cSOYtBOYevk8tqrwbSQ==",
            "storedKey" : "TwMxdnlB5Eiaqg4tNh9ByNuUp9A=",
            "serverKey" : "Mofr9ohVlFfR6/md4LMRkOhXouc="
        }
    },
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.dxy",
    "user" : "dxy",
    "db" : "admin",
    "credentials" : {
        "SCRAM-SHA-1" : {
            "iterationCount" : ,
            "salt" : "XD6smcWX4tdg/ZJPoLxxRg==",
            "storedKey" : "F4uiayykHDp/r9krAKZjdr+gqjM=",
            "serverKey" : "Kf51IU9J3RIrB8CFn5Z5hEKMSkw="
        }
    },
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        },
        {
            "role" : "readWrite",
            "db" : "abc"
        }
    ]
}
> db.system.users.find().count()

备份还原使用那个角色的帐号？之前创建的帐号zjy:test库读写权限；zjyr:test库读权限

root@zhoujinyi:~# mongodump --port= -uzjyr -pzjyr --db=test -o backup   #只要读权限就可以备份
--29T11::04.864-    writing test.abc to backup/test/abc.bson
--29T11::04.865-    writing test.abc metadata to backup/test/abc.metadata.json
--29T11::04.866-    done dumping test.abc
--29T11::04.867-    writing test.system.indexes to backup/test/system.indexes.bson

root@zhoujinyi:~# mongorestore --port= -uzjy -pzjy --db=test backup/test/  #读写权限可以进行还原
--29T11::26.607-    building a list of collections to restore from backup/test/ dir
--29T11::26.609-    reading metadata file from backup/test/abc.metadata.json
--29T11::26.609-    restoring test.abc from file backup/test/abc.bson
--29T11::26.611-    error: E11000 duplicate key error index: test.abc.$_id_ dup key: { : ObjectId('559154efb78649ebd831685a') }
--29T11::26.611-    restoring indexes for collection test.abc from metadata
--29T11::26.612-    finished restoring test.abc
--29T11::26.612-    done

mongodb 的性能简介：

使用mongodb最多的是用于查询，确实，作为nosql数据库，查询的效率确实高于关系型数据库，这个无可厚非，但是我们还是有必要用到关系型数据库，sql server,  MySQL 或者 Oracle。毕竟关系型数据库存在了这么多年，还是比较稳定和安全的。我现在做的是所有的数据都存了两份，一份是放在mysql里面，一份是放在mongodb里面，但是放在mysql里面的数据只是插入，没有用于查询，查询一般都在mongodb里面查询，除非特殊的情况，我才会去mysql里面查询数据，一般这样的数据就是属于比较敏感的数据，还是查询mysql比较靠谱，但是有的数据，我就没有存在mysql里面了，直接存在mongodb里面，就比如，向用户的评论这些东西，没必要存在数据库。

使用mongodb，我用的比较多的还是他的集合查询，mongodb的查询配合linq，简直不要太爽了，有兴趣的朋友可以去看一下，相关的文章。

写到这里，我还想谈一下，我设计数据库的思路。我一般设计数据库，不管什么表都有一个ID，主键ID， 这个ID是自增长的，我设计的一个方针就是，尽量避免表与表之间的join查询，如果每个表搞个ID，又是主键，查询起来还是比较节省性能的。join查询，表与表之间的关联，又耗性能不说，还把数据库设计的相当之复杂，增加了开发的难度。

mongodb 的索引的失效机制大概是这样的：

为集合创建一个indexes（索引）

然后确保每次插入数据的时候有该列,mongodb将会自动为你删除该列

mongodb 的缓存大小(working set size):

mongodb 是不能配置缓存大小的，一直吃内存。因为MongoDB并不干涉内存管理工作，而是把这些工作留给操作系统的虚拟内存管理器去处理，这样做的好处是简化了MongoDB的工作，但坏处是你没有方法很方便的控制MongoDB占多大内存，幸运的是虚拟内存管理器的存在让我们多数时候并不需要关心这个问题。

以下是详情：

但凡初次接触MongoDB的人，无不惊讶于它对内存的贪得无厌，至于个中缘由，我先讲讲Linux是如何管理内存的，再说说MongoDB是如何使用内存的，答案自然就清楚了。

据说带着问题学习更有效，那就先看一个MongoDB服务器的top命令结果：

shell> top -p $(pidof mongod)

Mem:  32872124k total, 30065320k used,  2806804k free,   245020k buffers

Swap:  2097144k total,      100k used,  2097044k free, 26482048k cached

VIRT  RES  SHR %MEM

1892g  21g  21g 69.6

这台MongoDB服务器有没有性能问题？大家可以一边思考一边继续阅读。

先讲讲Linux是如何管理内存的

在Linux里（别的系统也差不多），内存有物理内存和虚拟内存之说，物理内存是什么自然无需解释，虚拟内存实际是物理内存的抽象，多数情况下，出于方便性的考虑，程序访问的都是虚拟内存地址，然后操作系统会通过Page Table机制把它翻译成物理内存地址，详细说明可以参考Understanding Memory和Understanding Virtual Memory，至于程序是如何使用虚拟内存的，可以参考Playing with Virtual Memory，这里就不多费口舌了。

很多人会把虚拟内存和Swap混为一谈，实际上Swap只是虚拟内存引申出的一种技术而已：操作系统一旦物理内存不足，为了腾出内存空间存放新内容，就会把当前物理内存中的内容放到交换分区里，稍后用到的时候再取回来，需要注意的是，Swap的使用可能会带来性能问题，偶尔为之无需紧张，糟糕的是物理内存和交换分区频繁的发生数据交换，这被称之为Swap颠簸，一旦发生这种情况，先要明确是什么原因造成的，如果是内存不足就好办了，加内存就可以解决，不过有的时候即使内存充足也可能会出现这种问题，比如MySQL就有可能出现这样的情况，一个可选的解决方法是限制使用Swap：

shell> sysctl -w vm.swappiness=0

查看内存情况最常用的是free命令：

shell> free -m

total       used       free     shared    buffers     cached

Mem:         32101      29377       2723          0        239      25880

-/+ buffers/cache:       3258      28842

Swap:         2047          0       2047

新手看到used一栏数值偏大，free一栏数值偏小，往往会认为内存要用光了。其实并非如此，之所以这样是因为每当我们操作文件的时候，Linux都会尽可能的把文件缓存到内存里，这样下次访问的时候，就可以直接从内存中取结果，所以cached一栏的数值非常的大，不过不用担心，这部分内存是可回收的，操作系统的虚拟内存管理器会按照LRU算法淘汰冷数据。还有一个buffers，也是可回收的，不过它是保留给块设备使用的。

知道了原理，我们就可以推算出系统可用的内存是free + buffers + cached：

shell> echo $((2723 + 239 + 25880))

28842

至于系统实际使用的内存是used – buffers – cached：

shell> echo $((29377 - 239 - 25880))

3258

除了free命令，还可以使用sar命令：

shell> sar -r

kbmemfree kbmemused  %memused kbbuffers  kbcached

3224392  29647732     90.19    246116  26070160

shell> sar -W

pswpin/s pswpout/s

0.00      0.00

希望你没有被%memused吓到，如果不幸言中，重读本文。

再说说MongoDB是如何使用内存的

目前，MongoDB使用的是内存映射存储引擎，它会把数据文件映射到内存中，如果是读操作，内存中的数据起到缓存的作用，如果是写操作，内存还可以把随机的写操作转换成顺序的写操作，总之可以大幅度提升性能。MongoDB并不干涉内存管理工作，而是把这些工作留给操作系统的虚拟内存管理器去处理，这样做的好处是简化了MongoDB的工作，但坏处是你没有方法很方便的控制MongoDB占多大内存，幸运的是虚拟内存管理器的存在让我们多数时候并不需要关心这个问题。

MongoDB的内存使用机制让它在缓存重建方面更有优势，简而言之：如果重启进程，那么缓存依然有效，如果重启系统，那么可以通过拷贝数据文件到/dev/null的方式来重建缓存，更详细的描述请参考：Cache Reheating – Not to be Ignored。

有时候，即便MongoDB使用的是64位操作系统，也可能会遭遇OOM问题，出现这种情况，多半是因为限制了内存的大小所致，可以这样查看当前值：

shell> ulimit -a | grep memory

多数操作系统缺省都是把它设置成unlimited的，如果你的操作系统不是，可以这样修改：

shell> ulimit -m unlimited

shell> ulimit -v unlimited

注：ulimit的使用是有上下文的，最好放在MongoDB的启动脚本里。

有时候，MongoDB连接数过多的话，会拖累性能，可以通过serverStatus查询连接数：

mongo> db.serverStatus().connections

每个连接都是一个线程，需要一个Stack，Linux下缺省的Stack设置一般比较大：

shell> ulimit -a | grep stack

stack size              (kbytes, -s) 10240

至于MongoDB实际使用的Stack大小，可以用如下命令确认（单位：K）：

shell> cat /proc/$(pidof mongod)/limits | grep stack | awk -F 'size' '{print int($NF)/1024}'

如果Stack过大（比如：10240K）的话没有意义，简单对照命令结果中的Size和Rss：

shell> cat /proc/$(pidof mongod)/smaps | grep 10240 -A 10

所有连接消耗的内存加起来会相当惊人，推荐把Stack设置小一点，比如说1024：

shell> ulimit -s 1024

注：从MongoDB1.8.3开始，MongoDB会在启动时自动设置Stack。

有时候，出于某些原因，你可能想释放掉MongoDB占用的内存，不过前面说了，内存管理工作是由虚拟内存管理器控制的，幸好可以使用MongoDB内置的closeAllDatabases命令达到目的：

mongo> use admin

mongo> db.runCommand({closeAllDatabases:1})

另外，通过调整内核参数drop_caches也可以释放缓存：

shell> sysctl -w vm.drop_caches=1

平时可以通过mongo命令行来监控MongoDB的内存使用情况，如下所示：

mongo> db.serverStatus().mem:

{

"resident" : 22346,

"virtual" : 1938524,

"mapped" : 962283

}

还可以通过mongostat命令来监控MongoDB的内存使用情况，如下所示：

shell> mongostat

mapped  vsize    res faults

940g  1893g  21.9g      0

其中内存相关字段的含义是：

mapped：映射到内存的数据大小

visze：占用的虚拟内存大小

res：占用的物理内存大小

注：如果操作不能在内存中完成，结果faults列的数值不会是0，视大小可能有性能问题。

在上面的结果中，vsize是mapped的两倍，而mapped等于数据文件的大小，所以说vsize是数据文件的两倍，之所以会这样，是因为本例中，MongoDB开启了journal，需要在内存里多映射一次数据文件，如果关闭journal，则vsize和mapped大致相当。

如果想验证这一点，可以在开启或关闭journal后，通过pmap命令来观察文件映射情况：

shell> pmap $(pidof mongod)

到底MongoDB配备多大内存合适？宽泛点来说，多多益善，如果要确切点来说，这实际取决于你的数据及索引的大小，内存如果能够装下全部数据加索引是最佳情况，不过很多时候，数据都会比内存大，比如本文所涉及的MongoDB实例：

mongo> db.stats()

{

"dataSize" : 1004862191980,

"indexSize" : 1335929664

}

本例中索引只有1G多，内存完全能装下，而数据文件则达到了1T，估计很难找到这么大内存，此时保证内存能装下热数据即可，至于热数据是多少，取决于具体的应用，你也可以通过观察faults的大小来判断当前内存是否能够装下热数据，如果faults持续变大，就说明当前内存已经不能满足热数据的大小了。如此一来内存大小就明确了：内存 > 索引 + 热数据，最好有点富余，毕竟操作系统本身正常运转也需要消耗一部分内存。

关于MongoDB与内存的话题，大家还可以参考官方文档中的相关介绍。