#verbose：日志信息冗余。默认false。提高内部报告标准输出或记录到logpath配置的日志文件中。要启用verbose或启用verbosity 用vvvv参数

verbose = true

#启动verbose冗长信息，它的级别有 vv~vvvvv，v越多级别越高，在日志文件中记录的信息越详细。

vvvv = true  

#port：端口。默认27017，MongoDB的默认服务TCP端口，监听客户端连接。要是端口设置小于1024，比如1021，则需要root权限启动，不能用mongodb帐号启动

port = 27017  

#bind_ip：绑定地址。默认127.0.0.1，只能通过本地连接。进程绑定和监听来自这个地址上的应用连接。要是需要给其他服务器连接，则需要注释掉这个或则把IP改成本机地址，可以用一个逗号分隔的列表绑定多个IP地址。

bind_ip = 0.0.0.0

#maxConns：最大连接数。默认值：取决于系统（即的ulimit和文件描述符）限制。MongoDB中不会限制其自身的连接。当设置大于系统的限制，则无效，以系统限制为准。这对于客户端创建很多“表”，允许连接超时而不关闭“表”的时候很有用。设置该值的高于连接池和总连接数的大小，以防止尖峰时候的连接。注意：不能设置该值大于20000。

maxConns = 1000  

#objcheck:强制验证客户端请求。2.4的默认设置为objcheck成为true，在早期版本objcheck默认为false。因为它强制验证客户端请求，确保客户端绝不插入无效文件到数据库中。对于嵌套文档的对象，会有一点性能影响。设置noobjcheck 关闭。

objcheck = true

#noobjcheck = false  

#logpath：指定日志文件，该文件将保存所有的日志记录、诊断信息。除非另有指定，mongod将所有的日志信息输出到标准输出。如果没有指定logappend，重启则日志会进行覆盖操作。

logpath= /usr/local/mongodb/logs/mongodb.log

#logappend：写日志的模式：设置为true为追加。默认是覆盖。如果未指定此设置，启动时MongoDB的将覆盖现有的日志文件。

logappend=true  

#syslog：日志输出都发送到主机的syslog系统，而不是标准输出到logpath指定日志文件。syslog和logpath不能一起用，会报错：

syslog  = false

#pidfilepath：进程ID，没有指定则启动时候就没有PID文件。默认缺省。

pidfilepath = /usr/local/mongodb/data/mongo.pid  

#keyFile：指定存储身份验证信息的密钥文件的路径。默认缺省。

keyFile = /usr/local/mongodb/keyfile  

#nounixsocket：套接字文件，默认为false，有生成socket文件。当设置为true时，不会生成socket文件。

nounixsocket = false  

#unixSocketPrefix：套接字文件路径，默认/tmp

unixSocketPrefix = //usr/local/mongodb/tmp  

#fork：是否后台运行，设置为true 启动 进程在后台运行的守护进程模式。默认false。

fork = true  

#auth：用户认证，默认false。不需要认证。当设置为true时候，进入数据库需要auth验证，当数据库里没有用户，则不需要验证也可以操作。直到创建了第一个用户，之后操作都需要验证。比如：通过db.addUser('sa','sa')在admin库下面创建一个超级用户，只能在在admin库下面先认证完毕了：ab.auth('sa','sa')，才能去别的库操作，不能在其他库验证。这样连接数据库也需要指定库：

#mongo -usa -psa admin     #sa 帐号连接admin

#mongo -uaa -paa test      #aa 帐号连接test

auth = true  

#noauth：禁止用户认证，默认true

noauth = true  

#cpu：设置为true会强制mongodb每4s报告cpu利用率和io等待，把日志信息写到标准输出或日志文件。默认为false。

cpu = false

#dbpath：数据存放目录。默认：/data/db/

dbpath= /usr/local/mongodb/data/  

#diaglog：创建一个非常详细的故障排除和各种错误的诊断日志记录。默认0。设置为1，为在dbpath目录里生成一个diaglog.开头的日志文件，设置不等于0，日志会每分钟flush一次。产生的日志可以用mongosniff来查看，当重新设置成0，会停止写入文件，但mongod还是继续保持打开该文件，即使它不再写入数据文件。如果你想重命名，移动或删除诊断日志，你必须完全关闭mongod实例。

0    off. No logging.       #关闭。没有记录。

#1    Log write operations.  #写操作

#2    Log read operations.   #读操作

#3    Log both read and write operations. #读写操作

#7    Log write and some read operations. #写和一些读操作  

#directoryperdb：设置为true，修改数据目录存储模式，每个数据库的文件存储在DBPATH指定目录的不同的文件夹中。使用此选项，可以配置的MongoDB将数据存储在不同的磁盘设备上，以提高写入吞吐量或磁盘容量。默认为false。要是在运行一段时间的数据库中，开启该参数，会导致原始的数据都会消失（注释参数则会回来）。因为数据目录都不同了，除非迁移现有的数据文件到directoryperdb产生的数据库目录中，所以需要在规划好之后确定是否要开启。

directoryperdb = false

#journal：日志，（redo log，更多的介绍请看这里和这里）。默认值：（在64位系统）true。默认值：（32位系统）false。

#设置为true，启用操作日志，以确保写入持久性和数据的一致性，会在dbpath目录下创建journal目录。

#设置为false，以防止日志持久性的情况下，并不需要开销。为了减少磁盘上使用的日志的影响，您可以启用nojournal，并设置为true。

#注意：在64位系统上禁用日志必须使用带有nojournal的。

journal = false  

#nojournal:禁止日志，默认值：（在64位系统）false。默认值：（32位系统）true。

#设置nojournal为true关闭日志，64位，2.0版本后的mongodb默认是启用 journal日志。

nojournal = true

#journalCommitInterval：刷写提交机制，默认是30ms或则100ms。较低的值，会更消耗磁盘的性能。此选项接受2和300毫秒之间的值：

#如果单块设备提供日志和数据文件，默认的日记提交时间间隔为100毫秒。

#如果不同的块设备提供的日志和数据文件，默认的日记提交的时间间隔为30毫秒。

journalCommitInterval = 100  

#ipv6：是否支持ipv6，默认false。

ipv6 = true  

#jsonp：是否允许JSONP访问通过一个HTTP接口，默认false。

jsonp = true  

#nohttpinterface：是否禁止http接口，即28017 端口开启的服务。默认false，支持。

nohttpinterface = false  

#noprealloc：预分配方式。默认false：使用预分配方式来保证写入性能的稳定，预分配在后台进行，并且每个预分配的文件都用0进行填充。这会让MongoDB始终保持额外的空间和空余的数据文件，从而避免了数据增长过快而带来的分配磁盘空间引起的阻塞。设置noprealloc= true来禁用预分配的数据文件，会缩短启动时间，但在正常操作过程中，可能会导致性能显著下降。

noprealloc = false  

#noscripting：是否禁止脚本引擎。默认是false：不禁止。ture：禁止,要是设置成true：运行一些脚本的时候会出现："server-side JavaScript execution is disabled"

noscripting = true   

#notablescan：是否禁止表扫描操作。默认false：不禁止，ture：禁止,禁止要是执行表扫描会出现："table scans not allowed"

notablescan = true  

#nssize:命名空间的文件（即NS）的默认大小，默认16M，最大2G。所有新创建的默认大小命名空间的文件（即NS）。此选项不会影响现有的命名空间的文件的大小。默认值是16M字节，最大大小为2 GB。让小数据库不让浪费太多的磁盘空间，同时让大数据在磁盘上有连续的空间。

nssize  = 16  

#profile：数据库分析等级设置。记录一些操作性能到标准输出或则指定的logpath的日志文件中，默认0:关闭。

#0 关。无分析。

#1 开。仅包括慢操作。

#2 开。包括所有操作。

#控制 Profiling  的开关和级别：2种,第一种是直接在启动参数里直接进行设置或则启动MongoDB时加上–profile=级别，其信息保存在 生成的system.profile 中。第二种是在客户端用db.setProfilingLevel(级别)命令来实时配置，其信息保存在 生成的system.profile 中。默认情况下，mongod的禁用分析。数据库分析可以影响数据库的性能，因为分析器必须记录和处理所有的数据库操作。所以在需要的时候用动态修改就可以了。

profile = 0

#slowms：记录profile分析的慢查询的时间，默认是100毫秒。具体同上。

slowms  = 200  

#quota：配额，默认false。是否开启配置每个数据库的最多文件数的限制。当为true则用quotaFiles来配置最多文件的数量。

quota = true

#quotaFiles：配额数量。每个数据库的数据文件数量的限制。此选项需要quota为true。默认为8。

quotaFiles = 8  

#rest： 默认false，设置为true，使一个简单的 REST API。设置为true，开启后，在MongoDB默认会开启一个HTTP协议的端口提供REST的服务（nohttpinterface=false），这个端口是你Server端口加上1000，即28017，默认的HTTP端口是数据库状态页面，（开启后，web页面的Commands行中的命令都可以点进去）。mongodb自带的REST，不支持增、删、改，同时也不支持 权限认证。

rest = true  

#repair：修复数据库操作，默认是false。设置为true时，启动后修复所有数据库，设置这个选项最好在命令行上，而不是在配置文件或控制脚本。启动时修复，需要关闭journal.并且启动时,用控制文件指定参数和配置文件里指定参数的方式进行修复之后，（修复信息见log），需要再禁用repair参数才能启用mongodb。注意：mongod修复时，需要重写所有的数据库文件。如果在同一个帐号下不能运行修复，则需要运行chown修改数据库文件的权限。

repair = true  

#repairpath：修复路径，默认是在dbpath路径下的_tmp 目录。

repairpath = _tmp  

#smallfiles：是否使用较小的默认文件。默认为false，不使用。设置为true，使用较小的默认数据文件大小。smallfiles减少数据文件的初始大小，并限制他们到512M，也减少了日志文件的大小，并限制他们到128M。如果数据库很大，各持有少量的数据，会导致mongodb创建很多文件，会影响性能。

smallfiles = true  

#syncdelay：刷写数据到日志的频率，通过fsync操作数据。默认60秒。默认就可以，不需要设置。不会对日志文件（journal files）有影响。警告：如果设置为0，SYNCDELAY 不会同步到磁盘的内存映射文件。在生产系统上，不要设置这个值。

syncdelay = 60  

#sysinfo：系统信息，默认false。设置为true，mongod会诊断系统有关的页面大小，数量的物理页面，可用物理??页面的数量输出到标准输出。当开启sysinfo参数的时候，只会打印上面的信息，不会启动mongodb的程序。所以要关闭该参数，才能开启mongodb。

sysinfo = false  

#upgrade:升级。默认为false。当设置为true，指定DBPATH，升级磁盘上的数据格式的文件到最新版本。会影响数据库操作，更新元数据。大部分情况下，不需要设置该值。

upgrade = false  

#traceExceptions：是否使用内部诊断。默认false。

traceExceptions = false  

#quiet：安静模式。

quiet = true  

#setParameter：2.4的新参数，指定启动选项配置。想设置多个选项则用一个setParameter选项指定.格式：setParameter = <parameter>=<value>,如配置文件里设置syncdelay：

setParameter = syncdelay= 55,notablescan = true,journalCommitInterval = 50,traceExceptions = true 

1、processManagement:

    fork: <true | false>

    描述：是否以fork模式运行mongod/mongos进程，默认为false。

    pidFilePath:<路径>

    描述：配合"fork:true"参数，将mongod/mongos进程ID写入指定的文件，如果不指定，将不会创建PID文件。

2、net:

    bindIp: <127.0.0.1>

    描述：mongod/monogs进程绑定的IP，application通过此IP、port建立链接。可以绑定在任意网卡接口上，如果你的mongos/mongod只需要内网访问，可以绑定在内网IP(例如：192.168.1.100)，如果需要外网访问，那么则绑定外网IP，如果此值为“0.0.0.0”，则绑定到所有接口即内网、外网IP均可以访问。（不建议）可以绑定都多个ip上，ip地址之间用“,”分割。

    port: 27017

    描述：mongod/mongos侦听端口，默认为27017；不过因为mongodb有2种典型的架构模式：replica set和sharding，如果开发者在一个节点上部署多个mongod实例，需要注意修改此端口以避免冲突。

    maxIncomingConnections: 65536

    描述：mongod/mongos进程允许的最大连接数，如果此值超过操作系统配置的连接数阀值，将不会生效(ulimit)；默认值为65536。通常客户端将会使用连接池机制，可以有效的控制每个客户端的链接个数。

    wireObjectCheck: true

    描述：当客户端写入数据时，mongos/mongod是否检测数据的有效性(BSON)，如果数据格式不良，此insert、update操作将会被拒绝；默认值为true

    ipv6: false

    描述：是否支持mongos/mongod多个实例之间使用IPV6网络，默认值为false。此值需要在整个cluster中保持一致。

3、storage:

    dbPath: db

    描述：mongod进程存储数据目录，此配置仅对mongod进程有效。默认值为：/data/db。

    indexBuildRetry: true

    描述：当构建索引时mongod意外关闭，那么再次启动是否重新构建索引；索引构建失败，mongod重启后将会删除尚未完成的索引，但是否重建由此参数决定。默认值为true。

    repairPath: _tmp

    描述：配合--repair启动命令参数，在repair期间使用此目录存储临时数据，repair结束后此目录下数据将被删除，此配置仅对mongod进程有效。不建议在配置文件中配置，而是使用mongod启动命令指定。

    engine: mmapv1

    描述：存储引擎类型，mongodb 3.0之后支持“mmapv1”、“wiredTiger”两种引擎，默认值为“mmapv1”；官方宣称wiredTiger引擎更加优秀。

    journal:

        enabled: true

        描述：是否开启journal日志持久存储，journal日志用来数据恢复，是mongod最基础的特性，通常用于故障恢复。64位系统默认为true，32位默认为false，建议开启，仅对mongod进程有效。

    directoryPerDB: false

    描述：是否将不同DB的数据存储在不同的目录中，dbPath的子目录，目录名为db的名称。对已经存储数据的mongod修改此值，需要首先使用mongodump指令将数据导出，然后关闭mongod，再修改此值和指定新的dbPath，然后使用mongorestore指令重新导入数据。（即导出数据，并使用mongorestore将数据重新写入mongod的新目录中）

    对于replica set架构模式，只需要在每个secondary依次操作：关闭secondary，然后配置新的dbPath，然后启动即可（会执行初始化sync，从primary中将数据去完全同步到本地）。最后操作primary。

    此参数仅对mongod进程有效，默认值为false，不建议修改此值

    syncPeriodSecs: 60

    描述：mongod使用fsync操作将数据flush到磁盘的时间间隔，默认值为60（单位：秒），强烈建议不要修改此值；mongod将变更的数据写入journal后再写入内存，并间歇性的将内存数据flush到磁盘中，即延迟写入磁盘，有效提升磁盘效率。此指令不影响journal存储，仅对mongod有效。

    mmapv1:（如下配置仅对MMAPV1引擎生效）

        quota:

            enforced: false

            描述：配额管理，是否限制每个DB所能持有的最大文件数量，仅对mongod有效，默认值为false，建议保持默认值。

            maxFilesPerDB: 8

            描述：如果enforce开启，每个DB所持有的存储文件不会超过此阀值。仅对mongod进程有效。

        smallFiles: false

        描述：是否使用小文件存储数据；如果此值为true，mongod将会限定每个数据文件的大小为512M（默认最大为2G），journal降低到128M（默认为1G）。如果DB的数据量较大，将会导致每个DB创建大量的小文件，这对性能有一定的影响。在production环境下，不建议修改此值，在测试时可以设置为true，节约磁盘。

        journal:

            commitIntervalMs: 100

            描述：mongod进程提交journal日志的时间间隔，即fsync的间隔。考虑到磁盘效能，mongod间歇性的flush日志数据；此值越小，数据丢失的可能性越低，磁盘消耗越大，性能越低。如果希望write操作强制立即写入journal，可以传递参数选项“j:true”（在客户端write操作中指定此选项即可），此操作（包括此前尚未提交的）将会立即fsync到磁盘。仅对mongod有效，单位：毫秒

        nsSize: 每个database的namespace文件的大小，默认为16，单位：M；最大值可以设置为2048，即dbpath下“.ns”后缀文件的大小。16M基本上可以保存24000条命名条目，新建一个collection或者index信息，即会增加一个namespace条目；如果你的database下需要创建大量的collection（比如数据分析），则可以适度调大此值。

    wiredTiger:（如下配置仅对wiredTiger引擎生效（3.0以上版本）

        engineConfig:

            cacheSizeGB: 8

            描述：wiredTiger缓存工作集（working set）数据的内存大小，单位：GB，此值决定了wiredTiger与mmapv1的内存模型不同，它可以限制mongod对内存的使用量，而mmapv1则不能（依赖于系统级的mmap）。默认情况下，cacheSizeGB的值为假定当前节点只部署一个mongod实例，此值的大小为物理内存的一半；如果当前节点部署了多个mongod进程，那么需要合理配置此值。如果mongod部署在虚拟容器中（比如，lxc，cgroups，Docker）等，它将不能使用整个系统的物理内存，则需要适当调整此值。默认值为物理内存的一半。

            journalCompressor: snappy

            描述：journal日志的压缩算法，可选值为“none”、“snappy”、“zlib”。

            directoryForIndexes: false

            描述：是否将索引和collections数据分别存储在dbPath单独的目录中。即index数据保存“index”子目录，collections数据保存在“collection”子目录。默认值为false，仅对mongod有效。

        collectionConfig:

             blockCompressor: snappy

             描述：collection数据压缩算法，可选值“none”、“snappy”、“zlib”。开发者在创建collection时可以指定值，以覆盖此配置项。如果mongod中已经存在数据，修改此值不会带来问题，旧数据仍然使用原来的算法解压，新数据文件将会采用新的解压缩算法。

        indexConfig:

            prefixCompression: true

            描述：是否对索引数据使用“前缀压缩”（prefix compression，一种算法）。前缀压缩，对那些经过排序的值存储，有很大帮助，可以有效的减少索引数据的内存使用量。默认值为true。

4、operationProfiling:

    slowOpThresholdMs: 100

    描述：数据库profiler判定一个操作是“慢查询”的时间阀值，单位毫秒；mongod将会把慢查询记录到日志中，即使profiler被关闭。当profiler开启时，慢查询记录还会被写入“system.profile”这个系统级的collection中。请参看mongod profiler相关文档。默认值为100，此值只对mongod进程有效。

    mode: off

    描述：数据库profiler级别，操作的性能信息将会被写入日志文件中，可选值：

    1）off：关闭profiling

    2）slowOp：on，只包含慢操作日志

    3）all：on，记录所有操作

    数据库profiling会影响性能，建议只在性能调试阶段开启。此参数仅对mongod有效。

5、replication:（复制集架构模式配置，如果只是单点，则无需配置）

    oplogSizeMB: 10240

    描述：replication操作日志的最大尺寸，单位：MB。mongod进程根据磁盘最大可用空间来创建oplog，比如64位系统，oplog为磁盘可用空间的5%，一旦mongod创建了oplog文件，此后再次修改oplogSizeMB将不会生效。此值不要设置的太小， 应该足以保存24小时的操作日志，以保证secondary有充足的维护时间；如果太小，secondary将不能通过oplog来同步数据，只能全量同步。此值仅对mongod有效。

    enableMajorityReadConcern: false

    描述：是否开启readConcern的级别为“majority”，默认为false；只有开启此选项，才能在read操作中使用“majority”。（3.2+版本）

    replSetName: <无默认值>

    描述：“复制集”的名称，复制集中的所有mongd实例都必须有相同的名字，sharding分布式下，不同的sharding应该使用不同的replSetName。仅对mongod有效。

    secondaryIndexPrefetch: all

    描述：只对mmapv1存储引擎有效。复制集中的secondary，从oplog中运用变更操作之前，将会先把索引加载到内存中，默认情况下，secondaries首先将操作相关的索引加载到内存，然后再根据oplog应用操作。可选值：

    1）none：secondaries不将索引数据加载到内容

    2）all：sencondaries将此操作有关的索引数据加载到内存

    3）_id_only：只加载_id索引

    默认值为：all，此配置仅对mongod有效。

    localPingThresholdMs: 15

    描述：ping时间，单位：毫秒，mongos用来判定将客户端read请求发给哪个secondary。仅对mongos有效。默认值为15，和客户端driver中的默认值一样。当mongos接收到客户端read请求，它将：

    1、找出复制集中ping值最小的member。

    2、将延迟值被此值允许的members，构建一个列表

    3、从列表中随机选择一个member。

ping值是动态值，每10秒计算一次。mongos将客户端请求转发给延迟较小（与此值相比）的某个secondary节点。仅对mongos有效。

6、sharding:（仅对sharding架构模式下有效）

    clusterRole: <无默认值>

    描述：在sharding集群中，此mongod实例的角色，可选值：

    1、configsvr：此实例为config server，此实例默认侦听27019端口

    2、shardsvr：此实例为shard（分片），侦听27018端口

    此配置仅对mongod有效。通常config server和sharding server需要使用各自的配置文件。

    archiveMovedChunks: true

    描述：当chunks因为“负载平衡”而迁移到其他节点时，mongod是否将这些chunks归档，并保存在dbPath下“moveChunk”目录下，mongod不会删除moveChunk下的文件。默认为true。

    autoSplit: true

    描述：是否开启sharded collections的自动分裂，仅对mongos有效。如果所有的mongos都设定为false，那么collections数据增长但不能分裂成新的chunks。因为集群中任何一个mongos进程都可以触发split，所以此值需要在所有mongos行保持一致。仅对mongos有效。

    configDB: <无默认值>

    描述：设定config server的地址列表，每个server地址之间以“,”分割，通常sharded集群中指定1或者3个config server。（生产环境，通常是3个config server，但1个也是可以的）。所有的mongos实例必须配置一样，否则可能带来不必要的问题。仅对mongos有效。

    chunkSize: 64

    描述：sharded集群中每个chunk的大小，单位：MB，默认为64，此值对于绝大多数应用而言都是比较理想的。chunkSize太大会导致分布不均，太小会导致分裂成大量的chunk而经常移动

##整个sharding集群中，此值需要保持一致，集群启动后修改此值将不再生效。仅对mongos有效。

7、sytemsLog:（系统日志，必须配置）

    verbosity: 0

    描述：日志级别，0：默认值，包含“info”信息，1~5，即大于0的值均会包含debug信息

    quiet: true

    描述："安静"，此时mongod/mongos将会尝试减少日志的输出量。不建议在production环境下开启，否则将会导致跟踪错误比较困难。

    traceAllExceptions: true

    描述：打印异常详细信息。

    path:  logs/mongod.log

    logAppend: false

    描述：如果为true，当mongod/mongos重启后，将在现有日志的尾部继续添加日志。否则，将会备份当前日志文件，然后创建一个新的日志文件；默认为false。

    logRotate: rename

    描述：日志“回转”，防止一个日志文件特别大，则使用logRotate指令将文件“回转”，可选值：

    1）rename：重命名日志文件，默认值。

    2）reopen：使用linux日志rotate特性，关闭并重新打开此日志文件，可以避免日志丢失，但是logAppend必须为true。

    destination: file

    描述：日志输出目的地，可以指定为“ file”或者“syslog”，表述输出到日志文件，如果不指定，则会输出到标准输出中（standard output）。

security:  

    authorization: enabled  

    clusterAuthMode: keyFile  

    keyFile: /srv/mongodb/keyfile  

    javascriptEnabled: true  

setParameter:   

    enableLocalhostAuthBypass: true  

authenticationMechanisms: SCRAM-SHA-1 

 1）authorization：disabled或者enabled，仅对mongod有效；表示是否开启用户访问控制（Access Control），即客户端可以通过用户名和密码认证的方式访问系统的数据，默认为“disabled”，即客户端不需要密码即可访问数据库数据。（限定客户端与mongod、mongos的认证）

    2）clusterAuthMode：集群中members之间的认证模式，可选值为“keyFile”、“sendKeyFile”、“sendX509”、“x509”，对mongod/mongos有效；默认值为“keyFile”，mongodb官方推荐使用x509，不过我个人觉得还是keyFile比较易于学习和使用。不过3.0版本中，mongodb增加了对TLS/SSL的支持，如果可以的话，建议使用SSL相关的配置来认证集群的member，此文将不再介绍。（限定集群中members之间的认证）

    3）keyFile：当clusterAuthMode为“keyFile”时，此参数指定keyfile的位置，mongodb需要有访问此文件的权限。

    4）javascriptEnabled：true或者false，默认为true，仅对mongod有效；表示是否关闭server端的javascript功能，就是是否允许mongod上执行javascript脚本，如果为false，那么mapreduce、group命令等将无法使用，因为它们需要在mongod上执行javascript脚本方法。如果你的应用中没有mapreduce等操作的需求，为了安全起见，可以关闭javascript。

    “setParameter”允许指定一些的Server端参数，这些参数不依赖于存储引擎和交互机制，只是微调系统的运行状态，比如“认证机制”、“线程池参数”等。参见【parameter】

    1）enableLocalhostAuthBypass：true或者false，默认为true，对mongod/mongos有效；表示是否开启“localhost exception”，对于sharding cluster而言，我们倾向于在mongos上开启，在shard节点的mongod上关闭。

    2）authenticationMechanisms：认证机制，可选值为“SCRAM-SHA-1”、“MONGODB-CR”、“PLAN”等，建议为“SCRAM-SHA-1”，对mongod/mongos有效；一旦选定了认证机制，客户端访问databases时需要与其匹配才能有效。

setParameter:  

connPoolMaxShardedConnsPerHost: 200  

connPoolMaxConnsPerHost: 200  

notablescan: 0  

1）connPoolMaxShardedConnsPerHost：默认值为200，对mongod/mongos有效；表示当前mongos或者shard与集群中其他shards链接的链接池的最大容量，此值我们通常不会调整。连接池的容量不会阻止创建新的链接，但是从连接池中获取链接的个数不会超过此值。维护连接池需要一定的开支，保持一个链接也需要占用一定的系统资源。

2）connPoolMaxConnsPerHost：默认值为200，对mongod/mongos有效；同上，表示mongos或者mongod与其他mongod实例之间的连接池的容量，根据host限定。

systemLog:  

    quiet: false  

    path: /data/mongodb/logs/mongod.log  

    logAppend: false  

    destination: file  

processManagement:  

    fork: true  

    pidFilePath: /data/mongodb/mongod.pid  

net:  

    bindIp: 127.0.0.1  

    port: 27017  

    maxIncomingConnections: 65536  

    wireObjectCheck: true  

    ipv6: false   

storage:  

    dbPath: /data/mongodb/db  

    indexBuildRetry: true  

    journal:  

        enabled: true  

    directoryPerDB: false  

    engine: mmapv1  

    syncPeriodSecs: 60   

    mmapv1:  

        quota:  

            enforced: false  

            maxFilesPerDB: 8  

        smallFiles: true      

        journal:  

            commitIntervalMs: 100  

    wiredTiger:  

        engineConfig:  

            cacheSizeGB: 8  

            journalCompressor: snappy  

            directoryForIndexes: false    

        collectionConfig:  

            blockCompressor: snappy  

        indexConfig:  

            prefixCompression: true  

operationProfiling:  

    slowOpThresholdMs: 100  

    mode: off  

sharding:

    clusterRole: shardsvr

    archiveMovedChunks: true 

systemLog: 

    quiet: false 

    path: /data/mongodb/logs/mongod.log 

    logAppend: false 

    destination: file 

processManagement: 

    fork: true 

    pidFilePath: /data/mongodb/mongod.pid 

net: 

    bindIp: 127.0.0.1 

    port: 37017 

    maxIncomingConnections: 65536 

    wireObjectCheck: true 

    ipv6: false  

replication: 

    localPingThresholdMs: 15             

sharding: 

    autoSplit: true 

    configDB: m1.com:27018,m2.com:27018,m3.com:27018 

    chunkSize: 64

./mongod -f mongod.conf  

./mongod --bind_ip 127.0.0.1 --port 27017 --dbpath /data/mongodb/db --logpath /data/mongodb/logs --storageEngine mmapv1 --fork 

./mongo

> use admin;

> db.shutdownServer();  

[root@CentOS7 tools]# tar zxf mongodb-linux-x86_64-3.4.10.tgz -C /usr/local/

[root@CentOS7 tools]# mv /usr/local/mongodb-linux-x86_64-3.4.10/ /usr/local/mongodb

[root@CentOS7 /]# mkdir -p /usr/local/mongodb/{conf,data,keyfile,logs,tmp}

[root@CentOS7 /]# echo 'export PATH=$PATH:/usr/local/mongodb/bin' >> /etc/profile ; source /etc/profile

[root@CentOS7 /]# egrep -v "^#|^$" /etc/mongod.conf.bak

systemLog:

  destination: file

  logAppend: true

  path: /usr/local/mongodb/logs/mongod.log

storage:

  dbPath: /usr/local/mongodb/data

  journal:

    enabled: true

processManagement:

  fork: true  # fork and run in background

  pidFilePath: /usr/local/mongodb/tmp/mongod.pid  # location of pidfile

net:

  port: 27017

  bindIp: 0.0.0.0  # Listen to local interface only, comment to listen on all interfaces.

security:

    authorization: enabled

#!/bin/sh

#

#mongod - Startup script for mongod

#

# chkconfig: - 85 15

# description: Mongodb database.

# processname: mongod  

# Source function library

. /etc/rc.d/init.d/functions  

# things from mongod.conf get there by mongod reading it

# OPTIONS

OPTIONS=" -f /etc/mongod.conf"  

#mongod

mongod="/usr/local/mongodb/bin/mongod"  

lockfile=/usr/local/mongodb/keyfile/mongod  

start()

{

  echo -n $"Starting mongod: "

  $mongod $OPTIONS

  RETVAL=$?

  echo

  [ $RETVAL -eq 0 ] && touch $lockfile

}  

stop()

{

  echo -n $"Stopping mongod: "

  killproc $mongod -QUIT

  RETVAL=$?

  echo

  [ $RETVAL -eq 0 ] && rm -f $lockfile

}  

restart () {

        stop

        start

}  

ulimit -n 12000

RETVAL=0  

case "$1" in

  start)

    start

    ;;

  stop)

    stop

    ;;

  restart|reload|force-reload)

    restart

    ;;

  condrestart)

    [ -f $lockfile ] && restart || :

    ;;

  status)

    status $mongod

    RETVAL=$?

    ;;

  *)

    echo "Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"

    RETVAL=1

esac  

exit $RETVAL  

[Unit]

Description=mongo

After=network.target

[Service]

Type=forking

PIDFile=/usr/local/mongodb/tmp/mongod.pid

ExecStart=/usr/local/mongodb/bin/mongod -f /etc/mongod.conf.bak

ExecReload=/bin/kill -s HUP $MAINPID

ExecStop=/bin/kill -s QUIT $MAINPID

PrivateTmp=true

[Install]

WantedBy=multi-user.target

{

   _id: POST_ID

   title: TITLE_OF_POST,

   description: POST_DESCRIPTION,

   by: POST_BY,

   url: URL_OF_POST,

   tags: [TAG1, TAG2, TAG3],

   likes: TOTAL_LIKES,

   comments: [   

      {

         user:'COMMENT_BY',

         message: TEXT,

         dateCreated: DATE_TIME,

         like: LIKES

      },

      {

         user:'COMMENT_BY',

         message: TEXT,

         dateCreated: DATE_TIME,

         like: LIKES

      }

   ]

}

use DATABASE_NAME

> use lizexiong

switched to db lizexiong

>db

newdb

>show dbs

local     0.000025GB

test      0.00002GB

>db.name.insert({"name":" lizexiong"})

>show dbs

local     0.00005GB

test      0.00002GB

lizexiong 0.00002GB

db.dropDatabase()

> show dbs;

admin      0.000GB

lizexiong  0.000GB

local      0.000GB

> use lizexiong

switched to db lizexiong

> db.dropDatabase()

{ "dropped" : "lizexiong", "ok" : 1 }

#最后检查结果

> show dbs

admin  0.000GB

local  0.000GB

>use test

switched to db test

>db.createCollection("mycollection")

{ "ok" : 1 }

>show collections

mycollection

> db.createCollection("mycol", {capped : true, autoIndexId : true, size : 6142800, max : 10000 })

{ "ok" : 1 }

>db.newcollection.insert({"name" : "lizexiong"})

>show collections

mycol

newcollection

mycollection

db.COLLECTION_NAME.drop()

>use test

switched to db test

> show collections

mycol

mycollection

newcollection

>db.mycollection.drop()

true

>db.COLLECTION_NAME.insert(document)

db.mycol.insert({

   _id: 100,

   title: 'MongoDB Overview',

   description: 'MongoDB is no sql database',

   by: 'yiibai tutorials',

   url: 'http://www.huawei.com',

   tags: ['mongodb', 'database', 'NoSQL'],

   likes: 100,

})

_id: ObjectId(4 bytes timestamp, 3 bytes machine id, 2 bytes process id,

   3 bytes incrementer) 

> db.mycol.insert([

   {

      _id: 101,

      title: 'MongoDB Guide',

      description: 'MongoDB is no sql database',

      by: 'yiibai tutorials',

      url: 'http://www.huawei.com',

      tags: ['mongodb', 'database', 'NoSQL'],

      likes: 100

   },

   {

      _id: 102,

      title: 'NoSQL Database',

      description: "NoSQL database doesn't have tables",

      by: 'yiibai tutorials',

      url: 'http://www.huawei.com',

      tags: ['mongodb', 'database', 'NoSQL'],

      likes: 210,

      comments: [

         {

            user:'user1',

            message: 'My first comment',

            dateCreated: new Date(2017,11,10,2,35),

            like: 0

         }

      ]

   },

   {

      _id: 104,

      title: 'Python Quick Guide',

      description: "Python Quick start ",

      by: 'yiibai tutorials',

      url: 'http://www.huawei.com',

      tags: ['Python', 'database', 'NoSQL'],

      likes: 30,

      comments: [

         {

            user:'user1',

            message: 'My first comment',

            dateCreated: new Date(2018,11,10,2,35),

            like: 590

         }

      ]

   }

])

成功结果为:

BulkWriteResult({

         "writeErrors" : [ ],

         "writeConcernErrors" : [ ],

         "nInserted" : 3,

         "nUpserted" : 0,

         "nMatched" : 0,

         "nModified" : 0,

         "nRemoved" : 0,

         "upserted" : [ ]

})

db.inventory.insertOne(

   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }

)

> db.inventory.insertOne(

...    { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }

... )

{

 "acknowledged" : true,

 "insertedId" : ObjectId("5a5719d8ddd1e4ed6d858660")

db.inventory.insertMany([

   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },

   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },

   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }

])

> db.inventory.insertMany([

...    { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },

...    { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },

...    { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }

... ])

{

 "acknowledged" : true,

 "insertedIds" : [

  ObjectId("5a571a8addd1e4ed6d858661"),

  ObjectId("5a571a8addd1e4ed6d858662"),

  ObjectId("5a571a8addd1e4ed6d858663")

 ]

}

>db.COLLECTION_NAME.find(document)

Shell

> db.mycol.find().pretty()

>db.mycol.find().pretty()

{

   "_id": 100,

   "title": "MongoDB Overview",

   "description": "MongoDB is no sql database",

   "by": "yiibai tutorials",

   "url": "http://www.huawei.com",

   "tags": ["mongodb", "database", "NoSQL"],

   "likes": "100"

}

>db.mycol.find(

   {

      $and: [

         {key1: value1}, {key2:value2}

      ]

   }

).pretty()

> db.mycol.find({$and:[{"by":"yiibai tutorials"},{"title": "MongoDB Overview"}]}).pretty()

{

 "_id" : 100,

 "title" : "MongoDB Overview",

 "description" : "MongoDB is no sql database",

 "by" : "yiibai tutorials",

 "url" : "http://www.huawei.com",

 "tags" : [

  "mongodb",

  "database",

  "NoSQL"

 ],

 "likes" : 100

}

SELECT * FROM mycol where by ='yiibai tutorials' AND title ='MongoDB Overview' 

>db.mycol.find(

   {

      $or: [

         {key1: value1}, {key2:value2}

      ]

   }

).pretty()

> db.mycol.find({$or:[{"by":"yiibai tutorials"},{"title": "MongoDB Overview"}]}).pretty()

SELECT * FROM mycol where likes> 10 AND(by ='yiibai tutorials' OR title ='MongoDB Overview')

db.mycol.find({"likes": {$gt:10}, $or: [{"by": "yiibai tutorials"},

   {"title": "MongoDB Overview"}]}).pretty()

db.inventory.insertMany( [

   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },

   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },

   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },

   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },

   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }

]);

> db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

{ "_id" : ObjectId("5a572a08ddd1e4ed6d858664"), "item" : "journal", "qty" : 25, "size" : { "h" : 14, "w" : 21, "uom" : "cm" }, "status" : "A" }

db.inventory.find(  { size: { w: 21, h: 14, uom: "cm" } }  )

{ <field1>: { <operator1>: <value1> }, ... }

db.inventory.find( { "size.h": { $lt: 15 } } )

db.mycol.find({}, {'_id':1, 'title':1})

{ "_id" : 100, "title" : "MongoDB Overview" }

{ "_id" : 101, "title" : "MongoDB Guide" }

{ "_id" : 102, "title" : "NoSQL Database" }

{ "_id" : 104, "title" : "Python Quick Guide" }

> db.mycol.find({'title':'MongoDB Overview'},{'_id':1, 'title':1})

{ "_id" : 100, "title" : "MongoDB Overview" }

> # 更新操作

> db.mycol.update({'title':'MongoDB Overview'},{$set:{'title':'New Update MongoDB Overview'}})

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

> # 查询更新后的结果 -

> db.mycol.find({'_id':100},{'_id':1, 'title':1})

{ "_id" : 100, "title" : "New Update MongoDB Overview" }

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

> db.mycol.remove({'_id':100})

WriteResult({ "nRemoved" : 1 })

>db.COLLECTION_NAME.find({},{KEY:1})

> db.mycol.find({}, {'title':1,'_id':0})

{ "title" : "MongoDB Guide" }

{ "title" : "NoSQL Database" }

{ "title" : "Python Quick Guide" }

{ "title" : "MongoDB Overview" }

> db.mycol.find({}, {'title':1,'by':1, 'url':1})

{ "_id" : 101, "title" : "MongoDB Guide", "by" : "yiibai tutorials", "url" : "http://www.huawei.com" }

{ "_id" : 102, "title" : "NoSQL Database", "by" : "yiibai tutorials", "url" : "http://www.huawei.com" }

{ "_id" : 104, "title" : "Python Quick Guide", "by" : "yiibai tutorials", "url" : "http://www.huawei.com" }

> db.COLLECTION_NAME.find().limit(NUMBER)

> db.mycol.find({},{"title":1,_id:0}).limit(2)

{ "title" : "MongoDB Guide" }

{ "title" : "NoSQL Database" }

> 

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

> db.mycol.find({},{"title":1,_id:0}).limit(1).skip(2)

{ "title" : "Python Quick Guide" }

>

Shell

>db.COLLECTION_NAME.find().sort({KEY:1})

> ## 按`title`降序排序

> db.mycol.find({},{"title":1,_id:0}).sort({"title":-1})

{ "title" : "Python Quick Guide" }

{ "title" : "NoSQL Database" }

{ "title" : "MongoDB Overview" }

{ "title" : "MongoDB Guide" }

> ## 按`title`升序排序

> db.mycol.find({},{"title":1,_id:0}).sort({"title":1})

{ "title" : "MongoDB Guide" }

{ "title" : "MongoDB Overview" }

{ "title" : "NoSQL Database" }

{ "title" : "Python Quick Guide" }

> 

>db.COLLECTION_NAME.ensureIndex({KEY:1})

>db.mycol.ensureIndex({"title":1})

>db.mycol.ensureIndex({"title":1,"description":-1})

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

db.article.insert([

{

   _id: 100,

   title: 'MongoDB Overview',

   description: 'MongoDB is no sql database',

   by_user: 'Maxsu',

   url: 'http://www.yiibai.com',

   tags: ['mongodb', 'database', 'NoSQL'],

   likes: 100

},

{

   _id: 101,

   title: 'NoSQL Overview',

   description: 'No sql database is very fast',

   by_user: 'Maxsu',

   url: 'http://www.yiibai.com',

   tags: ['mongodb', 'database', 'NoSQL'],

   likes: 10

},

{

   _id: 102,

   title: 'Neo4j Overview',

   description: 'Neo4j is no sql database',

   by_user: 'Kuber',

   url: 'http://www.neo4j.com',

   tags: ['neo4j', 'database', 'NoSQL'],

   likes: 750

},

{

   _id: 103,

   title: 'MySQL Overview',

   description: 'MySQL is sql database',

   by_user: 'Curry',

   url: 'http://www.yiibai.com/mysql/',

   tags: ['MySQL', 'database', 'SQL'],

   likes: 350

}])Shell

> db.article.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])

{ "_id" : "Curry", "num_tutorial" : 1 }

{ "_id" : "Kuber", "num_tutorial" : 1 }

{ "_id" : "Maxsu", "num_tutorial" : 2 }

>Shell

select by_user, count(*) as num_tutorial from `article` group by by_user

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0

>rs.add(HOST_NAME:PORT)

>rs.add("mongod1.net:27017")

> 

rs0:PRIMARY> db.isMaster()

{

        "hosts" : [

                "ubuntu:27017"

        ],

        "setName" : "rs0",

        "setVersion" : 1,

        "ismaster" : true,

        "secondary" : false,

        "primary" : "ubuntu:27017",

        "me" : "ubuntu:27017",

        "electionId" : ObjectId("7fffffff0000000000000001"),

        "lastWrite" : {

                "opTime" : {

                        "ts" : Timestamp(1498896581, 1),

                        "t" : NumberLong(1)

                },

                "lastWriteDate" : ISODate("2017-07-01T08:09:41Z")

        },

        "maxBsonObjectSize" : 16777216,

        "maxMessageSizeBytes" : 48000000,

        "maxWriteBatchSize" : 1000,

        "localTime" : ISODate("2017-07-01T08:09:50.365Z"),

        "maxWireVersion" : 5,

        "minWireVersion" : 0,

        "readOnly" : false,

        "ok" : 1

}

rs0:PRIMARY>

$ mongo

> use admin

> db.createUser(

     {

       user:"root",

       pwd:"huawei",

       roles:[{role:"root",db:"admin"}]

     }

  )

> exit

> use mydb

> db.createUser(

    {

      user: "user01",

      pwd: "pwd123",

      roles: ["readWrite"]

    }

 ) 

> exit

> db.auth('user01','pwd123')

1

> 

> use mydb

> db.dropUser('user01)

Shell use test

db.createUser(

   {

     user: "mynewuser",

     pwd: "myuser123",

     roles: [ "readWrite", "dbAdmin" ]

   }

);

use test

db.createUser(

   {

     user: "mynewuser1",

     pwd: "myuser1123",

     roles: [ ]

   }

);

use admin

db.createUser(

   {

     user: "myadmin1",

     pwd: "myadmin123",

     roles:

       [

         { role: "readWrite", db: "config" },

         "clusterAdmin"

       ]

   }

);

$ mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

use admin

db.createRole(

   {

     role: "manageOpRole",

     privileges: [

       { resource: { cluster: true }, actions: [ "killop", "inprog" ] },

       { resource: { db: "", collection: "" }, actions: [ "killCursors" ] }

     ],

     roles: []

   }

)

use admin

db.createRole(

   {

     role: "mongostatRole",

     privileges: [

       { resource: { cluster: true }, actions: [ "serverStatus" ] }

     ],

     roles: []

   }

)

$ mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

use reporting

db.getUser("reportsUser")

use accounts

db.getRole( "readWrite", { showPrivileges: true } )

use reporting

db.revokeRolesFromUser(

    "reportsUser",

    [

      { role: "readWrite", db: "accounts" }

    ]

)

use reporting

db.grantRolesToUser(

    "reportsUser",

    [

      { role: "read", db: "accounts" }

    ]

)

$ mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

db.changeUserPassword("reporting", "SOh3TbYhxuLiW8ypJPxmt1oOfL")

$ mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

use reporting

db.getUser("reportsUser")  #此方式,3.X以后才有

...

"roles" : [

   { "role" : "readWrite", "db" : "accounts" },

   { "role" : "read", "db" : "reporting" },

   { "role" : "read", "db" : "products" },

   { "role" : "read", "db" : "sales" }

]

$ mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

use products

db.getRole( "read", { showPrivileges: true } )

...

"privileges" : [

  {

    "resource": { "db" : "products", "collection" : "" },

    "actions": [ "collStats","dbHash","dbStats","find","killCursors","planCacheRead" ]

  },

  {

    "resource" : { "db" : "products", "collection" : "system.js" },

    "actions": [ "collStats","dbHash","dbStats","find","killCursors","planCacheRead" ]

10.   }

11. ],

12. "inheritedPrivileges" : [

13.   {

14.     "resource": { "db" : "products", "collection" : "" },

15.     "actions": [ "collStats","dbHash","dbStats","find","killCursors","planCacheRead" ]

16.   },

17.   {

18.     "resource" : { "db" : "products", "collection" : "system.js" },

19.     "actions": [ "collStats","dbHash","dbStats","find","killCursors","planCacheRead" ]

20.   }

21. ]