xshell 怎么在服务器上安装mongodb

1 复制Mongodb到指定服务器

到mongodb官方网站http://wwwmongodborg/downloads下载mongodb，解压并将目录考到需要安装的服务器上，然后进行配置。例如：

复制代码 代码如下:

[root@SHNHDX17-165 ~]# scp -r root@1031880:/data/web/dxm/mongodb/mongodb-linux-x86_64-245 data/web/

会将mongodb目录copy到101117165服务器的 ~/data/web目录下。

2 建立数据、日志目录

进入mongodb根目录，新建一个data目录存放数据、新建一个log目录存放日志，然后在该目录下新建一个日志文件，例如命名为mongodblog。

复制代码 代码如下:

[root@SHNHDX17-165 mongodb]# mkdir data

[root@SHNHDX17-165 mongodb]# mkdir logs

[root@SHNHDX17-165 mongodb]# cd logs

[root@SHNHDX17-165 logs]# touch mongodblog

3创建配置文件

在mongodb根目录新建一个配置文件，文件名任意，例如mongodbconf，然后在配置文件中添加配置信息：

复制代码 代码如下:

port=27017 代表端口号，如果不指定则默认为 27017

dbpath=/root/data/web/mongodb/data/ 数据库路径

logpath=/root/data/web/mongodb/logs/mongodblog 日志路径

logappend=true 日志文件自动累加，而不是覆盖

4启动Mongodb服务（根据配置文件）

执行命令

复制代码 代码如下:

[root@SHNHDX17-165 mongodb]# /bin/mongod -f mongodbconf

会出现以下信息：

复制代码 代码如下:

all output going to: /root/data/web/mongodb/logs/mongodblog

5使用客户端来连接该数据库

重新开启一个终端，然后切换到mongodb目录下

复制代码 代码如下:

[root@SHNHDX17-164 ~]# cd data/web/mongodb

然后输入

复制代码 代码如下:

[root@SHNHDX17-164 mongodb]# bin/mongo localhost:27017

MongoDB shell version: 245

connecting to: localhost:27017/test

Server has startup warnings:

Fri Nov 8 13:05:59823 [initandlisten]

Fri Nov 8 13:05:59823 [initandlisten] WARNING: You are running on a NUMA machine

Fri Nov 8 13:05:59823 [initandlisten] We suggest launching mongod like this to avoid performance problems:

Fri Nov 8 13:05:59823 [initandlisten] numactl --interleave=all mongod [other options]

Fri Nov 8 13:05:59823 [initandlisten]

>

连接成功。

6配置自启动（可选）

设置开机自动启动Mongodb

复制代码 代码如下:

[root@SHNHDX17-165 ~]# echo "/root/data/web/mongodb/bin/mongod -f

/root/data/web/mongodb/mongodbconf -fork " >> /etc/rclocal

设置环境变量

复制代码 代码如下:

vi ~/bash_profile

PATH=$PATH:$HOME/bin:$JAVA_HOME/bin:/root/data/web/mongodb/bin

mongo副本集/复制集是mongo高可用性特征之一，是有自动故障恢复功能的主要集群。由一个Primary节点和一个或多个Secondary节点组成。

复制是在多台服务器之间同步数据的过程，由一组Mongod实例（进程）组成，包含一个Primary节点和多个Secondary节点

Mongodb Driver（客户端）的所有数据都写入Primary，Secondary从Primary同步写入的数据

通过上述方式来保持复制集内所有成员存储相同的数据集，提供数据的高可用

Failover （故障转移，故障切换，故障恢复）

Redundancy（数据冗余）

避免单点，用于灾难时恢复，报表处理，提升数据可用性

读写分离，分担读压力

对用户透明的系统维护升级

主节点记录所有的变更到oplog日志

辅助节点(Secondary)复制主节点的oplog日志并且将这些日志在辅助节点进行重放(做)

各个节点之间会定期发送心跳信息，一旦主节点宕机，则触发选举一个新的主节点，剩余的辅助节点指向新的主

10s内各辅助节点无法感知主节点的存在，则开始触发选举

通常1分钟内完成主辅助节点切换，10-30s内感知主节点故障，10-30s内完成选举及切换

用户恢复数据，防止数据丢失，实现灾难恢复

人为误操作导致数据删除，程序Bug导致数据损坏等

首要复制节点，由选举产生，提供读写服务的节点，产生oplog日志

备用(辅助)复制节点，Secondary可以提供读服务，增加Secondary节点可以提供复制集的读服务能力

在故障时，备用节点可以根据设定的优先级别提升为首要节点。提升了复制集的可用性

Arbiter节点只参与投票，不能被选为Primary，并且不从Primary同步数据

Arbiter本身不存储数据，是非常轻量级的服务。

当复制集成员为偶数时，最好加入一个Arbiter节点，以提升复制集可用性

Mongodb版本30以上, 三台服务器均为64位

三台服务器    --------  Primary（Centos7)、 Secondary（Centos7)、 Secondary(Debian8)；架设IP分别为 19216811、12、 13

三台服务器关闭防火墙    -------- systemctl  stop firewalldservice

三台服务器修改mongo配置文件    --------  vi  /etc/mongodconf 

        侦听地址除了 localhost 外再加上服务器IP； 设置复制集名字（RepliSetName）。

开启mongod服务： mongod

三台服务器mongo各自初始化： rsinitiate()

Primary上副本集配置：

rsconf(配置名称，可随意取)={_id:"副本集名",member:[{_id:0,host:"IP:port",priority:2},{_id:1,host:"IP:port",priority:1},{_id:2,host:"IP:port",priority:1}]}

在初始化：rsinitiate(变量名，如下面的config)

Secondary上配置：

rsslaveOk()    #承认自己是Secondary

三台服务器上互相添加副本集成员：

rsadd("IP:port")， 如在Primary上 rsadd("19216812:27017"), rsadd("19216813:27017")

查看状态

rsstatus()

3、rs(replication set) 常用命令：

初始化副本集  ----  rsinitiate()

mongo查看状态 ---- rsstatus()

初始化副本集配置

rsconf = {_id: "rs0",

members: [{

_id: 0,

host: ":27017"}]}

rsinitiate( rsconf )

验证副本集配置  ----  rsconfig()

增加副本集成员  ----  rsadd("Ip:port")

移除副本集成员  ----  rsremove("IP:port")    #此步骤在Primary上操作

改变成员变量的优先级

cfg = rsconf()

cfgmembers[0]priority = 3

cfgmembers[1]priority = 1

cfgmembers[2]priority = 2

rsreconfig(cfg)

配置延迟副本集

cfg = rsconf()

cfgmembers[0]priority = 0

cfgmembers[0]hidden = true

cfgmembers[0]slaveDelay = 3600

rsreconfig(cfg)

#  07/03/2017

1启停止MongoDB

执行mongod,启MongoDB服务器mongod选项命令执行 mongod --help

主要选项：

--dbpath

指定数据目录默认值C:\data\db每mongod进程都需要独立数据目录要3mongod

实例必须3独立数据目录mongod启数据库目录创建mongodlock文件

文件用于防止其mongod纯净使用该数据目录

--port

指定服务器监听端口号默认端口27017要运行mongod进程则要给每指定同端口号

--logpath

指定志输路径文件夹读写权限系统文件存创建已文件覆盖掉

清除所原志记录想要保留原志需使用--logappend选项

--config

指定配置文件加载命令行未指定各种选项

2配置文件启

MongoDB支持文件获取配置信息需要配置非或者要自化MongoDB启用

指定配置文件用-f或--config选项

:

mongod --config refactorConfigtxt

refactorConfigtxt内容:

#start MongoDB

port = 10000

dbpath = "f:\mongo\db"

logpath = "f:\mongo\log\MongoDBtxt"

rest = true

配置文件命令行功能

mongod --dbpath "f:\mongo\db" --logpath "f:\mongo\log\MongoDBtxt" --rest --port 10000

配置文件特点:

a#行注释

b指定选项语种"选项=值"形式选项区写

c命令行--rest关选项,值要设true

3停止MongoDB

使用shutdown命令{"shutdown":1},命令要admin数据库使用shell提供辅助函数:

use admin

dbshutdownServer()

4 监控

使用管理接口,默认情况,启mongod启基本http服务器,该服务默认端口28017浏览器输入

localhost:28017些链接需要mongod启,用--rest选项启rest支持 才能进启rest支持,

mongod启使用--nohttpinterface关闭管理接口

5serverStatus

要获取运行MongoDB服务器统计信息,基本工具serverStatus命令

dbrunCommand({"serverStatus":1})

serverStatus返键解释:

"globalLock"值表示全局写入锁占用服务器少间(单位微秒)

"mem"包含服务器内存映射少数据,服务器进程虚拟内存驻内存占用情况(单位MB)

"indexCounters"表示B树磁盘检索("misses")内存检索("hits")数比值始升,要考虑加内存

"backgroundFlushing"表示台做少fsync及用少间

"opcounters"文档包含每种主要操作数

"asserts"统计断言数

6mongostat

serverStatus虽强,服务器监控说容易MongoDB提供mongostat

mongostat输些serverStatus提供重要信息,每秒输新行,比前看静态数据实性要

输列,别 inserts/s commands/s vsize %locked,与serverStatus数据相应

使用第三插件进行数据库监控

7安全认证

认证基础知识

每MongoDB实例数据库都用户,启安全性检查,数据库认证用户才能执行读或写操作

认证文,MongoDB普通数据作admin数据库处理admin数据库用户称超级用户(管理员)

认证,管理员读写所数据库,执行特定管理命令,listDatabasesshutdown

启安全检查前,至少要管理员帐号,shell连接没启安全检查服务器

面添加管理员refactor_root,test数据库添加两普通账号,其读权限shell创建读用户要

addUser第三参数设true调用addUser必须响应数据库写权限所数据库调用addUser,

没启安全检查

重启数据库,重启加入 --auth 命令行选项,启安全检查

第连接,能test数据库执行任何操作,作读用户认证,能查找,能插入数据能读写用户认证,能查找插入

数据,能使用show dbs 列举所数据库超级用户认证,所欲

8认证工作原理

数据库用户帐号文档形式存储systemusers集合文档结构

{

"_id" : ObjectId("5006a037dff37e149322fd83"),

"user" : "refactor_read_write",

"readOnly" : false,

"pwd" : "5a84584ac51d3f702461fce4c46b0d6b"//根据用户名密码散列

}

知道用户信息何存储及存储位置,进行管理工作

删除帐户:

> dbsystemusersremove({"user":"refactor_read"})

> dbauth("refactor_read","refactor")

0

用户认证,服务器认证连接绑定跟踪认证,说驱程序或工具使用连接池或故障切换

另节点,所认证用户必须每新连接重新认证

MongoDB传输协议加密,需加密,用ssh隧道或者类似技术做客户端服务器间加密

建议MongoDB服务器放防火墙或放应用服务器能访问网络MongoDB必须能外面访问,

建议使用--bindip选项,指定mongod绑定本ip址:能本机应用服务器访问,使用

mongod --bindip localhost

默认情况MongoDB启简单http服务器,便于查看运行,锁,复制等面信息,要想公些信息,用

--nohttpinterface关闭管理接口

用--noscripting完全禁止服务端javascript执行

9备份修复

MongoDB所数据都存放 数据目录 ,默认目录C:\data\db\启MongoDB候用--dbpath指定数据目录

论数据目录哪,都存放着MongoDB所数据要想备份MongoDB,要简单复制数据目录所文件即

除非服务器做完整fsync,允许写入,否则运行MongoDB创建数据目录副本并安全,备份能已经

破损,需要修复

运行MongoDB创建数据目录副本并安全,所先服务器关,再复制数据目录关闭数据库要停止业务

10mongodumpmongorestore

mongodump种能运行备份mongodump运行MongoDB做查询,所查文档写入磁盘

mongodump般客户端,所供运行MongoDB使用,即便处理其请求或执行写入没问题

mongodump使用普通查询机制,所产备份定服务器数据实快照服务器备份程处理写入,非明显

mongodump备份查询其客户端性能产影响

mongodump --help 获帮助

mongorestore备份恢复数据工具

mongorestore获取mongodump 输结,并备份数据插入运行MongoDB实例

:数据库test备份backup目录

mongodump -d test -o backup

使用mongorestore 恢复testNew 数据库

mongorestore -d testNew --drop backup/test/

-d指定要恢复数据库--drop指恢复前删除集合(若存),否则数据与现集合数据合并,能覆盖些文档

使用mongorestore --help获帮助信息

11fsync锁

虽使用mongodumpmongorestore能停机备份,却失获取实数据视图能力MongoDBfsync命令

能MongoDB运行复制数据目录损坏数据

fsync命令强制服务器所缓冲区写入磁盘选择锁住址数据库进步写入,知道释放锁止写入锁让

fsync备份发挥作用关键

shell,强制执行fsync并获写入锁:

dbrunCommand({"fsync":1,"lock":1})

,数据目录数据致,且数据实快照锁,安全数据目录副本作备份要数据库运行

快照功能文件系统,比LVM,EBS,用,拍数据库目录快照快

备份,解锁:

db$cmdsysunlockfindOne()

dbcurrentOp()

运行dbcurrentOp()确保已经解锁(初请求解锁花点间)

fsync命令,能非灵备份,用停掉服务器,用牺牲备份实性能要付代价些写入操作

暂阻塞唯耽误读写能保证实快照备份式通服务器备份

12属备份

虽面备份式灵,都没服务器备份复制式运行MongoDB,前面提备份技术仅能用

主服务器,用服务器服务器数据几乎与主服务器同步太乎属服务器性能或者能能读写,

于能随意选择面3种备份式:关停,转存或恢复工具或fsync命令服务器备份MongoDB推荐备份式

13修复

MongoDB存储式能保证磁盘数据能用,能损毁MongoDB内置修复功能试着恢复损坏数据文件

未停止MongoDB应该修复数据库修复数据库式简单 mongod --repair 启服务器

修复数据库实际程简单:所文档导马导入,忽略效文档完,重建索引数据量,花间,

所数据都要验证,所索引都要重建(MongoDB 18 版本引入志系统,使修复间打打缩短)

修复能比修复前少些文档,损坏文档删除

修复数据库能起压缩数据作用闲置控件(删除体积较集合,或删除量文档腾空间)修复重新利用

修复运行服务器数据库,要shell用repairDatabases

use test

dbrepairDatabase()

分片是MongoDB提供的一种机制，其可以将大型的集合分割保存到不同的服务器上。与其他的分区方案相比，MongoDB几乎能自动为我们完成所有事情。只要我们进行简单的配置，并告诉MongoDB要分配的数据，它就可以自动维护数据在不同服务器之间的平衡。同时根据需要增减服务器，MongoDB也会自动移动平移已有数据。

分片机制提供了如下三种优势

1 对集群进行抽象，让集群“不可见”。

MongoDB自带了一个叫做mongos的专有路由进程。mongos就是掌握统一路口的路由器，其会将客户端发来的请求准确无误的路由到集群中的一个或者一组服务器上，同时会把接收到的响应拼装起来发回到客户端。

2保证集群总是可读写。

MongoDB通过多种途径来确保集群的可用性和可靠性。将MongoDB的分片和复制功能结合使用，在确保数据分片到多台服务器的同时，也确保了每分数据都有相应的备份，这样就可以确保有服务器换掉时，其他的副本可以立即接替坏掉的部分继续工作。

3使集群易于扩展。

当系统需要更多的空间和资源的时候，MongoDB使我们可以按需方便的扩充系统容量。

实现数据分割

分片(shard)是集群中存储集合数据子集的一台或者多台服务器。在生产环境中一个分片通常是一个副本集(replica set)。

片键(key)，MongoDB以其作为依据来确定需要在不同分片服务器之间移动的数据。例如我们可以选择用户名(username)字段作为分片键，现有一用户名区间[“p”,”z”],那么wufengtinghai是属于这一区间的，那么数据最终会保存到与此区间对应的分片服务器上。

分配数据到分片服务器

分配数据到分片服务器可以使用不同的方式，了解不同的方式可以加深我们对MongoDB使用方式的理解。

一分片一区间

分配数据到分片最简单的方式莫过于一个区间一个分片。假设我们有四个分片存储用户的相关信息，则我们可能会得到如下的分片和区间的对应关系。

这种分片方式非常简单易懂，但是在一个大型繁忙的系统中却会带来许多的不便。假如大量的用户使用首字母在“a”,”f”)中的名字来注册，这将会导致分片1比较大，因此需要将其一部分文档移动到分片2上，我们可以调整分片1对应区间”a”,”c”),使分片2的区间变成”c”,”n”)。

如果移动数据后，分片2因此过载怎么办？假设分片1和分片2各有500G数据，而分片3和分片4各自有300G数据。那么按照这个方案，最终需要一连串的复制，总共算下来需要移动400G数据，考虑到需要在集群的服务器之间移动这些数据，可见移动数据量之大。

如果需要新加分片服务器进行水平扩展呢？假设此时每个分片上都有了500G数据，那么我们现在需要将分片4上的400G数据移动到分片5，将分片3的300G数据移动到分片4，将分片2的200G数据移动到分片3，将分片1的100G数据移动到分片2，整整移动了1T的数据！

随着分片数量和数据量的增长，这种噩梦将会持续下去，因此MongoDB不会采用这种方式。

一分片多区间

如果我们采用一分片多区间的方式，我们可以将分片1上的数据划分为两个区间，”a”,”d”)包含400G数据，”d”,”f”)包含100G数据，同样我们也可以对分片2做类似的处理，得到区间”f”,”j”)和“j”,”n”)。现在我们只需要将分片1上的”d”,”f”)数据移动到分片4，将分片2的“j”,”n”)的数据移动到分片3。这样我们仅仅只需要移动200G数据。

如果要添加新分片，可以从每个分片顶端取100G数据并将其移动到新的分片上，这样仅仅只需要移动400G数据即可。

MongoDB就是利用这种方式，当一个分片的数据越来越大时，其会自动分割片键区间，并将分片的数据进行分割并移动到其他分片。

MongoDB是一款为web应用程序和互联网基础设施设计的数据库管理系统。没错MongoDB就是数据库，是NoSQL类型的数据库。

（1）MongoDB提出的是文档、集合的概念，使用BSON（类JSON）作为其数据模型结构，其结构是面向对象的而不是二维表，存储一个用户在MongoDB中是这样子的。

使用这样的数据模型，使得MongoDB能在生产环境中提供高读写的能力，吞吐量较于mysql等SQL数据库大大增强。

（2）易伸缩，自动故障转移。易伸缩指的是提供了分片能力，能对数据集进行分片，数据的存储压力分摊给多台服务器。自动故障转移是副本集的概念，MongoDB能检测主节点是否存活，当失活时能自动提升从节点为主节点，达到故障转移。

（3）数据模型因为是面向对象的，所以可以表示丰富的、有层级的数据结构，比如博客系统中能把“评论”直接怼到“文章“的文档中，而不必像myqsl一样创建三张表来描述这样的关系。

（1）文档数据类型

SQL类型的数据库是正规化的，可以通过主键或者外键的约束保证数据的完整性与唯一性，所以SQL类型的数据库常用于对数据完整性较高的系统。MongoDB在这一方面是不如SQL类型的数据库，且MongoDB没有固定的Schema，正因为MongoDB少了一些这样的约束条件，可以让数据的存储数据结构更灵活，存储速度更加快。

（2）即时查询能力

MongoDB保留了关系型数据库即时查询的能力，保留了索引（底层是基于B tree）的能力。这一点汲取了关系型数据库的优点，相比于同类型的NoSQL redis 并没有上述的能力。

（3）复制能力

MongoDB自身提供了副本集能将数据分布在多台机器上实现冗余，目的是可以提供自动故障转移、扩展读能力。

（4）速度与持久性

MongoDB的驱动实现一个写入语义 fire and forget ，即通过驱动调用写入时，可以立即得到返回得到成功的结果（即使是报错），这样让写入的速度更加快，当然会有一定的不安全性，完全依赖网络。

MongoDB提供了Journaling日志的概念，实际上像mysql的bin-log日志，当需要插入的时候会先往日志里面写入记录，再完成实际的数据操作，这样如果出现停电，进程突然中断的情况，可以保障数据不会错误，可以通过修复功能读取Journaling日志进行修复。

（5）数据扩展

MongoDB使用分片技术对数据进行扩展，MongoDB能自动分片、自动转移分片里面的数据块，让每一个服务器里面存储的数据都是一样大小。

MongoDB核心服务器主要是通过mongod程序启动的，而且在启动时不需对MongoDB使用的内存进行配置，因为其设计哲学是内存管理最好是交给操作系统，缺少内存配置是MongoDB的设计亮点，另外，还可通过mongos路由服务器使用分片功能。

MongoDB的主要客户端是可以交互的js shell 通过mongo启动，使用js shell能使用js直接与MongoDB进行交流，像使用sql语句查询mysql数据一样使用js语法查询MongoDB的数据，另外还提供了各种语言的驱动包，方便各种语言的接入。

mongodump和mongorestore,备份和恢复数据库的标准工具。输出BSON格式，迁移数据库。

mongoexport和mongoimport，用来导入导出JSON、CSV和TSV数据，数据需要支持多格式时有用。mongoimport还能用与大数据集的初始导入，但是在导入前顺便还要注意一下，为了能充分利用好mongoDB通常需要对数据模型做一些调整。

mongosniff,网络嗅探工具，用来观察发送到数据库的操作。基本就是把网络上传输的BSON转换为易于人们阅读的shell语句。

因此，可以总结得到，MongoDB结合键值存储和关系数据库的最好特性。因为简单，所以数据极快，而且相对容易伸缩还提供复杂查询机制的数据库。MongoDB需要跑在64位的服务器上面，且最好单独部署，因为是数据库，所以也需要对其进行热备、冷备处理。

因为本篇文章不是API手册，所有这里对shell的使用也是基础的介绍什么功能可以用什么语句，主要是为了展示使用MongoDB shell的方便性，如果需要知道具体的MongoDB shell语法可以查阅官方文档。

创建数据库并不是必须的操作，数据库与集合只有在第一次插入文档时才会被创建，与对数据的动态处理方式是一致的。简化并加速开发过程，而且有利于动态分配命名空间。如果担心数据库或集合被意外创建，可以开启严格模式。

以上的命令只是简单实例，假设如果你之前没有学习过任何数据库语法，同时开始学sql查询语法和MongoDB 查询语法，你会发现哪一个更简单呢？如果你使用的是java驱动去操作MongoDB，你会发现任何的查询都像Hibernate提供出来的查询方式一样，只要构建好一个查询条件对象，便能轻松查询（接下来会给出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成没问题，也正因为这样简洁，完善的查询机制，深深的爱上了MongoDB。

使用java驱动链接MongoDB是一件非常简单的事情，简单的引用，简单的做增删改查。在使用完java驱动后我才发现spring 对MongoDB 的封装还不如官方自身提供出来的东西好用，下面简单的展示一下使用。

这里只举例了简单的链接与简单的MongoDB操作，可见其操作的容易性。使用驱动时是基于TCP套接字与MongoDB进行通信的，如果查询结果较多，恰好无法全部放进第一服务器中，将会向服务器发送一个getmore指令获取下一批查询结果。

插入数据到服务器时间，不会等待服务器的响应，驱动会假设写入是成功的，实际是使用客户端生成对象id，但是该行为可以通过配置配置，可以通过安全模式开启，安全模式可以校验服务器端插入的错误。

要清楚了解MongoDB的基本数据单元。在关系型数据库中有带列和行的数据表。而MongoDB数据的基本单元是BSON文档，在键值中有指向不定类型值的键，MongoDB拥有即时查询，但不支持联结操作，简单的键值存储只能根据单个键来获取值，不支持事务，但支持多种原子更新操作。

如读写比是怎样的，需要何种查询，数据是如何更新的，会不会存在什么并发问题，数据结构化的程度是要求高还是低。系统本身的需求决定mysql还是MongoDB。

在关于schema 的设计中要注意一些原则，比如：

数据库是集合的逻辑与物理分组，MongoDB没有提供创建数据库的语法，只有在插入集合时，数据库才开始建立。创建数据库后会在磁盘分配一组数据文件，所有集合、索引和数据库的其他元数据都保存在这些文件中，查阅数据库使用磁盘状态可通过。

集合是结构上或概念上相似得文档的容器，集合的名称可以包含数字、字母或 符号，但必须以字母或数字开头，完全。

限定集合名不能超过128个字符，实际上 符号在集合中很有用，能提供某种虚拟命名空间，这是一种组织上的原则，和其他集合是一视同仁的。在集合中可以使用。

其次是键值，在MongoDB里面所有的字符串都是UTF-8类型。数字类型包括double、int、long。日期类型都是UTC格式，所以在MongoDB里面看到的时间会比北京时间慢8小时。整个文档大小会限制在16m以内，因为这样可以防止创建难看的数据类型，且小文档可以提升性能，批量插入文档理想数字范围是10~200，大小不能超过16MB。

（1）索引能显著减少获取文档的所需工作量，具体的对比可以通过 explain()方法进行对比

（2）解析查询时MongoDB通过最优计划选择一个索引进行查询，当没有最适合索引时，会先不同的使用各个索引进行查询，最终选出一个最优索引做查询

（3）如果有一个a-b的复合索引，那么仅针对a的索引是冗余的

（4）复合索引里的键的顺序是很重要的

（1）单键索引

（2）复合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段会出现null的值，或是大量文档都不包含被索引的键。

如果数据集很大时，构建索引将会花费很长的时间，且会影响程序性能，可通过

当使用 mongorestore 时会重新构建索引。当曾经执行过大规模的删除时，可使用

对索引进行压缩，重建。

（1）查阅慢查询日志

（2）分析慢查询

注意新版本的MongoDB 的explain方法是需要参数的，不然只显示普通的信息。

本节同样主要简单呈现MongoDB副本集搭建的简易性，与副本集的强壮性，监控容易性

提供主从复制能力，热备能力，故障转移能力

实际上MongoDB对副本集的操作跟mysql主从操作是差不多的，先看一下mysql的主从数据流动过程

而MongoDB主要依赖的日志文件是oplog

写操作先被记录下来，添加到主节点的oplog里。与此同时，所有从结点复制oplog。首先，查看自己oplog里最后一条的时间戳；其次，查询主节点oplog里所有大于此时间戳的条目;最后，把那些条目添加到自己的oplog里并应用到自己的库里。从节点使用长轮询立即应用来自主结点oplog的新条目。

当遇到以下情况，从节点会停止复制

local数据库保存了所有副本集元素据和oplog日志

可以使用以下命令查看复制情况

每个副本集成员每秒钟ping一次其他所有成员，可以通过rsstatus()看到节点上次的心跳检测时间戳和 健康 状况。

这个点没必要过多描述，但是有一个特殊场景，如果从节点和仲裁节点都被杀了，只剩下主节点，他会把自己降级成为从节点。

如果主节点的数据还没有写到从库，那么数据不能算提交，当该主节点变成从节点时，便会触发回滚，那些没写到从库的数据将会被删除，可以通过rollback子目录中的BSON文件恢复回滚的内容。

（1）使用单节点链接

只能链接到主节点，如果链接到从节点的话，会被拒绝写入操作，但是如果没有使用安全模式，因为mongo的fire and forget 特性，会把拒绝写入的异常给吃掉。

（2）使用副本集方式链接

能根据写入的情况自动进行故障转移，但是当副本集进行新的选举时，还是会出现故障，如果不使用安全模式，依旧会出现写不进去，但现实成功的情况。

分片是数据库切分的一个概念实现，这里也是简单总结为什么要使用分片以及分片的原理，操作。

当数据量过大，索引和工作数据集占用的内存就会越来越多，所以需要通过分片负载来解决这个问题

（1）分片组件

（2）分片的核心操作

分片一个集合：分片是根据一个属性的范围进行划分的，MongoDB使用所谓的分片键让每个文档在这些范围里找到自己的位置

块：是位于一个分片中的一段连续的分片键范围，可以理解为若干个块组成分片，分片组成MongoDB的全部数据

（3）拆分与迁移

块的拆分：初始化时只有一个块，达到最大块尺寸64MB或100000个文档就会触发块的拆分。把原来的范围一分为二，这样就有了两个块，每个块都有相同数量的文档。

迁移：当分片中的数据大小不一时会产生迁移的动作，比如分片A的数据比较多，会将分片A里面的一些块转移到分片B里面去。分片集群通过在分片中移动块来实现均衡，是由名为均衡器的软件进程管理的，任务是确保数据在各个分片中保持均匀分布，当集群中拥有块最多的分片与拥有块最少分片的块差大于8时，均衡器就会发起一次均衡处理。

启动两个副本集、三个配置服务器、一个mongos进程

配置分片

（1）分片查询类型

（2）索引

分片集合只允许在_id字段和分片键上添加唯一性索引，其他地方不行，因为这需要在分片间进行通信，实施起来很复杂。

当创建分片时，会根据分片键创建一个索引。

（1）分片键是不可修改的、分片键的选择非常重要

（2）低效的分片键

（3）理想的分片键

（1）部署拓扑

根据不同的数据中心划分

这里写描述

（2）最低要求

（3）配置的注意事项

需要估计集群大小，可使用以下命令对现有集合进行分片处理

（4）备份分片集群

备份分片时需要停止均衡器

（1）部署架构

使用64位机器、32位机器会制约mongodb的内存，使其最大值为15GB

（2）cpu

mongodb 只有当索引和工作集都可放入内存时，才会遇到CPU瓶颈，CPU在mongodb使用中的作用是用来检索数据，如果看到CPU使用饱和的情况，可以通过查询慢查询日志，排查是不是查询的问题导致的，如果是可以通过添加索引来解决问题

mongodb写入数据时会使用到CPU，但是mongodb写入时间一次只用到一个核，如果有频繁的写入行为，可以通过分片来解决这个问题

（3）内存

大内存是mongodb的保障，如果工作集大小超过内存，将会导致性能下降，因为这将会增加数据加载入内存的动作

（4）硬盘

mongodb默认每60s会与磁盘强制同步一次，称为后台刷新，会产生I/O操作。在重启时mongodb会将磁盘里面的数据加载至内存，高速磁盘将会减少同步的时间

（5）文件系统

使用ext4 和 xfs 文件系统

禁用最后访问时间

（6）文件描述符

linux 默认文件描述符是1024，需要大额度的提升这个额度

（7）时钟

mongodb各个节点服务器之间使用ntp服务器

（1）绑定IP

启动时使用 - -bind_ip 命令

（2）身份验证

启动时使用 - -auth 命令

（3）副本集身份认证

使用keyFile，注意keyFile文件的权限必须是600，不然会启动不起来

（1）拓扑结构

搭建副本集至少需要两个节点，其中仲裁结点不需要有自己的服务器

（2）Journaling日志

写数据时会先写入日志，而此时的数据也不是直接写入硬盘，而是写入内存

但是Journaling日志会消耗内存，所以可以在主库上面关闭，在从库上面启动

可以单独为Journaling日志使用一块固态硬盘

在插入时，可以通过驱动确保Journaling插入后再反馈，但是会非常影响性能。

logpath 选项指定日志存储地址

-vvvvv 选项（v越多，输出越详细）

dbrunCommand({logrotare:1}) 开启滚动日志

（1）serverStatus

这里写描述

（2）top

（3）dbcurrentOp()

动态展示mongodb活动数据

占用当前mongodb监听端口往上1000号的端口

（1）mongodump

把数据库内容导出成BSON文件，而mongorestore能读取并还原这些文件

（2）mongorestore

把导出的BSON文件还原到数据库

（3）备份原始数据文件

可以这么做，但是，操作之前需要进行锁库处理 dbrunCommand({fsync:1,lock:true})

db$cmdsysunlockfindOne() 请求解锁操作，但是数据库不会立刻解锁，需要使用dbcurrentOp()验证。

（1）修复

mongd --repair 修复所有数据库

dbrunCommand({repairDatabase:1}) 修复单个数据库

修复就是根据Jourling文件读取和重写所有数据文件并重建各个索引

（2）压紧

压紧，会重写数据文件，并重建集合的全部索引，需要停机或者在从库上面运行,如果需要在主库上面运行，需要添加force参数 保证加写锁。

（1）监控磁盘状态

（2）为提升性能检查索引和查询

总的来说，扫描尽可能少的文档。

保证没有冗余的索引，冗余的索引会占用磁盘空间、消耗更多的内存，在每次写入时还需做更多工作

（3）添加内存

dataSize 数据大小 和 indexSize 索引大小，如果两者的和大于内存，那么将会影响性能。

storageSize超过dataSize 数据大小 两倍以上，就会因磁盘碎片而影响性能，需要压缩。

点击上方 蓝色字体 ，选择“置顶公众号”

优质文章，第一时间送达

链接 | blogcsdnnet/hayre/article/details/80628431

1MongoDB是什么？用一句话总结

MongoDB是一款为web应用程序和互联网基础设施设计的数据库管理系统。没错MongoDB就是数据库，是NoSQL类型的数据库。

（1）MongoDB提出的是文档、集合的概念，使用BSON（类JSON）作为其数据模型结构，其结构是面向对象的而不是二维表，存储一个用户在MongoDB中是这样子的。

使用这样的数据模型，使得MongoDB能在生产环境中提供高读写的能力，吞吐量较于mysql等SQL数据库大大增强。

（2）易伸缩，自动故障转移。易伸缩指的是提供了分片能力，能对数据集进行分片，数据的存储压力分摊给多台服务器。自动故障转移是副本集的概念，MongoDB能检测主节点是否存活，当失活时能自动提升从节点为主节点，达到故障转移。

（3）数据模型因为是面向对象的，所以可以表示丰富的、有层级的数据结构，比如博客系统中能把“评论”直接怼到“文章“的文档中，而不必像myqsl一样创建三张表来描述这样的关系。

3主要特性

（1）文档数据类型

SQL类型的数据库是正规化的，可以通过主键或者外键的约束保证数据的完整性与唯一性，所以SQL类型的数据库常用于对数据完整性较高的系统。MongoDB在这一方面是不如SQL类型的数据库，且MongoDB没有固定的Schema，正因为MongoDB少了一些这样的约束条件，可以让数据的存储数据结构更灵活，存储速度更加快。 （2）即时查询能力

MongoDB保留了关系型数据库即时查询的能力，保留了索引（底层是基于B tree）的能力。这一点汲取了关系型数据库的优点，相比于同类型的NoSQL redis 并没有上述的能力。 （3）复制能力

MongoDB自身提供了副本集能将数据分布在多台机器上实现冗余，目的是可以提供自动故障转移、扩展读能力。 （4）速度与持久性

MongoDB的驱动实现一个写入语义 fire and forget ，即通过驱动调用写入时，可以立即得到返回得到成功的结果（即使是报错），这样让写入的速度更加快，当然会有一定的不安全性，完全依赖网络。

MongoDB提供了Journaling日志的概念，实际上像mysql的bin-log日志，当需要插入的时候会先往日志里面写入记录，再完成实际的数据操作，这样如果出现停电，进程突然中断的情况，可以保障数据不会错误，可以通过修复功能读取Journaling日志进行修复。

（5）数据扩展

MongoDB使用分片技术对数据进行扩展，MongoDB能自动分片、自动转移分片里面的数据块，让每一个服务器里面存储的数据都是一样大小。

MongoDB核心服务器主要是通过mongod程序启动的，而且在启动时不需对MongoDB使用的内存进行配置，因为其设计哲学是内存管理最好是交给操作系统，缺少内存配置是MongoDB的设计亮点，另外，还可通过mongos路由服务器使用分片功能。

MongoDB的主要客户端是可以交互的js shell 通过mongo启动，使用js shell能使用js直接与MongoDB进行交流，像使用sql语句查询mysql数据一样使用js语法查询MongoDB的数据，另外还提供了各种语言的驱动包，方便各种语言的接入。

mongodump和mongorestore,备份和恢复数据库的标准工具。输出BSON格式，迁移数据库。

mongoexport和mongoimport，用来导入导出JSON、CSV和TSV数据，数据需要支持多格式时有用。mongoimport还能用与大数据集的初始导入，但是在导入前顺便还要注意一下，为了能充分利用好mongoDB通常需要对数据模型做一些调整。

mongosniff,网络嗅探工具，用来观察发送到数据库的操作。基本就是把网络上传输的BSON转换为易于人们阅读的shell语句。

因此，可以总结得到，MongoDB结合键值存储和关系数据库的最好特性。因为简单，所以数据极快，而且相对容易伸缩还提供复杂查询机制的数据库。MongoDB需要跑在64位的服务器上面，且最好单独部署，因为是数据库，所以也需要对其进行热备、冷备处理。

因为本篇文章不是API手册，所有这里对shell的使用也是基础的介绍什么功能可以用什么语句，主要是为了展示使用MongoDB shell的方便性，如果需要知道具体的MongoDB shell语法可以查阅官方文档。

创建数据库并不是必须的操作，数据库与集合只有在第一次插入文档时才会被创建，与对数据的动态处理方式是一致的。简化并加速开发过程，而且有利于动态分配命名空间。如果担心数据库或集合被意外创建，可以开启严格模式。

以上的命令只是简单实例，假设如果你之前没有学习过任何数据库语法，同时开始学sql查询语法和MongoDB 查询语法，你会发现哪一个更简单呢？如果你使用的是java驱动去操作MongoDB，你会发现任何的查询都像Hibernate提供出来的查询方式一样，只要构建好一个查询条件对象，便能轻松查询（接下来会给出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成没问题，也正因为这样简洁，完善的查询机制，深深的爱上了MongoDB。

使用java驱动链接MongoDB是一件非常简单的事情，简单的引用，简单的做增删改查。在使用完java驱动后我才发现spring 对MongoDB 的封装还不如官方自身提供出来的东西好用，下面简单的展示一下使用。

这里只举例了简单的链接与简单的MongoDB操作，可见其操作的容易性。使用驱动时是基于TCP套接字与MongoDB进行通信的，如果查询结果较多，恰好无法全部放进第一服务器中，将会向服务器发送一个getmore指令获取下一批查询结果。

插入数据到服务器时间，不会等待服务器的响应，驱动会假设写入是成功的，实际是使用客户端生成对象id，但是该行为可以通过配置配置，可以通过安全模式开启，安全模式可以校验服务器端插入的错误。

要清楚了解MongoDB的基本数据单元。在关系型数据库中有带列和行的数据表。而MongoDB数据的基本单元是BSON文档，在键值中有指向不定类型值的键，MongoDB拥有即时查询，但不支持联结操作，简单的键值存储只能根据单个键来获取值，不支持事务，但支持多种原子更新操作。

如读写比是怎样的，需要何种查询，数据是如何更新的，会不会存在什么并发问题，数据结构化的程度是要求高还是低。系统本身的需求决定mysql还是MongoDB。

在关于schema 的设计中要注意一些原则，比如：

数据库是集合的逻辑与物理分组，MongoDB没有提供创建数据库的语法，只有在插入集合时，数据库才开始建立。创建数据库后会在磁盘分配一组数据文件，所有集合、索引和数据库的其他元数据都保存在这些文件中，查阅数据库使用磁盘状态可通过。

集合是结构上或概念上相似得文档的容器，集合的名称可以包含数字、字母或 符号，但必须以字母或数字开头，完全。

限定集合名不能超过128个字符，实际上 符号在集合中很有用，能提供某种虚拟命名空间，这是一种组织上的原则，和其他集合是一视同仁的。在集合中可以使用。

其次是键值，在MongoDB里面所有的字符串都是UTF-8类型。数字类型包括double、int、long。日期类型都是UTC格式，所以在MongoDB里面看到的时间会比北京时间慢8小时。整个文档大小会限制在16m以内，因为这样可以防止创建难看的数据类型，且小文档可以提升性能，批量插入文档理想数字范围是10~200，大小不能超过16MB。

（2）解析查询时MongoDB通过最优计划选择一个索引进行查询，当没有最适合索引时，会先不同的使用各个索引进行查询，最终选出一个最优索引做查询

（3）如果有一个a-b的复合索引，那么仅针对a的索引是冗余的

（4）复合索引里的键的顺序是很重要的

（2）复合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段会出现的值，或是大量文档都不包含被索引的键。

如果数据集很大时，构建索引将会花费很长的时间，且会影响程序性能，可通过

当使用 mongorestore 时会重新构建索引。当曾经执行过大规模的删除时，可使用

对索引进行压缩，重建。

（1）查阅慢查询日志

（2）分析慢查询

注意新版本的MongoDB 的explain方法是需要参数的，不然只显示普通的信息。

本节同样主要简单呈现MongoDB副本集搭建的简易性，与副本集的强壮性，监控容易性

提供主从复制能力，热备能力，故障转移能力

实际上MongoDB对副本集的操作跟mysql主从操作是差不多的，先看一下mysql的主从数据流动过程

而MongoDB主要依赖的日志文件是oplog

写操作先被记录下来，添加到主节点的oplog里。与此同时，所有从结点复制oplog。首先，查看自己oplog里最后一条的时间戳；其次，查询主节点oplog里所有大于此时间戳的条目;最后，把那些条目添加到自己的oplog里并应用到自己的库里。从节点使用长轮询立即应用来自主结点oplog的新条目。

当遇到以下情况，从节点会停止复制

local数据库保存了所有副本集元素据和oplog日志

可以使用以下命令查看复制情况

每个副本集成员每秒钟ping一次其他所有成员，可以通过rsstatus看到节点上次的心跳检测时间戳和 健康 状况。

这个点没必要过多描述，但是有一个特殊场景，如果从节点和仲裁节点都被杀了，只剩下主节点，他会把自己降级成为从节点。

如果主节点的数据还没有写到从库，那么数据不能算提交，当该主节点变成从节点时，便会触发回滚，那些没写到从库的数据将会被删除，可以通过rollback子目录中的BSON文件恢复回滚的内容。

只能链接到主节点，如果链接到从节点的话，会被拒绝写入操作，但是如果没有使用安全模式，因为mongo的fire and forget 特性，会把拒绝写入的异常给吃掉。

（2）使用副本集方式链接

能根据写入的情况自动进行故障转移，但是当副本集进行新的选举时，还是会出现故障，如果不使用安全模式，依旧会出现写不进去，但现实成功的情况。

分片是数据库切分的一个概念实现，这里也是简单总结为什么要使用分片以及分片的原理，操作。

当数据量过大，索引和工作数据集占用的内存就会越来越多，所以需要通过分片负载来解决这个问题

（2）分片的核心操作

分片一个集合：分片是根据一个属性的范围进行划分的，MongoDB使用所谓的分片键让每个文档在这些范围里找到自己的位置

块：是位于一个分片中的一段连续的分片键范围，可以理解为若干个块组成分片，分片组成MongoDB的全部数据

（3）拆分与迁移

块的拆分：初始化时只有一个块，达到最大块尺寸64MB或100000个文档就会触发块的拆分。把原来的范围一分为二，这样就有了两个块，每个块都有相同数量的文档。

迁移：当分片中的数据大小不一时会产生迁移的动作，比如分片A的数据比较多，会将分片A里面的一些块转移到分片B里面去。分片集群通过在分片中移动块来实现均衡，是由名为均衡器的软件进程管理的，任务是确保数据在各个分片中保持均匀分布，当集群中拥有块最多的分片与拥有块最少分片的块差大于8时，均衡器就会发起一次均衡处理。

启动两个副本集、三个配置服务器、一个mongos进程

配置分片

（2）索引

分片集合只允许在_id字段和分片键上添加唯一性索引，其他地方不行，因为这需要在分片间进行通信，实施起来很复杂。

当创建分片时，会根据分片键创建一个索引。

（2）低效的分片键

（3）理想的分片键

根据不同的数据中心划分

（2）最低要求

（3）配置的注意事项

需要估计集群大小，可使用以下命令对现有集合进行分片处理

（4）备份分片集群

备份分片时需要停止均衡器

使用64位机器、32位机器会制约mongodb的内存，使其最大值为15GB

（2）cpu mongodb 只有当索引和工作集都可放入内存时，才会遇到CPU瓶颈，CPU在mongodb使用中的作用是用来检索数据，如果看到CPU使用饱和的情况，可以通过查询慢查询日志，排查是不是查询的问题导致的，如果是可以通过添加索引来解决问题

mongodb写入数据时会使用到CPU，但是mongodb写入时间一次只用到一个核，如果有频繁的写入行为，可以通过分片来解决这个问题 （3）内存

大内存是mongodb的保障，如果工作集大小超过内存，将会导致性能下降，因为这将会增加数据加载入内存的动作

（4）硬盘

mongodb默认每60s会与磁盘强制同步一次，称为后台刷新，会产生I/O操作。在重启时mongodb会将磁盘里面的数据加载至内存，高速磁盘将会减少同步的时间

（5）文件系统

使用ext4 和 xfs 文件系统

禁用最后访问时间

（6）文件描述符

linux 默认文件描述符是1024，需要大额度的提升这个额度

（7）时钟

mongodb各个节点服务器之间使用ntp服务器

启动时使用 - -bind_ip 命令

（2）身份验证

启动时使用 - -auth 命令

（3）副本集身份认证

使用keyFile，注意keyFile文件的权限必须是600，不然会启动不起来

搭建副本集至少需要两个节点，其中仲裁结点不需要有自己的服务器

（2）Journaling日志 写数据时会先写入日志，而此时的数据也不是直接写入硬盘，而是写入内存

但是Journaling日志会消耗内存，所以可以在主库上面关闭，在从库上面启动

可以单独为Journaling日志使用一块固态硬盘

在插入时，可以通过驱动确保Journaling插入后再反馈，但是会非常影响性能。

-vvvvv 选项（v越多，输出越详细）

dbrunCommand({logrotare:1}) 开启滚动日志

（2）top

（3）dbcurrentOp

动态展示mongodb活动数据

占用当前mongodb监听端口往上1000号的端口

把数据库内容导出成BSON文件，而mongorestore能读取并还原这些文件

（2）mongorestore

把导出的BSON文件还原到数据库

（3）备份原始数据文件 可以这么做，但是，操作之前需要进行锁库处理 dbrunCommand({fsync:1,lock:true}) db$cmdsysunlockfindOne 请求解锁操作，但是数据库不会立刻解锁，需要使用 dbcurrentOp 验证。

dbrunCommand({repairDatabase:1}) 修复单个数据库

修复就是根据Jourling文件读取和重写所有数据文件并重建各个索引 （2）压紧

压紧，会重写数据文件，并重建集合的全部索引，需要停机或者在从库上面运行,如果需要在主库上面运行，需要添加force参数 保证加写锁。

（2）为提升性能检查索引和查询

总的来说，扫描尽可能少的文档。

保证没有冗余的索引，冗余的索引会占用磁盘空间、消耗更多的内存，在每次写入时还需做更多工作

（3）添加内存

dataSize 数据大小 和 indexSize 索引大小，如果两者的和大于内存，那么将会影响性能。

storageSize超过dataSize 数据大小 两倍以上，就会因磁盘碎片而影响性能，需要压缩。

　　这种用法对于以下应用场合来讲，超实用：

　　置于慢速RDBMS系统之前的写操作密集型高速缓存

　　嵌入式系统

　　无需持久化数据的PCI兼容系统

　　需要轻量级数据库而且库中数据可以很容易清除掉的单元测试（unit testing）

　　如果这一切可以实现就真是太优雅了：我们就能够巧妙地在不涉及磁盘操作的情况下利用MongoDB的查询/检索功能。可能你也知道，在99％的情况下，磁盘IO（特别是随机IO）是系统的瓶颈，而且，如果你要写入数据的话，磁盘操作是无法避免的。

　　MongoDB有一个非常酷的设计决策，就是她可以使用内存影射文件（memory-mapped file）来处理对磁盘文件中数据的读写请求。这也就是说，MongoDB并不对RAM和磁盘这两者进行区别对待，只是将文件看作一个巨大的数组，然后按照字节为单位访问其中的数据，剩下的都交由操作系统（OS）去处理！就是这个设计决策，才使得MongoDB可以无需任何修改就能够运行于RAM之中。

　　实现方法

　　这一切都是通过使用一种叫做tmpfs的特殊类型文件系统实现的。在Linux中它看上去同常规的文件系统（FS）一样，只是它完全位于RAM中（除非其大小超过了RAM的大小，此时它还可以进行swap，这个非常有用！）。我的服务器中有32GB的RAM，下面让我们创建一个16GB的 tmpfs：

　　# mkdir /ramdata # mount -t tmpfs -o size=16000M tmpfs /ramdata/ # df Filesystem           1K-blocks      Used Available Use% Mounted on /dev/xvde1             5905712   4973924    871792  86% / none                  15344936         0  15344936   0% /dev/shm tmpfs                 16384000         0  16384000   0% /ramdata

　　接下来要用适当的设置启动MongoDB。为了减小浪费的RAM数量，应该把smallfiles和noprealloc设置为true。既然现在是基于RAM的，这么做完全不会降低性能。此时再使用journal就毫无意义了，所以应该把nojournal设置为true。

　　dbpath=/ramdata nojournal = true smallFiles = true noprealloc = true

　　MongoDB启动之后，你会发现她运行得非常好，文件系统中的文件也正如期待的那样出现了：

　　# mongo MongoDB shell version: 232 connecting to: test > dbtestinsert({a:1}) > dbtestfind() { "_id" : ObjectId("51802115eafa5d80b5d2c145"), "a" : 1 } # ls -l /ramdata/ total 65684 -rw------- 1 root root 16777216 Apr 30 15:52 local0 -rw------- 1 root root 16777216 Apr 30 15:52 localns -rwxr-xr-x 1 root root        5 Apr 30 15:52 mongodlock -rw------- 1 root root 16777216 Apr 30 15:52 test0 -rw------- 1 root root 16777216 Apr 30 15:52 testns drwxr-xr-x 2 root root       40 Apr 30 15:52 _tmp

　　现在让我们添加一些数据，证实一下其运行完全正常。我们先创建一个1KB的document，然后将它添加到MongoDB中4百万次：

　　> str = "" > aaa = "aaaaaaaaaa" aaaaaaaaaa > for (var i = 0; i < 100; ++i) { str += aaa; } > for (var i = 0; i < 4000000; ++i) { dbfooinsert({a: Mathrandom(), s: str});} > dbfoostats() {         "ns" : "testfoo",         "count" : 4000000,         "size" : 4544000160,         "avgObjSize" : 113600004,         "storageSize" : 5030768544,         "numExtents" : 26,         "nindexes" : 1,         "lastExtentSize" : 536600560,         "paddingFactor" : 1,         "systemFlags" : 1,         "userFlags" : 0,         "totalIndexSize" : 129794000,         "indexSizes" : {                 "_id_" : 129794000         },         "ok" : 1 }

　　可以看出，其中的document平均大小为1136字节，数据总共占用了5GB的空间。_id之上的索引大小为130MB。现在我们需要验证一件 非常重要的事情：RAM中的数据有没有重复，是不是在MongoDB和文件系统中各保存了一份？还记得MongoDB并不会在她自己的进程内缓存任何数据，她的数据只会缓存到文件系统的缓存之中。那我们来清除一下文件系统的缓存，然后看看RAM中还有有什么数据：

　　# echo 3 > /proc/sys/vm/drop_caches  # free              total       used       free     shared    buffers     cached Mem:      30689876    6292780   24397096          0       1044    5817368 -/+ buffers/cache:     474368   30215508 Swap:            0          0          0

　　可以看到，在已使用的63GB的RAM中，有58GB用于了文件系统的缓存（缓冲区，buffer)。为什么即使在清除所有缓存之后，系统中仍然还有58GB的文件系统缓存？？其原因是，Linux非常聪明，她不会在tmpfs和缓存中保存重复的数据。太棒了！这就意味着，你在RAM只有一份数据。下面我们访问一下所有的document，并验证一下，RAM的使用情况不会发生变化：

 

　　果不其然！ :)

　　复制（replication）呢？

　　既然服务器在重启时RAM中的数据都会丢失，所以你可能会想使用复制。采用标准的副本集（replica set）就能够获得自动故障转移（failover），还能够提高数据读取能力（read capacity）。如果有服务器重启了，它就可以从同一个副本集中另外一个服务器中读取数据从而重建自己的数据（重新同步，resync）。即使在大量数据和索引的情况下，这个过程也会足够快，因为索引操作都是在RAM中进行的 :)

　　有一点很重要，就是写操作会写入一个特殊的叫做oplog的collection，它位于local数据库之中。缺省情况下，它的大小是总数据量的5%。在我这种情况下，oplog会占有16GB的5%，也就是800MB的空间。在拿不准的情况下，比较安全的做法是，可以使用oplogSize这个选项为oplog选择一个固定的大小。如果备选服务器宕机时间超过了oplog的容量，它就必须要进行重新同步了。要把它的大小设置为1GB，可以这样：

　　oplogSize = 1000

　　分片（sharding）呢？

　　既然拥有了MongoDB所有的查询功能，那么用它来实现一个大型的服务要怎么弄？你可以随心所欲地使用分片来实现一个大型可扩展的内存数据库。配置服务器（保存着数据块分配情况）还还是用过采用基于磁盘的方案，因为这些服务器的活动数量不大，老从头重建集群可不好玩。

　　注意事项

　　RAM属稀缺资源，而且在这种情况下你一定想让整个数据集都能放到RAM中。尽管tmpfs具有借助于磁盘交换（swapping）的能力，但其性能下降将非常显著。为了充分利用RAM，你应该考虑：

　　使用usePowerOf2Sizes选项对存储bucket进行规范化

　　定期运行compact命令或者对节点进行重新同步（resync）

　　schema的设计要相当规范化（以避免出现大量比较大的document）