MongoDB Usage

最新推荐文章于 2024-08-27 07:42:15 发布

晚起的男孩

最新推荐文章于 2024-08-27 07:42:15 发布

阅读量764

点赞数 1

本文链接：https://blog.youkuaiyun.com/ghbfgb/article/details/78884796

版权

本文详细介绍了在Linux环境下MongoDB的安装、配置、开机启动设置以及MongoDB的启动与停止方法，包括配置文件参数解释，如日志路径、端口设置、数据存储目录、认证模式等。此外，还提供了关闭MongoDB服务的不同命令，以及MongoDB在不同场景下的启动选项和注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Linux下MongoDB安装和配置详解（一）

原创 2016年08月24日 16:35:03

一、MongoDB的安装

1.下载安装包

下载方式：

curl -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.2.9.tgz

解压缩压缩包：

tar zxvf mongodb-linux-x86_64-3.2.9.tgz

2. 安装准备

创建数据库文件夹与日志文件、配置文件：

mkdir -p /usr/local/server/mongodb/data

touch /usr/local/server/mongodb/mongod.log

touch /usr/local/server/mongodb/ mongodb.conf

将mongodb移动到/usr/local/server/mongdb文件夹：

mv mongodb-linux-x86_64-3.2.9/* /usr/local/server/mongodb/

3. 启动mongodb(有两种方式)

参数启动：

参数启动可以直接在命令后面加配置参数，也可以加配置文件启动，如下加配置参数启动：

cd /usr/local/server/mongodb/bin/mongod/bin/

./mongod --dbpath=/usr/local/server/mongodb/data --logpath=/usr/local/server/mongodb/mongod.log --logappend --port=27017 --fork

注：如果加权限就用 --auth 参数，不需要权限就去掉

如果在配置文件中配置好各项参数，则可以使用配置文件启动：

./mongod --config /usr/local/server/mongodb/mongodb.conf

附录： mongodb配置文件详解

系统服务启动：

使用系统服务命令启动需要先将服务加入到系统服务中，附录：将mongod添加到系统服务

service mongod start|stop|restart

注：可以将mongodb临时加入系统路径变量中，这样可以不用输入路径直接启动，代码如下：

export PATH= /usr/local/server/mongodb /bin:$PATH

然后可以查看是否成功：echo $PATH

4. 参数解释: --dbpath 数据库路径(数据文件)

--logpath 日志文件路径

--master 指定为主机器

--slave 指定为从机器

--source 指定主机器的IP地址

--pologSize 指定日志文件大小不超过64M.因为resync是非常操作量大且耗时，最好通过设置一个足够大的oplogSize来避免resync(默认的 oplog大小是空闲磁盘大小的5%)。

--logappend 日志文件末尾添加

--port 启用端口号

--fork 在后台运行

--only 指定只复制哪一个数据库

--slavedelay 指从复制检测的时间间隔

--auth 是否需要验证权限登录(用户名和密码)

--config 配置文件位置

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------

二、用户授权和管理

1、mongodb安装好后第一次进入是不需要密码的，也没有任何用户，通过shell命令可直接进入，cd到mongodb目录下的bin文件夹，执行命令./mongo即可

运行如下：

[root@namenode mongodb]# ./bin/mongo

MongoDB shell version: 1.8.2

connecting to: test

> use test;

switched to db test

2、添加管理用户（mongoDB 没有无敌用户root，只有能管理用户的用户 userAdminAnyDatabase）,

>use admin

>db.createUser( {user: "admin",pwd: "123456",roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]})

注：添加完用户后可以使用show users或db.system.users.find()查看已有用户

3、添加完管理用户后，关闭MongoDB，并使用权限方式再次开启MongoDB，这里注意不要使用kill直接去杀掉mongodb进程，（如果这样做了，请去data/db目录下删除mongo.lock文件），可以使用db.shutdownServer()关闭

4、使用权限方式启动MongoDB

./mongod --dbpath=/usr/local/server/mongodb/data --logpath=/usr/local/server/mongodb/mongod.log --fork --auth

或者在配置文件中修改：

auth = true

#noauth = true

5、进入mongo shell，使用admin数据库并进行验证，如果不验证，是做不了任何操作的。

> use admin

> db.auth("admin","123456") #认证，返回1表示成功

6、验证之后还是做不了操作，因为admin只有用户管理权限，下面创建用户，用户都跟着库走，

> use mydb

> db.createUser({user: "root",pwd: "123456",roles: [{ role: "readWrite", db: "mydb" }]})

7、使用创建的用户root登录进行数据库操作：

[root@localhost mongodb]# mongo 127.0.0.1/mydb -uroot -p

MongoDB shell version: 3.2.9

Enter password:

connecting to: 127.0.0.1/mydb

> db

mydb

> use mydb

switched to db mydb

> show collections

然后就可以进行增删改查各种数据操作...

------------------------------------------------------------------------------------------------------------------------------------------------------------------

Linux下MongoDB安装和配置详解（二）

原创 2016年08月24日 16:36:09

二、mongoDB配置详解

-----------------------------------------配置文件------------------------------------------

#启用日志文件，默认启用

journal=true

#这个选项可以过滤掉一些无用的日志信息，若需要调试使用请设置为false

quiet=false

# 日志文件位置

logpath=/usr/local/server/mongodb/logs

# 以追加方式写入日志

logappend=true

# 是否以守护进程方式运行

fork = true

# 默认27017

port = 27017

# 数据库文件位置

dbpath=/usr/local/server/mongodb/data

# 启用定期记录CPU利用率和 I/O 等待

#cpu = true

# 是否以安全认证方式运行，默认是不认证的非安全方式

#auth = true

#noauth = true

# 详细记录输出

#verbose = true

# Inspect all client data for validity on receipt (useful for

# developing drivers)用于开发驱动程序时验证客户端请求

#objcheck = true

# Enable db quota management

# 启用数据库配额管理

#quota = true

# 设置oplog记录等级

# Set oplogging level where n is

# 0=off (default)

# 1=W

# 2=R

# 3=both

# 7=W+some reads

#diaglog=0

# Diagnostic/debugging option 动态调试项

#nocursors = true

# Ignore query hints 忽略查询提示

#nohints = true

# 禁用http界面，默认为localhost：28017

#nohttpinterface = true

# 关闭服务器端脚本，这将极大的限制功能

# Turns off server-side scripting. This will result in greatly limited

# functionality

#noscripting = true

# 关闭扫描表，任何查询将会是扫描失败

# Turns off table scans. Any query that would do a table scan fails.

#notablescan = true

# 关闭数据文件预分配

# Disable data file preallocation.

#noprealloc = true

# 为新数据库指定.ns文件的大小，单位:MB

# Specify .ns file size for new databases.

# nssize =

# Replication Options 复制选项

# in replicated mongo databases, specify the replica set name here

#replSet=setname

# maximum size in megabytes for replication operation log

#oplogSize=1024

# path to a key file storing authentication info for connections

# between replica set members

#指定存储身份验证信息的密钥文件的路径

#keyFile=/path/to/keyfile

----------------------------------------------------配置文件----------------------------------------

MongoDB各配置参数详细说明：

1、verbose：

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

如：verbose = true

2.vvvv = true

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

3、port：

端口。默认27017，MongoDB的默认服务TCP端口，监听客户端连接。要是端口设置小于1024，比如1021，则需要root权限启动，不能用 mongodb帐号启动，（普通帐号即使是27017也起不来）否则报错：[mongo --port=1021 连接]

ERROR: listen(): bind() failed errno:13 Permission denied for socket: 127.0.0.1:1021

如：port = 27017

4、bind_ip：

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

如：bind_ip = 127.0.0.1

5、maxConns：

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

如：maxConns = 100

6、objcheck:

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

如：objcheck = true

7、noobjcheck：

同上，默认关闭false。

如：noobjcheck = false

8、logpath：

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

如：logpath=/var/log/mongodb/mongodb.log

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

如：logappend=true

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

如：syslog = true

11、pidfilepath：

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

如：pidfilepath = /var/run/mongo.pid

12、keyFile：
指定存储身份验证信息的密钥文件的路径。默认缺省。详情见："
word-spacing: 0px; display: inline; white-space: normal; orphans: 2; widows: 2; font-size-adjust: none; font-stretch: normal; background- color: #ffffff; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px;">Replica Set Security" and “Replica Set Administration.”
如：.keyFile = /srv/mongodb/keyfile

13、nounixsocket：

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

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

如：unixSocketPrefix = /tmp

14、fork：

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

如：fork = true

15、auth：

用户认证，默认false。不需要认证。当设置为true时候，进入数据库需要auth验证，当数据库里没有用户，则不需要验证也可以操作。直到创建了第一个用户，之后操作都需要验证。

比如：通过db.addUser('sa','sa') 在admin库下面创建一个超级用户，只能在在admin库下面先认证完毕了：ab.auth('sa','sa') ，才能去别的库操作，不能在其他库验证。这样连接数据库也需要指定库：

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

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

如：auth = true

16、noauth：

禁止用户认证，默认true。同上

如：noauth = true

17、cpu：

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

开启日志会出现：

1.Mon Jun 10 10:21:42.241 [snapshotthread] cpu: elapsed:4000 writelock: 0%

如：cpu = true

18、dbpath：

数据存放目录。默认： word-spacing: 0px; white-space: normal; orphans: 2; widows: 2; font-size-adjust: none; font-stretch: normal; background-color: #ffffff; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px;">/data/db/

如：dbpath=/var/lib/mongodb

19、diaglog：

创建一个非常详细的故障排除和各种错误的诊断日志记录。默认0。设置为1，为在dbpath目录里生成一个diaglog.开头的日志文件，他的值如下：

1.Value    Setting
2.0    off. No logging.       #关闭。没有记录。
3.1    Log write operations. #写操作
4.2    Log read operations.   #读操作
5.3    Log both read and write operations. #读写操作
6.7    Log write and some read operations. #写和一些读操作

设置不等于0，日志会每分钟flush 一次：

1.Mon Jun 10 11:16:17.504 [DataFileSync] flushing diag log
2.Mon Jun 10 11:17:17.442 [DataFileSync] flushing diag log

产生的日志可以用mongosniff 来查看：要是mongosniff[类似于tcpdump的作为一个MongoDB的特定的TCP/ IP网络流量]出现报错和具体用法，请见这里，之前先执行：apt-get install libpcap-dev

1.root@m3:/var/lib/mongodb# mongosniff --source DIAGLOG diaglog.51b542a9

注意：当重新设置成0，会停止写入文件，但mongod还是继续保持打开该文件，即使它不再写入数据文件。如果你想重命名，移动或删除诊断日志，你必须完全关闭mongod实例。

如：diaglog = 3

20、directoryperdb：

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

01.原始数据结构：
02.journal
03.mongod.lock
04.local.0
05.local.1
06.local.ns
07.test.0
08.test.1
09.test.ns
10.
11.开启 directoryperdb，并把数据文件迁移到相关的数据目录后的结构：
12.
13.journal
14.mongod.lock
15.local/local.0
16.local/local.1
17.local/local.ns
18.test/test.0
19.test/test.1
20.test/test.ns

如：directoryperdb = ture

21、journal：

日志，（redo log，更多的介绍请看这里和这里）
默认值：（在64位系统）true。
默认值：（32位系统）false。
设置为true，启用操作日志，以确保写入持久性和数据的一致性，会在dbpath目录下创建journal目录。
设置为false，以防止日志持久性的情况下，并不需要开销。为了减少磁盘上使用的日志的影响，您可以启用nojournal，并设置为true。
注意：在64位系统上禁用日志必须使用带有nojournal的。

1.#journal=true
2.journal=false

32位OS：

1.Tue Jun 11 12:17:09.628 [initandlisten] ** NOTE: This is a 32 bit MongoDB binary.
2.Tue Jun 11 12:17:09.628 [initandlisten] ** 32 bit builds are limited to less than 2GB of data (or less with --journal).

64位OS：

1.Tue Jun 11 12:29:34 [initandlisten] journal dir=/var/lib/mongodb/journal
2.Tue Jun 11 12:29:34 [initandlisten] recover : no journal files present, no recovery needed

22、nojournal:

禁止日志

默认值：（在64位系统）false。
默认值：（32位系统）true。
设置nojournal为true关闭日志，64位，2.0版本后的mongodb默认是启用 journal日志。

如：nojournal=true

23、journalCommitInterval：

刷写提交机制，默认是30ms或则100ms。较低的值，会更消耗磁盘的性能。
此选项接受2和300毫秒之间的值：
如果单块设备提供日志和数据文件，默认的日记提交时间间隔为100毫秒。
如果不同的块设备提供的日志和数据文件，默认的日记提交的时间间隔为30毫秒。

如：journalCommitInterval=100

24、ipv6：

是否支持ipv6，默认false。

25、jsonp：

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

26、nohttpinterface：

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

如：nohttpinterface = false

27、noprealloc：

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

如：noprealloc = false

28、noscripting：

是否禁止脚本引擎。默认是false：不禁止。ture：禁止
要是设置成true：运行一些脚本的时候会出现：

1.JavaScript execution failed: group command failed: { "ok" : 0, "errmsg" : "server-side JavaScript execution is disabled" }

1.#noscripting = true <====> noscripting = false

notablescan：是否禁止表扫描操作。默认false：不禁止，ture：禁止

禁止要是执行表扫描会出现：

1.error: { "$err" : "table scans not allowed:test.emp", "code" : 10111 }

可以动态修改设置：

1.db.adminCommand({setParameter:1, notablescan:false})

1.#notablescan = true <====> notablescan = false

29、nssize:

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

1.-rwxrwxrwx 1 mongodb zhoujy 16M 6月 11 14:44 test.0
2.-rwxrwxrwx 1 mongodb zhoujy 32M 6月 1 21:36 test.1
3.-rwxrwxrwx 1 mongodb zhoujy 16M 6月 11 14:44 test.ns
4.drwxr-xr-x 2 root root 4.0K 6月 10 11:57 _tmp

如：nssize = 16

30、profile：

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

1.级别设置
2.0 关。无分析。
3.1 开。仅包括慢操作。
4.2 开。包括所有操作。

控制 Profiling 的开关和级别：2种
第一种是直接在启动参数里直接进行设置或则启动MongoDB时加上–profile=级别，其信息保存在生成的system.profile 中。

如：profile = 2

第二种是在客户端用db.setProfilingLevel(级别)命令来实时配置，其信息保存在生成的system.profile 中。

1.[initandlisten] creating profile collection: local.system.profile

1.> db.setProfilingLevel(2)
2.{ "was" : 0, "slowms" : 100, "ok" : 1 }
3.> db.getProfilingStatus()
4.{ "was" : 2, "slowms" : 100 }

默认情况下，mongod的禁用分析。数据库分析可以影响数据库的性能，因为分析器必须记录和处理所有的数据库操作。所以在需要的时候用动态修改就可以了。

31、slowms：

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

1.slowms = 200

1.> db.getProfilingStatus()
2.{ "was" : 2, "slowms" : 200 }

32、quota：

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

如：quota = true

33、quotaFiles：

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

如：quotaFiles = 8

34、rest：

默认false，设置为true，使一个简单的 REST API。

如：rest = true

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

35、repair：

修复数据库操作，默认是false。
设置为true时，启动后修复所有数据库，设置这个选项最好在命令行上，而不是在配置文件或控制脚本。如：
命令行修复：

1.> db.repairDatabase('xxx')
2.{ "ok" : 1 }
3.> db.repairDatabase()
4.{ "ok" : 1 }

启动时修复：

1.repair = true

1.root@m3:/var/log/mongodb# mongod --repair

启动时修复，需要关闭journal，否则报错:

1.Can't specify both --journal and --repair options.

并且启动时，用控制文件指定参数和配置文件里指定参数的方式进行修复之后，（修复信息见log），需要再禁用repair参数才能启用mongodb。
注意：mongod修复时，需要重写所有的数据库文件。如果在同一个帐号下不能运行修复，则需要运行chown修改数据库文件的权限。

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

1.drwxr-xr-x 2 root root 4.0K 6月 11 20:23 _tmp

36、smallfiles：

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

如：smallfiles = true

37、syncdelay：

刷写数据到日志的频率，通过fsync操作数据。默认60秒。

如：syncdelay = 60

默认就可以，不需要设置。不会对日志文件（journal files）有影响

警告：如果设置为0，SYNCDELAY 不会同步到磁盘的内存映射文件。在生产系统上，不要设置这个值。

38、sysinfo：

系统信息，默认false。

设置为true，mongod会诊断系统有关的页面大小，数量的物理页面，可用物理??页面的数量输出到标准输出。

1.Tue Jun 11 21:07:15.031 sysinfo:
2.Tue Jun 11 21:07:15.035   page size: 4096
3.Tue Jun 11 21:07:15.035   _SC_PHYS_PAGES: 256318
4.Tue Jun 11 21:07:15.035   _SC_AVPHYS_PAGES: 19895

当开启sysinfo参数的时候，只会打印上面的信息，不会启动mongodb的程序。所以要关闭该参数，才能开启mongodb。

39、upgrade:

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

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

如：traceExceptions = false

40、quiet：

安静模式。

如：quiet = true

41、setParameter：

2.4的新参数，指定启动选项配置。想设置多个选项则用一个setParameter选项指定，可以setParameter的参数请见这里，详情请见这里
声明setParameter设置在这个文件中，使用下面的格式：

如：setParameter = <parameter>=<value>

如配置文件里设置syncdelay：

1.setParameter = syncdelay= 55,notablescan = true,journalCommitInterval = 50,traceExceptions = true
Replication Options 复制选项

42、replSet：

使用此设置来配置复制副本集。指定一个副本集名称作为参数，所有主机都必须有相同的名称作为同一个副本集。

43、oplogSize：

指定的复制操作日志（OPLOG）的最大大小。mongod创建一个OPLOG的大小基于最大可用空间量。对于64位系统，OPLOG通常是5％的可用磁盘空间。
一旦mongod第一次创建OPLOG，改变oplogSize将不会影响OPLOG的大小。

44、fastsync：

默认为false。在副本集下，设置为true，从一个dbpath里启用从库复制服务，该dbpath的数据库是主库的快照，可用于快速启用同步，否则的mongod将尝试执行初始同步。注意：如果数据不完全同步，mongod指定fastsync开启，secondary或slave与主永久不同步，这可能会导致显着的一致性问题。

45、replIndexPrefetch：

2.2版本出现的新参数，默认是all。可以设置的值有：all, none, and _id_only。只能在副本集（replSet）中使用。默认情况下，secondary副本集的成员将加载所有索引到内存中（从OPLOG之前的操作有关的）。您可以修改此行为，使secondary只会加载_id索引。指定_id_或none，防止mongod的任何索引加载到内存。

46、Master/Slave Replication：主从复制的相关设置

master：默认为false，当设置为true，则配置当前实例作为主实例。

如：master = true

47、slave：

默认为false，当设置为true，则配置当前实例作为从实例。

如：slave = true

48、source：

默认为空，格式为：<host><:port>。用于从实例的复制：设置从的时候指定该选项会让从复制指定主的实例

如：source = 127.0.0.1:30001

49、only：

默认为空，用于从选项，指定一个数据库进行复制。

如：only = abc #只同步abc集合（库）

50、slavedelay：

设置从库同步主库的延迟时间，用于从设置，默认为0。

如：slavedelay = 60 #延迟60s同步主数据

51、autoresync：

默认为false，用于从设置。是否自动重新同步。设置为true，如果落后主超过10秒，会强制从自动重新同步。如果oplogSize太小，此设置可能有问题。如果OPLOG大小不足以存储主的变化状态和从的状态变化之间的差异，这种情况下强制重新同步是不必要的。当设置autoresync选项设置为false，10分钟内从不会进行大于1次的自动重新同步。

Linux下MongoDB安装和配置详解（三）

原创 2016年08月25日 10:02:22

一、将mongod服务添加为系统服务

MongoDB安装之后，每次都需要运行命令加参数来启动，不便于管理，这里可以将其添加到系统服务，方法如下：

1、创建文件

linux系统服务启动文件都存放在 /etc/init.d/ 下面，service mongod start 这样的命令是通过运行该目录下的脚本实现管理的，所以需要创建一个脚本文件mongod并修改读写权限

>touch mongod

>chmod 755 mongod

另外还需要用到一个文件来保存服务pid，service mongod stop 命令就是通过这个文件读取服务pid的,可以建立在MongoDB的安装目录下面，

>cd /usr/local/server/mongodb/

>touch mongod.pid

>chmod 755 mongod.pid

2、编写mongod脚本，以下为编写好的脚本示例：

##--------------------------------------------------------

#!/bin/bash

#chkconfig:35 23 34

#description: MongoDB service

#set -x

if [ -f /etc/init.d/functions ] ; then

##载入functions，. 在这里相当于source的功能--has a blank between . and /

. /etc/init.d/functions

##服务名，会多处调用

prog=mongod

##状态返回值，functions 函数会调用这个值

RETVAL=0

mongod=/usr/local/server/mongodb/bin/mongod

MONGODB_CONF_FILE=/usr/local/server/mongodb/mongodb.conf

lockfile=/var/lock/subsys/${prog} ##subsys目录下的文件是用于给其他程序判断服务的实例运行状态的

pidfile=/usr/local/server/mongodb/mongod.pid

start() {

echo -n $"Starting $prog: "

daemon $mongod --config $MONGODB_CONF_FILE ##daemon调用后面的命令执行情况

pgrep mongod>${pidfile} ##写入pid到pidfile

RETVAL=$?

echo

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

return $RETVAL

}

stop () {

echo -n $"Stopping $prog: "

killproc -p ${pidfile} ##killproc 从pidfile 获取到pid，并杀死

RETVAL=$?

echo

[ $RETVAL -eq 0 ] && /bin/rm -f ${lockfile}

return $RETVAL

}

case $1 in

start)

start

;;

stop)

stop

;;

restart)

stop

start

;;

echo $"Usage: $0 {start|stop|restart}"

exit 2

;;

esac

exit $?

##-------------------------------------------------------------------

3、通过这个脚本就可以实现系统服务启动、关闭、重启mongod服务了，然后我们可以让他开机启动:

>chkconfig mongod on

and
>chkconfig --add mongod

Self Operation:

chmod 755 functions--not necessary--correct import/source is : . [must has a blank here] /etc/init.d/functions

[root@xiaobai init.d]# export PATH=/usr/local/server/mongodb/bin:$PATH
[root@xiaobai init.d]# echo $PATH
/usr/local/server/mongodb/bin:/usr/lib64/qt-3.3/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:/home/jdk1.8.0_144/bin:/root/bin

[root@xiaobai init.d]# mongod --config /usr/local/server/mongodb/mongodb.conf
about to fork child process, waiting until server is ready for connections.
forked process: 4516
child process started successfully, parent exiting

[root@xiaobai init.d]# mongo --host=192.168.43.188
MongoDB shell version v3.4.6
connecting to: mongodb://192.168.43.188:27017/
MongoDB server version: 3.4.6
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:
2017-12-24T13:43:48.393+0800 I CONTROL [initandlisten]
2017-12-24T13:43:48.393+0800 I CONTROL [initandlisten] ** WARNING: Access control is not enabled for the database.
2017-12-24T13:43:48.393+0800 I CONTROL [initandlisten] **          Read and write access to data and configuration is unrestricted.
2017-12-24T13:43:48.393+0800 I CONTROL [initandlisten] ** WARNING: You are running this process as the root user, which is not recommended.
2017-12-24T13:43:48.393+0800 I CONTROL [initandlisten]
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten]
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten] **        We suggest setting it to 'never'
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten]
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten] **        We suggest setting it to 'never'
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten]
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 14473 processes, 110032 files. Number of processes should be at least 55016 : 0.5 times number of files.
2017-12-24T13:43:48.394+0800 I CONTROL [initandlisten]
>
>
>
>
>
>
> use test;
switched to db test
> use admin
switched to db admin
> db.createUser( {user: "admin",pwd: "123456",roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]})
Successfully added user: {
   "user" : "admin",
   "roles" : [
       {
           "role" : "userAdminAnyDatabase",
           "db" : "admin"
       }
   ]
}
> show users;
{
   "_id" : "admin.admin",
   "user" : "admin",
   "db" : "admin",
   "roles" : [
       {
           "role" : "userAdminAnyDatabase",
           "db" : "admin"
       }
   ]
}

Mongodb 启动关闭脚本并设置开机自动启动Mongodb2015-09-09 23:23:51

分类： MySQL

配置文件内容：
[root@yoon etc]# cat mongod.conf
logpath=/export/log/mongodb.log
logappend=true
fork = true
dbpath=/export/data/db
pidfilepath = /export/mongodb/etc/mongodb.pid
rest = true
httpinterface = true
port = 27017

脚本如下：
[root@yoon ~]# cd /etc/init.d/

[root@yoon init.d]# vi mongod

#!/bin/bash

# mongod - Startup script for mongod

# chkconfig: 35 80 15
# description: Mongo is a scalable, document-oriented database.
# processname: mongod
#config: /export/mongodb/etc/mongod.conf
# pidfile: /export/mongodb/etc/mongodb.pid

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

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

if [ $(id -u) != "0" ]; then
echo "Permission Denied! Please use root to run again!"
exit 1
fi

test -d /export/mongodb || (mkdir -p /export/mongodb ; chown mongod:mongod /export/mongodb)

# NOTE: if you change any OPTIONS here, you get what you pay for:
# this script assumes all options are in the config file.
CONFIGFILE="/export/mongodb/etc/mongod.conf"
SYSCONFIG="/etc/sysconfig/mongod"

export PATH=$PATH:/export/mongodb/bin/

DBPATH=`awk -F= '/^dbpath/{print $2}' "$CONFIGFILE"`
OPTIONS=" --config $CONFIGFILE"
mongod=${MONGOD-/export/mongodb/bin/mongod}
echo "db path is: "$DBPATH
echo $mongod
MONGO_USER=mongodb
MONGO_GROUP=mongodb

[ -f "$SYSCONFIG" ] && source "$SYSCONFIG"

super() {
su - $MONGO_USER -c "PATH=$PATH:/export/mongodb/bin/; $*"
}

start()
{
echo -n $"Starting mongod: "
# echo -n "$MONGO_USER" "numactl --interleave=all"
# daemon --user "$MONGO_USER" "numactl --interleave=all" $mongod $OPTIONS
# daemon --user "$MONGO_USER" $mongod $OPTIONS
#
# su - $MONGO_USER -c "$mongod $OPTIONS" -m -p
# su - $MONGO_USER
# $mongod $OPTIONS
daemon --user "$MONGO_USER" "numactl --interleave=all" $mongod $OPTIONS
# super $mongod $OPTIONS
echo $mongod$OPTIONS
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/mongod
}

stop()
{
echo -n $"Stopping mongod: "
killproc -p "$DBPATH"/mongod.lock -d 300 /export/mongodb/bin/mongod
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/mongod
}

restart () {
stop
start
}

ulimit -n 12000
RETVAL=0

case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload|force-reload)
restart
;;
condrestart)
[ -f /var/lock/subsys/mongod ] && restart || :
;;
status)
status $mongod
RETVAL=$?
;;
*)
echo "Usage: $0 {start|stop|status|restart|reload|force-reload|condrestart}"
RETVAL=1
esac

exit $RETVAL

==========================================
[root@yoon ~]# service mongod start

[root@yoon ~]# service mongod stop

===============================================
设置开机自动启动Mongodb
[root@yoon ~]# chkconfig --add mongod

[root@yoon ~]# chkconfig mongod on

[root@yoon ~]# chkconfig mongod --list
mongod 0:off 1:off 2:on 3:on 4:on 5:on 6:off

Centos7 设置Mongodb开机启动-自定义服务

一.官网下载 mongodb，解压到指定目录

本机mongodb目录为：/usr/context/mongodb/mongodb-3.2.10/

二 .编写配置文件，主要指定数据库文件，日志文件，以及一些启动参数.

(1).在mongodb下新建data文件夹，以及子文件夹db，logs，在logs中新建mongodb.log日志文件，其中db文件夹用来存储数据库文件，logs用来存储日志文件

(2).在mongodb-3.2.10/bin/目录下新建mongodb.conf配置文件，内容如下:

[plain] view plain copy

dbpath=/usr/context/mongodb/data/db/
logpath=/usr/context/mongodb/data/log/mongodb.log
logappend=true
port=27017
fork=true
nohttpinterface=true
auth=true

dbpath:数据库文件路径

logpath:日志文件路径

logappend:是否追加日志

port:端口

fork:是否以后台进程启动

auth:是否启动授权认证

nohttpinterface:是否支持HTTP形式访问

三.编写自定义服务

(1).在/lib/systemd/system/目录下新建mongodb.service文件，内容如下

[java] view plain copy

[Unit]
Description=mongodb
After=network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
ExecStart=/usr/context/mongodb/mongodb-3.2.10/bin/mongod --config /usr/context/mongodb/mongodb-3.2.10/bin/mongodb.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/usr/context/mongodb/mongodb-3.2.10/bin/mongod --shutdown --config /usr/context/mongodb/mongodb-3.2.10/bin/mongodb.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target

(2).设置权限

[java] view plain copy

chmod 754 mongodb.service

(3).启动关闭服务，设置开机启动

[java] view plain copy

#启动服务
systemctl start mongodb.service
#关闭服务
systemctl stop mongodb.service
#开机启动
systemctl enable mongodb.service

*注意:conf和service文件中设置路径，注意需要设置为绝对路径。

Linux下设置MongoDB开机自启动

将MongoDB服务加入随机启动

vi /etc/rc.local

使用vi编辑器打开配置文件，并在其中加入下面一行代码

/usr/local/mongodb/bin/mongod -dbpath=/usr/local/mongodb/data/db --fork --port 27017 --logpath=/usr/local/mongodb/log/work.log --logappend --auth

启动服务

/usr/local/mongodb/bin/mongod -dbpath=/usr/local/mongodb/data/db --fork --port 27017 --logpath=/usr/local/mongodb/log/work.log --logappend --auth

其他：

Mongodb在Linux下安装及配置

我这里选用rehl 6作为其运行载体。

1.下载mongodb的linux版本(注意32位和64位的区别)，下载地址：http://www.mongodb.org/downloads

2.将下载的mongodb安装文件mongodb-linux-i686-1.6.5.tgz放到/usr/local/下

3.解压tar -zxvf mongodb-linux-i686-1.6.5.tgz

重命名mv mongodb-linux-i686-1.6.5.tgz mongodb

4,创建数据库文件目录，默认为/data/db,我把数据库文件目录放在当前文件夹下，mkdir -p data/db,创建日志目录mkdir log

5.启动服务
cd /usr/local/mongodb/bin

./mongod -dbpath=../data/db -logpath=../log/mongodb.log

6，启动客户端shell测试

[root@localhost bin]# ./mongo
MongoDB shell version: 1.6.5
connecting to: test
> db.foo.save({a:1})
> db.foo.find()
{ "_id" : ObjectId("4d292a457e289d5d90dc6f33"), "a" : 1 }

7.将mongoDB服务加入随机启动

vi /etc/rc.local

使用vi编辑器打开配置文件，并在其中加入下面一行代码

/usr/local/mongodb/bin/mongod -dbpath=/usr/local/mongodb/data/db --port 27017

-logpath=/usr/local/mongodb/log --logappend

8.连接mongoDB客户端，出现如下信息则启动成功
./mongodbbin/mongo
MongoDB shell version: 1.6.5
connecting to: test
>

9，脚本启动关闭mongodb

## start-mongod.sh

MONGODIR = /usr/local/mongodb
MONGOD = $MONGODIR /bin/mongod
MONGO = $MONGODIR /bin/mongo
DBDIR = $MONGODIR /data/db
LOGPATH = $MONGODIR/log /mongodb.log

# mongod will print its pid, so store it in out.tmp, then
# print it using awk to mongod.pid
$MONGOD --dbpath $DBDIR --fork --logpath $LOGPATH --logappend > out.tmp
awk 'NR == 2 { print $3 }' < out.tmp > mongod.pid

sleep 3
$MONGO < onstart.js

## in onstart.js

use admin;
db.runCommand ( "logRotate" ) ;

linux开机启动mongodb

方式一（不推荐）

ubuntu编辑/etc/rc.local

/home/wyt/bin/mongodb-linux-x86_64-ubuntu1404-3.2.8/bin/mongod --dbpath=/home/wyt/bin/mongodb/data --logpath=/home/wyt/bin/mongodb/logs --logappend --port=27017 --fork

方式二（不推荐）

/home/wyt/bin/mongodb-linux-x86_64-ubuntu1404-3.2.8/bin/mongod --config /home/wyt/bin/mongodb.conf

配置文件内容：

# 指定数据库路径

dbpath =/home/wyt/bin/mongodb/data

# 指定服务端口号，默认端口27017

port =27017

#设置每个数据库将被保存在一个单独的目录

directoryperdb = true

# 启用验证（ 注意，后面要改成true）

auth = false

#以守护进程的方式运行MongoDB，创建服务器进程

fork = true

#提供http接口

httpinterface = true

# 指定MongoDB日志文件，注意是指定文件不是目录

logpath =/home/wyt/bin/mongodb/logs

# 使用追加的方式写日志

logappend = true

注意上面的data文件夹需要创建，logs是文件不是文件夹，不需要创建logs

方式三（推荐）

配置文件和方式二相同，把mongodb拷贝到/etc/init.d，把mongodb.conf拷贝到合适地方，然后执行

chmod 777 /etc/init.d/mongodb

update-rc.d mongodb defaults

update-rc.d -f mongodb remove

附件：

/etc/init.d/mongodb脚本如下

 
       #!/bin/sh 
      
       ### BEGIN INIT INFO 
      
       # Provides:     mongodb 
      
       # Required-Start: 
      
       # Required-Stop: 
      
       # Default-Start:        2 3 4 5 
      
       # Default-Stop:         0 1 6 
      
       # Short-Description: mongodb 
      
       # Description: mongo db server 
      
       ### END INIT INFO 
      
       EXE_FILE= 
       /home/wyt/bin/mongodb-linux-x86_64-ubuntu1404-3 
       .2.9 
       /bin/mongod 
      
       CONFIG_FILE= 
       /home/wyt/bin/mongodb 
       .conf 
      
       .  
       /lib/lsb/init-functions 
      
       MONGOPID=` 
       ps 
       -ef|  
       grep 
       mongod|  
       grep 
       - 
       v 
       grep 
       | 
       awk 
       '{print $2}' 
       ` 
      
       test 
        -x $EXE_FILE ||  
       exit 
        0 
      
       case 
        "$1" 
       in 
      
       start) 
      
       ulimit 
       -n 3000 
      
       log_begin_msg 
       "Starting MongoDB server" 
      
       $EXE_FILE --config $CONFIG_FILE 
      
       log_end_msg 0 
      
       ;; 
      
       stop) 
      
       log_begin_msg 
       "Stopping MongoDB server" 
      
       if 
       [ ! -z  
       "$MONGOPID" 
       ];  
       then 
      
       kill 
       -15 $MONGOPID 
      
       fi 
      
       log_end_msg 0 
      
       ;; 
      
       status) 
      
       ps 
       -aux|  
       grep 
       mongod 
      
       ;; 
      
       *) 
      
       log_success_msg 
       "Usage: /etc/init.d/mongodb {start|stop|status}" 
      
       exit 
       1 
      
       esac 
      
       exit 
        0

Mongodb开启与关闭

Mongodb的开启

默认启动：

$ ./mongodb

默认数据保存路径：/data/db/

默认端口：27017

修改默认路径：

--dbpath

$ ./mongdb --dbpath /mongodb/

把数据存储位置指向一个自己的目录/mongodb/

修改默认端口：

--port

$ ./mongdb --port 20111

把服务端口修改为20111，这个一方面是为了安全，使用默认端口容易被一些恶意的人发现做手脚

启动后台服务:

--fork

在后台开启Mongdb服务

在使用这个方式启动的时候要注意两点：

1、该功能只在1.1之后的版本才可以使用。

2、另外通过这个方式在后台启动，如果在启动的时候像--dbpath 那样使用 --logpath 输出日志时候日志输出目录也要自己创建。

如：

$ ./mongod --fork --logpath /var/log/mongodb.log --logappend

解析最后--logappend,以追加的方式创建日志防止把之前的日志删除了

Mongodb的关闭:

前台运行:

如果没有使用--fork，直接可以前台退出终端关闭。通过这种方式，Mongodb将会自己做清理退出，把没有写好的数据写完成，并最终关闭数据文件。要注意的是这个过程会持续到所有操作都完成。

后台运行:

如果使用--fork在后台运行mongdb服务，那么就要通过向服务器发送shutdownServer()消息来关闭。

1、普通命令：

$ ./mongod

> use admin

> db.shutdownServer()

要注意的是，这个命令只允许在本地，或是一个经过认证的客户端。

2、如果这是一个主从式的复制集群，在1.9.1版本后将按下面的步骤来关闭

检查从Mongodb的数据更新时间
如果所有的从Mongodb和主的时间差都超过10，这个时候不会关闭mongodb（在这种情况下面，我们可以通过配置timeoutSecs的方式来让从Mongodb完成数据的更新）
如果其中有一个从Mongodb与主服务时间差在10秒内，那么主服务器将会关闭，并且等待从Mongodb更新完成并关闭。

3、如果没有up-to-date 从Mongodb且你想强制关闭服务，可以通过添加force:true;命令如下：

> db.adminCommand({shutdown : 1, force : true})

> //or

> db.shutdownServer({force : true})

4、指定特定超时时间的关闭服务器，命令同上，另外加上一个timeoutsec:参数

> db.adminCommand(shutdown : 1, force : true, timeoutsec : 5)

> //or

> db.shutdownServer({force : true, timeoutsec : 5})

Mongodb开机启动

在/etc/rc.local文件末尾添加下面的代码

#add mongodb service

rm -rf /data/mongodb_data/* && /usr/local/mongodb/bin/mongod --dbpath=/data/mongdb_data/ --logpath=/data/mongdb_log/mongodb.log --logappend &

mongoDB 启动与停止

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。它以高性能、易部署、易使用，存储数据非常方便等优点被广泛使用。其安装配置相当简单，有如轻量级的mysql，但功能丝毫不差。本文主要描述mongoDB的启动与停止。

一、准备环境

1、当前环境
# more /etc/redhat-release 
CentOS release 6.7 (Final)

2、安装mongod
# which mongod
/var/lib/mongodb/bin/mongod

参考：
Linux下快速安装MongoDB
Windows平台下安装MongoDB

3、创建数据目录
# mkdir -pv /data/mongodata/{rs1,rs2,rs3}
# mkdir -pv /var/lib/mongodb/conf

二、启动mongodb

1、基于命令行方式启动mongodb
# mongod --dbpath=/data/mongodata/rs1 --logpath=/data/mongodata/rs1/rs1.log &

缺省端口为
[root@node3 rs1]# netstat -nltp|grep mongod
tcp        0      0 0.0.0.0:27017               0.0.0.0:*                   LISTEN      5062/mongod 

2、基于配置文件的命令行启动
vi /var/lib/mongodb/conf/rs2.conf

port = 27000
dbpath = /data/mongodata/rs2
logpath = /data/mongodata/rs2/rs2.log
smallfiles = true
fork = true
pidfilepath = /var/run/mongo.pid

# mongod --config /var/lib/mongodb/conf/rs2.conf &

### Author : Leshami
### Blog   : http://blog.youkuaiyun.com/leshami

# netstat -nltp|grep 27000
tcp        0      0 0.0.0.0:27000               0.0.0.0:*                   LISTEN      5356/mongod    

3、以守护进程方式启动mongodb
# mongod --dbpath=/data/mongodata/rs3 --logpath=/data/mongodata/rs1/rs3.log --fork --port 28000

# netstat -nltp|grep mongod
tcp        0      0 0.0.0.0:28000               0.0.0.0:*                   LISTEN      5465/mongod         
tcp        0      0 0.0.0.0:27017               0.0.0.0:*                   LISTEN      5435/mongod         
tcp        0      0 0.0.0.0:27000               0.0.0.0:*                   LISTEN      5448/mongod

4、使用系统服务的方式启动mogodb
启动脚本

# vi /etc/init.d/mongod

#!/bin/sh  
# chkconfig: 2345 93 18  

#MogoDB home directory  
MONGODB_HOME=/var/lib/mongodb

#mongodb command  
MONGODB_BIN=$MONGODB_HOME/bin/mongod

#mongodb config file
MONGODB_CONF=$MONGODB_HOME/conf/mongodb.conf

#mongodb PID
MONGODB_PID=/var/run/mongo.pid

#set open file limit
SYSTEM_MAXFD=65535

MONGODB_NAME="mongodb"
. /etc/rc.d/init.d/functions

if [ ! -f $MONGODB_BIN ]
then
        echo "$MONGODB_NAME startup: $MONGODB_BIN not exists! "  
        exit
fi

start(){
     ulimit -HSn $SYSTEM_MAXFD
     $MONGODB_BIN --config="$MONGODB_CONF"  --fork ##added @20160901
     ret=$?
     if [ $ret -eq 0 ]; then
        action $"Starting $MONGODB_NAME: " /bin/true
     else
        action $"Starting $MONGODB_NAME: " /bin/false
     fi

}

stop(){
        PID=$(ps aux |grep "$MONGODB_NAME" |grep "$MONGODB_CONF" |grep -v grep |wc -l) 
        if [[ $PID -eq 0  ]];then
        action $"Stopping $MONGODB_NAME: " /bin/false
        exit
        fi
        kill -HUP `cat $MONGODB_PID`
        ret=$?
        if [ $ret -eq 0 ]; then
                action $"Stopping $MONGODB_NAME: " /bin/true
                rm -f $MONGODB_PID
        else   
                action $"Stopping $MONGODB_NAME: " /bin/false
        fi

}

restart() {

        stop
        sleep 2
        start
}

case "$1" in
        start)
                start
                ;;
        stop)
                stop
                ;;
        status)
        status $prog
                ;;
        restart)
                restart
                ;;
        *)
                echo $"Usage: $0 {start|stop|status|restart}"
esac

# chmod u+x /etc/init.d/mongod

# service mongod start
about to fork child process, waiting until server is ready for connections.
forked process: 5543
child process started successfully, parent exiting
Starting mongodb:                                          [  OK  ]

三、停止mongoDB

1、向mongod进程发送信号
###SIGINT信号

# ps -ef|grep mongod|grep rs1
root       5435   4914  1 19:13 pts/2    00:00:14 mongod --dbpath=/data/mongodata/rs1 --logpath=/data/mongodata/rs1/rs1.log

# kill -2 5435

2016-08-30T17:02:00.528+0800 I CONTROL[signalProcessingThread] got signal 2(Interrupt), will terminate after current cmd ends
2016-08-30T17:02:00.530+0800 I REPL     [signalProcessingThread] Stopping replication applier threads
2016-08-30T17:02:00.554+0800 I STORAGE  [conn1253] got request after shutdown()
2016-08-30T17:02:00.774+0800 I CONTROL  [signalProcessingThread] now exiting
2016-08-30T17:02:00.774+0800 I NETWORK  [signalProcessingThread] shutdown: going to close listening sockets...
2016-08-30T17:02:00.774+0800 I NETWORK  [signalProcessingThread] closing listening socket: 6
2016-08-30T17:02:00.775+0800 I NETWORK  [signalProcessingThread] closing listening socket: 7
2016-08-30T17:02:00.775+0800 I NETWORK  [signalProcessingThread] removing socket file: /tmp/mongodb-27017.sock
2016-08-30T17:02:00.775+0800 I NETWORK  [signalProcessingThread] shutdown: going to flush diaglog...
2016-08-30T17:02:00.775+0800 I NETWORK  [signalProcessingThread] shutdown: going to close sockets...
2016-08-30T17:02:00.775+0800 I STORAGE  [signalProcessingThread] shutdown: waiting for fs preallocator...
2016-08-30T17:02:00.775+0800 I STORAGE  [signalProcessingThread] shutdown: final commit...
2016-08-30T17:02:00.775+0800 I JOURNAL  [signalProcessingThread] journalCleanup...
2016-08-30T17:02:00.775+0800 I JOURNAL  [signalProcessingThread] removeJournalFiles
2016-08-30T17:02:00.777+0800 I NETWORK  [conn1254] end connection 192.168.1.247:58349 (0 connections now open)
2016-08-30T17:02:00.779+0800 I JOURNAL  [signalProcessingThread] Terminating durability thread ...
2016-08-30T17:02:00.881+0800 I JOURNAL  [journal writer] Journal writer thread stopped
2016-08-30T17:02:00.882+0800 I JOURNAL  [durability] Durability thread stopped
2016-08-30T17:02:00.882+0800 I STORAGE  [signalProcessingThread] shutdown: closing all files...
2016-08-30T17:02:00.884+0800 I STORAGE  [signalProcessingThread] closeAllFiles() finished
2016-08-30T17:02:00.884+0800 I STORAGE  [signalProcessingThread] shutdown: removing fs lock...
2016-08-30T17:02:00.885+0800 I CONTROL  [signalProcessingThread] dbexit:  rc: 0

###SIGTERM信号
# ps -ef|grep mongod|grep rs3

# ps -ef|grep mongod|grep rs3
root  5465 1 1 19:14 ? 00:00:13 mongod --dbpath=/data/mongodata/rs3 --logpath=/data/mongodata/rs1/rs3.log --fork --port 28000
# kill -4 5465

信号     产生方式 
sigint  通过ctrl+c将会对当进程发送此信号 
sigterm kill命令不加参数就是发送这个信号  

对进程的影响
  sigint 信号被当前进程树接收到，也就是说，不仅当前进程会收到信号，它的子进程也会收到
  sigterm只有当前进程收到信号，子进程不会收到。如果当前进程被kill了，那么它的子进程的父进程将会是init，也就是pid为1的进程

上述信号在发出后
        不再接受新的连接请求
        等待现有的连接处理完毕
        关闭所有打开的连接
        将内存的数据写出到磁盘
        安全停止

2、使用系统服务脚本方式停止mongod
        # ps -ef|grep mongod
        root   5675  1  3 19:33 ?   00:00:00 /var/lib/mongodb/bin/mongod --config=/var/lib/mongodb/conf/rs2.conf
        root       5689   4950  0 19:33 pts/3    00:00:00 grep mongod
        [root@node3 conf]# 
        [root@node3 conf]# service mongod stop
        Stopping mongodb:                                          [  OK  ]

3、db.shutdownServer()方式
        # mongo localhost:27000
        > use admin
        > db.shutdownServer()

4、使用命令行方式关闭(补充@20160901)
        # mongod -f /etc/mongo-m.conf  --shutdown

5、强制关闭mongod
        # kill -9 5675
        缺点：
        数据库直接关闭
        数据丢失
        数据文件容易损坏(需要进行修复)

MongoDB(4):多种方式关闭服务命令

http://blog.youkuaiyun.com/czw698/article/details/8791153

MongoDB 提供几种关闭服务的命令，具体为以下：

一使用 Crtl+C 关闭

[mongo@redhatB data]$ mongod --dbpath=/database/mongodb/data/ --logpath=/var/applog/mongo_log/mongo.log --logappend --port=27017 --journal > start_mongo.log 2>&1
光标：键入 Crtl+C 关闭

备注：如果以前台方式启动 MongoDB 服务，使用“Crtl+C” 服务会关闭，这种关闭方式会等待
当前进行中的的操作完成，所以依然是干净的关闭方式。

二使用数据库命令关闭
--2.1 开启服务

[mongo@redhatB data]$ mongod -f /database/mongodb/data/mongodb_27017.conf
forked process: 18155
all output going to: /var/applog/mongo_log/mongo.log
child process started successfully, parent exiting

--2.2 登陆数据库

[mongo@redhatB data]$ mongo
MongoDB shell version: 2.2.1
connecting to: test

--2.3 关闭 MongoDB 服务

> use admin;
switched to db admin

> db.shutdownServer();
Wed Nov 14 06:07:33 DBClientCursor::init call() failed
Wed Nov 14 06:07:33 query failed : admin.$cmd { shutdown: 1.0 } to: 127.0.0.1:27017
server should be down...
Wed Nov 14 06:07:33 trying reconnect to 127.0.0.1:27017
Wed Nov 14 06:07:33 reconnect 127.0.0.1:27017 failed couldnt connect to server 127.0.0.1:27017

三使用 mongod 命令关闭

[mongo@redhatB data]$ mongod --shutdown --dbpath /database/mongodb/data/
killing process with pid: 17747

备注：mongod 命令的 shutdown 选项能干净的关闭 MongoDB 服务。

四使用 kill 命令
--4.1 查看 mongo 相关进程

[mongo@redhatB data]$ ps -ef | grep mongo
root     17573 14213 0 05:10 pts/1    00:00:00 su - mongo
mongo    17574 17573 0 05:10 pts/1    00:00:00 -bash
mongo    18288     1 0 06:12 ?        00:00:00 mongod -f /database/mongodb/data/mongodb_27017.conf
mongo    18300 17574 6 06:13 pts/1    00:00:00 ps -ef
mongo    18301 17574 0 06:13 pts/1    00:00:00 grep mongo

--4.2 kill mongo 服务进程

[mongo@redhatB data]$ kill 18288

[mongo@redhatB data]$ ps -ef | grep pmon
mongo 18304 17574 0 06:13 pts/1 00:00:00 grep pmon

备注：可以使用操作系统的 kill 命令，给 mongod 进程发送 SIGINT 或 SIGTERM 信号，
            即 "kill -2 PID," 或者 “kill -15 PID“。

          建议不要使用 ”kill -9 pid“，因为如果 MongoDB 运行在没开启日志（--journal）的情况下，
            可能会造成数据损失。

五参考
http://www.mongodb.org/display/DOCS/Starting+and+Stopping+Mongo
http://docs.mongodb.org/manual/reference/mongod/
http://www.cnblogs.com/taobataoma/archive/2007/08/30/875743.html