Mongodb3.2.8全面开战之实战篇

向右看齐 2022-07-16 13:50 150阅读 0赞

# Mongodb3.2.8全面开战之实战篇 #

作者：[Chris\_111X][Chris_111X]

# 简介 #

本博文是本人经过一个月的学习和参考网上的资料进行实践操作后的一个成果，希望帮助测试、开发人员或者数据库管理员，能够迅速搭建mongodb的分片和副本集的环境，实现mongodb高并发高可用的架构。本文主要注重如果搭建mongodb的过程，并没有太多的理论去讲解mongodb的功能原理，如错误，请留言指出。

# 1.安装准备 #

系统环境：Centos7.2-redhat release7.2

MongoDB安装包：mongodb-linux-x86\_64-rhel70-3.2.8.tgz

下载地址：https://www.mongodb.com/download-center\#community

![Center][]

下载MongoDB安装，选择Community Server选项，选中RHEL 7 Linux 64-bit版本下载。

# 2.解压MongoDB安装包 #

![Center 1][]

上传 mysql 安装包到服务器后，需要对文件进行解压。

# 3.将MongoDB文件夹移动到指定目录下    #

![Center 2][]

输入mvmongodb-linux-x86\_64-rhel70-3.2.8 /usr/local将mongoDB的文件夹移动到usr/local目录下。

\#mv mongodb-linux-x86\_64-rhel70-3.2.8 /usr/local

![Center 3][]

输入mv mongodb-linux-x86\_64-rhel70-3.2.8mongodb-rh7，修改MongoDB的目录名称。

\#mv mongodb-linux-x86\_64-rhel70-3.2.8 mongodb-rh7

# 4.创建MongoDB存放数据库文件和日志的目录 #

MongoDB的数据存储在data目录的db目录下，但是这个目录在安装过程不会自动创建，所以你需要手动创建data目录，并在data目录中创建db目录。

以下实例中我们将data目录创建于根目录下(/)。

注意：/data/db是 MongoDB 默认的启动的数据库路径(--dbpath)。

![Center 4][]

进入到mongodb-rh7目录下输入mkdir –p data命令创建一个data的文件夹。

\#mkdir -p data

![Center 5][]

在mongodb-rh7目录下输入mkdir –p log命令创建一个log的文件夹。

# 5.YAML格式mongod.conf（Core Options） #

官方说明：

Changed in version 2.6: MongoDB 2.6introduces a YAML-based configuration file format. The 2.4 configuration fileformat remains for backward compatibility.

NOTE：

YAML does not support tab characters forindention: use spaces instead.

![Center 6][]

更详细的配置请参考官方配置：https://docs.mongodb.com/manual/reference/configuration-options/\#core-options

![Center 7][]

我们采用YMAL格式配置mognod.conf文件。首先进入到mongodb的bin目录下，输入命令vi mongod.conf创建配置文件。输入配置信息后，进行保存，

输入:号之后，需要空格隔开

systemLog:

destination:file  \#以文件形式输出日志文件，输入file之前，需要空格

path: /usr/local/mongodb-rh7/log/mongodb.log \#表示存储日志文件

logAppend: true    \#日志是追加模式，false是覆盖模式

storage:

dbPath:/usr/local/mongodb-rh7/data    \#表示存储mongodb数据库文件目录

processManagement:

fork: true    \#作为后台服务运行

\#net:

\#         bindIP: 127.0.0.1

\#         port: 27017

\#security:

\#         authorization:enabled

以上是mongod.conf文件配置

![Center 8][]

保存成功后，在bin目录下可看到新建的mongod.conf文件

# 6.启动MongoDB服务    #

![Center 9][]

进入到bin目录下，输入命令./mongod -f mongod.conf启动mongod服务

\#./mongod -fmongod.conf      \#./mongod –f(指定配置文件参数) 配置文件名称

![Center 10][]

新打开一个窗口，连接服务器，查看启动mongodb的服务和端口，说明已经启动成功.

# 7.停止MongoDB服务 #

![Center 11][]

新建一个窗口，连接服务器，进入到bin目录下，输入命令./mongod -f mongod.conf –shutdown停止mongod服务

\#./mongod -fmongod.conf –shutdown

# 8.客户端连接MongoDB #

![Center 12][]

在bin目录下，输入命令./mongo localhost:27017登录mongodb，登录成功后，查看数据库。

\# ./mongo localhost:27017    \#./mongo 主机名:端口号

![Center 13][]

创建一个数据，并在该数据下新建一个collection，在该collections下插入一条数据，插入成功，并且可以查询出来。

# 9.设置systemd命令自定义开机系统服务 #

为了方便启动mongodb服务器，我们进行配置成服务的方式进行启动mongodb，使用systemctl命令可以控制mongodb服务的启动和停止操作。

## 9.1.配置mongodb.service文件 ##

![Center 14][]

输入命令cd /usr/lib/systemd/system进入到目录下，输入vimongodb.service创建文件

![Center 15][]

mongodb.service文件内容如下：

\[Unit\]

Description=mongodb service daemon

After=network.target

\[Service\]

Type=forking

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

ExecStop=/usr/local/mongodb-rh7/bin/mongod

\--shutdown -f /usr/local/mongodb-rh7/bin/mongod.conf

PrivateTmp=true

\[Install\]

WantedBy=multi-user.target

![Center 16][]

保存mongodb.service文件后，需要输入命令进行重新加载.

\#systemctl daemon-reload

## 9.2.Systemd命令操作mongodb服务 ##

![Center 17][]

\#systemctl start mongodb    \#启动mongodb服务

\#systemctl status mongodb   \#查看mongodb服务状态

\#systemctl Stop mongodb    \#停止mongodb服务

\#netstat -ntlp                          \#查看端口

## 9.3.设置启动/停止开机系统服务 ##

![Center 18][]

启动开机服务之前，必须要先启动mongodb服务。确认mongodb服务是否开机启动，需要输入systemctl is-enabled mongodb.service的值是否enabled.

\#systemctl start mongodb                  \#启动mongodb服务

\#systemctl enable mongodb.service          \#设置开机启动mongodb服务

\#systemctl is-enabled mongodb.service       \#查看mongodb服务是否设置开机启动

\#systemctl disable mongodb.service         \#停止mongodb服务开机启动

# 10.Firewall下设置MongoDB端口 #

![Center 19][]

在服务器启动firewalld的情况下，如果没有将mongodb的端口添加到firewalld，可能无法连接mongodb数据库，添加mongodb端口命令如下：

\#firewall-cmd --permanent--add-port=27017/tcp        \#添加mongodb的端口号

\# firewall-cmd --reload                             \#重载firewalld，否则不生效

\# firewall-cmd --list-all                             \#再次查看firewalld中添加的端口

# 11.创建超级管理员和普通用户 #

超级管理员：可管理所有的数据库。

普通用户：某个数据库的管理员。

开启数据库登录认证之前必须要创建一个超级数据库管理员了，否则无法对数据库进行操作。

如何创建用户和数据库授权，请参考Mongodb官方文档。参考地址：

[https://docs.mongodb.com/manual/core/security-users/][https_docs.mongodb.com_manual_core_security-users]

[https://docs.mongodb.com/manual/tutorial/create-users/][https_docs.mongodb.com_manual_tutorial_create-users]

## 11.1.数据库角色介绍 ##

MongoDB基本的角色

1.数据库用户角色Database UserRoles：read、readWrite;

2.数据库管理角色DatabaseAdministrator Role：dbAdmin、dbOwner、userAdmin；

3.集群管理角色 ClusterAdministartor Roles：clusterAdmin、clusterManager、clusterMonitor、hostManager；

4.备份恢复角色Backup andRestoration Roles：backup、restore；

5.所有数据库角色All-DatabaseRoles：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase

6.超级用户角色Superuser Roels：root

//这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）

其中MongoDB默认是没有开启用户认证的，也就是说游客也拥有超级管理员的权限。userAdminAnyDatabase：有分配角色和用户的权限，但没有查写的权限

具体角色：

Read：允许用户读取指定数据库

readWrite：允许用户读写指定数据库

dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile

userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户

clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。

readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限

readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限

userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限

dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。

root：只在admin数据库中可用。超级账号，超级权限

参考文档地址：

[https://docs.mongodb.com/manual/reference/built-in-roles/\#all-database-roles][https_docs.mongodb.com_manual_reference_built-in-roles_all-database-roles]

## 11.2.创建管理员用户 ##

### 11.2.1.创建超级管理员角色用户 ###

![Center 20][]

在创建数据库超级管理员用户，必须进入到admin数据库下才能创建超级管理员用户。

\#mongo         \#进入mongodb/bin目录下输入mongo命令连接数据库

\#use admin      \#进入到admin数据库中

\#db \#显示处于当前数据库

\#db.system.users.find()  \#查看user集合下的数据

\#db.createUser(\{user:'root',pwd:'root123456',roles:\[\{role:root,db:'admin'\}\]\})

语法说明：

db.createUser(

\{user:’用户名’,

pwd:’密码’,

roles:\[

\{role:root,db:'admin'\}\] \}

)

![Center 21][]

创建成功后，会显示用户信息

![Center 22][]

输入\#db.system.users.find()查看users集合下的所有记录。

#### 11.2.1.1.配置用户认证 ####

创建超级管理员后，使用管理员账户登录前，必须要先在配置mongod.conf文件，启用数据库认证。

![Center 23][]

进入到mongodb的bin目录下，输入vi mongod.conf命令编辑文件，输入命令。命令如下：

\#security:

\#       authorization: enabled

![Center 24][]

保存文件成功后需要输入systemctl restart mongodb命令重启mongodb服务。

#### 11.2.1.2.验证超级管理员权限 ####

![Center 25][]

在mongodb的bin目录下输入：

\#./mongo localhost:27017      \#登录远程数据库地址和端口

![Center 26][]

选择admin数据库进行登录

\#use admin                 \#进入到amdin数据库下

\#db.auth(‘root’,’root123456’)   \#.db.auth(用户名，密码)

登录成功后，显示返回值1.

![Center 27][]

登录成功后，可对任意数据数据库进行操作，例如，插入数据或创建数据库。

### 11.2.2.创建管理所有数据库角色用户 ###

![Center 28][]

userAdminAnyDatabase 角色，用来管理所有数据库用户，可以通过这个角色来创建、删除用户。使用该用户进行登录后，可选择指定的数据为该数据库创建相应的用户。

\# use admin

\#db.createUser(\{user:'sa',pwd:'sa123456',roles:\[\{role:'userAdminAnyDatabase',db:'admin'\}\]\})

### 11.2.3.创建普通数据库管理员角色用户 ###

![Center 29][]

\#use testdb            \#进入testdb数据

\#db.createUser(\{user:'sa',pwd:'sa123456',roles:\['userAdmin'\]\})  创建属于testdb的管理员，该管理员

\#该管理员只能对指定的数据库进行管理用户。

### 11.2.4.创建一个用户管理多个数据库 ###

use reporting      \#进入到目标数据库

db.createUser(      \#创建方法

user: "reportsUser",       \#用户名

pwd: "12345678",         \#密码

roles: \[                   \#角色

\{ role: "read", db: "reporting" \},           \#只读，数据名称

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

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

\{ role: "readWrite", db: "accounts" \}        \#读写操作，数据名称

)

请注意：在那个数据库下创建用户，就需要在那个数据库下进行认证。例如在admin数据库下创建用户，但创建时，db为testdb的时候，

不能在testdb数据库下认证，只能在admin数据库下认证登录。

## 11.3.配置mongod.conf文件身份认证 ##

![Center 30][]

进入到mongodb的bin目录下，输入vi mongod.conf命令编辑文件，输入命令。命令如下：

\#security:

\#       authorization: enabled    \#enabled启用，disabled禁用或者输入\#注释掉。

![Center 31][]

保存文件成功后需要输入systemctl restart mongodb命令重启mongodb服务。

## 11.4.客户端身份登录 ##

![Center 32][]

在mongodb的bin目录下输入：

\#./mongo localhost:27017      \#登录远程数据库地址和端口

\#use admin                 \#进入到amdin数据库下

\#db.auth(‘root’,’root123456’)   \#.db.auth(用户名，密码)

登录成功后，显示返回值1.

另外一种方式登录：

![Center 33][]

远程登录默认的数据库。

\# ./mongo --host localhost --port 27017 -usa -p sa123456 --authenticationDatabase admin

\# ./mongo --host 数据库地址--port 端口-u 用户名-p 密码--authenticationDatabase默认的数据库。

![Center 34][]

除了可以设置以上的参数登录，在命令行中输入./mongo –h查看帮助

，参考帮助文档的语法来自定义选不同的字段来进行登录。

## 11.5.删除用户 ##

![Center 35][]

进入到admin数据下，输入删除语句

\#db.system.users.remove(\{user:'root'\})

\#remove(\{查询条件\})

## 11.6.更改用户密码 ##

![Center 36][]

使用管理员账户登录后，然后在进入到修改用户密码的所属数据，进入后，输入命令进行密码修改。

\#db.changeUserPassword("sa","sa0123456")  \#db.changeUserPassword(用户名，新密码)

![Center 37][]

使用密码进行登录。

![Center 38][]

登录成功后可对集合进行查询。

## 11.7.获取用户权限 ##

![Center 39][]

输入db.getUser(‘sa’)命令可获取该用户相应的信息

\#db.getUser(‘sa’)             \#db.getUser(用户名)

# 12.数据库副本集 #

## 12.1.前期准备 ##

需要准备3台mongod服务器

Shard01：10.190.130.27:27017

Shard02：10.190.130.28:27017

Shard03：10.190.130.79:27017

![Center 40][]

副本集架构

### 12.1.1.Mongod.conf文件配置 ###

![Center 41][]

在bin目录下vi mongod.conf文件输入以下内容：

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

storage:

dbPath: /usr/local/mongodb-rh7/data

processManagement:

fork: true

replication:

oplogSizeMB: 5

replSetName: re01

注意：3台mogod服务器的mongod.conf文件配置内容是一样的。

## 12.2.Mongodb副本集配置过程 ##

### 12.2.1.连接mongodb服务器 ###

![Center 42][]

启动mognodb数据库服务后，选择任意一台mongodb服务器，使用mongo进行登录。

\#/mongo 10.190.130..27:27017

### 12.2.2.定义副本集配置变量 ###

![Center 43][]

定义副本集变量

config=\{\_id:"re01",members:\[\{\_id:0,host:"10.190.130.27:27017"\},\{\_id:1,host:"10.190.130.28:27017"\},\{\_id:2,host:"10.190.130.79:27017"\}\]\}

语法结构：

定义副本集变量

config=\{\_id:"副本集名称",members:\[\{\_id:0,host:"数据库地址:端口号"\},\{\_id:1,"数据库地址:端口号""\},\{\_id:2,host:""数据库地址:端口号""\},,,以此类推\]\}

### 12.2.3.初始化副本集 ###

![Center 44][]

初始化副本集rs.initiate(config)

语法结构：

rs.initiate(定义的副本集变量名称)

### 12.2.4.检查副本集状态 ###

![Center 45][]

输入rs.status()查看副本集状态。

health：1   //1表明状态是正常，0表明异常

state:1    // 1表明是primary，2表明是slave，即做备份的机器

查看更多状态信息，请参考官方文档：

[https://docs.mongodb.com/manual/reference/replica-states/][https_docs.mongodb.com_manual_reference_replica-states]

## 12.3.测试副本集配置 ##

#### 12.3.1.主节点创建测试数据 ####

![Center 46][]

使用mongo连接primary数据库，插入10W条数据。

语句如下：

\#for(var i=0;i<100000;i++)\{db.userInfo.insert(\{"userName":"user"+i,"depart":"towngas","userNo":"no."+i\})\}

### 12.3.2.从节点查看同步数据 ###

![Center 47][]

登录从节点（Secondary Node）数据库后，必须输入rs.slaveOk()后，才能执行查询操作。

输入命令如下：

\#./mong 10.190.130.130.28:27017

\#use copp

\#rs.slaveOk()

\#db.userInfo.count()

\#db.userInfo.find()

![Center 48][]

查询第二个从节点（secondary node）的数据库的数据。

输入命令如下：

\#./mong 10.190.130.130.79:27017

\#use copp

\#rs.slaveOk()

\#db.userInfo.count()

\#db.userInfo.find()

注意：由于主节点插入了10W条数据成后，在从节点上查询同步的数据，不会马上查询到主节点同步的数据，需要等待一定的时间。

### 12.3.3.测试副本集选举主节点 ###

在副本集环境中，停止主节点数据库服务后，副本集会从两个从节点(secondary node)服务中，选举一个节点成为主节点(primary node)，以实现高可用。

#### 12.3.3.1.主节点故障后副本集重新选举主节点 ####

![Center 49][]

将primary的mongodb服务停止后，再查看另外两台服务器的状态。

![Center 50][]

选择任意一台secondary服务器进行查看副本集状态。显示之前的primary服务器已经停止服务health：0表明异常。而且之前的一台secondary服务器的

stateStr已经成为primary。说明副本集内部选举primary已经成功。

#### 12.3.3.2.测试新主节点下数据同步 ####

![Center 51][]

登录新的主节点（primary：10.190.130.79:27017），插入数据成功后，再查看secondary节点同步数据。

![Center 52][]

登录到从节点（secondary：10.190.130.28:27017）下，查看同步数据，已经跟primary数据一致。

#### 12.3.3.3.重新启动故障节点 ####

![Center 53][]

必须先进入到数据库目录下，删除故障节点下数据库文件，然后重新启动之前被停止的主节点

（10.190.130.27:27017），查看状态。显示启动的节点已经成从节点（secondary）。

![Center 54][]

查看该节点的数据，该节点已经完成数据同步，并且查询数据正常。

## 12.4.删除副本集成员 ##

![Center 55][]

连接主节点后，输入rs.remove("10.190.130.27:27017")命令删除从节点后，再输入rs.status()

查看副本集状态，显示删除节点成功，不在显示被删除的从节点信息。

语法结构：

rs.remove(服务器地址和端口号)

从副本集中删除一个节点服务器，更多具体的信息请参考官方文档：

[https://docs.mongodb.com/manual/tutorial/remove-replica-set-member/][https_docs.mongodb.com_manual_tutorial_remove-replica-set-member]

## 12.5.添加副本集成员 ##

![Center 56][]

首先启动要添加到副本集中的节点服务器。该服务器是10.190.130.27:27017

注意：该节点下的配置其它节点的配置是一致的。

![Center 57][]

连接到主节点服务器（primary：10.190.130.79:27017），下输入rs.add("10.190.130.27:27017")后，添加副本节点成功。

![Center 58][]

输入rs.status()查看添加一个副本集成功后的副本集状态。

![Center 59][]

连接新增的副本集服务器，查看数据同步。

## 12.6.强制成员为主节点 ##

希望某一个从节点成为主节点时，可通过最高优先设置和数据库命令这两种方式，将从节点强制转换为主节点。

### 12.6.1.使用数据库命令强制一个从节点成为主节点 ###

副本集成员：

10.190.130.27:27017        ---从节点（将该节点转成主节点）

10.190.130.28:27017        ---从节点

10.190.130.79:27017        ---主节点

![Center 60][]

1.使用mongo连接数据，运行rs.status()确认副本集状态。

![Center 61][]

2.使用mongo连接10.190.130.28:27017服务器，并输入rs.freeze(120)，表示冻结该服务器，在120秒内不会尝试成为主节点。

![Center 62][]

3. 使用mongo连接10.190.130.79:27017主节点服务器，并输入rs.stepDown(120)，在120秒内不会尝试成为主节点。

![Center 63][]![Center 64][]

4. 使用mongo连接10.190.130.27:27017，输入rs.status()查看副本集状态，该节点已经成为副本集的主节点。

注意：在转型期，有一个短暂的窗口里的设置没有主节点。

### 12.6.2.设置最高优先级强制转换成员为主节点 ###

10.190.130.27:27017        ---主节点

10.190.130.28:27017        ---从节点（将该节点强制转为主节点）

10.190.130.79:27017        ---从节点

![Center 65][]![Center 66][]

1.连接主节点服务器，并查看副本集状态。

![Center 67][]

2.连接主节点成功后，输入cfg=rs.conf()命令。

![Center 68][]

3.继续执行以下命令设置节点的优先级。当节点1的值是1，那么节点3的值必须设置0.5，这样节点的优先级才是最高的，

最有从中可以选举出节点1的优先级为最高，所以节点1为主节点，也是就是10.190.130.28:27017服务器。

输入命令：

\#cfg.members\[0\].priority=1

\#cfg.members\[2\].priority=0.5

注意：设置节点优先级的下标是从0开始的。

![Center 69][]

4.rs.reconfig(cfg)执行该命令后回去修改配置文件去配置最高优先级成员为主节点。

再执行rs.status()后，之前的主节点状态变成为从节点状态。显示节点3服务器重新连接成功。

![Center 70][]

5.再次输入rs.status()查看副本集节点，显示10.190.130.28:27017服务器已经成为主节点。

![Center 71][]

6.登录./mongo10.190.130.28:27017，显示服务器的状态为主节点。

更详细的配置信息请参考官方文档：

[https://docs.mongodb.com/manual/tutorial/force-member-to-be-primary/][https_docs.mongodb.com_manual_tutorial_force-member-to-be-primary]

# 13.数据库分片 #

Mongodb分配技术需要最少4台服务区，其中2台为mongod服务器，一台为mongos服务区，另外一太为mongosconfig server服务器。

分片

在Mongodb里面存在另一种集群，就是分片技术,可以满足MongoDB数据量大量增长的需求。当MongoDB存储海量的数据时，一台机器可能不足以存储数据，也可能不足以提供可接受的读写吞吐量。这时，我们就可以通过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。

为什么使用分片

1.        复制所有的写入操作到主节点

2.        延迟的敏感数据会在主节点查询

3.        单个副本集限制在12个节点

4.        当请求量巨大时会出现内存不足。

5.        本地磁盘不足

6.        垂直扩展价格昂贵

![Center 72][]

上图中主要有如下所述三个主要组件：

MongosServer（路由服务器）:

Mongos路由服务器是MongoDB中的一个路由进程，它接受所有的用户请求，并分发到每个分片服务器，让后它将聚合各个分片的服务器的结果，返回给客户端。Mongos本身并不持久化数据，Sharded cluster所有的元数据都会存储到Config Server，而用户的数据则会分散存储到各个shard。Mongos启动后，会从config server加载元数据，开始提供服务，将用户的请求正确路由到对应的Shard。

Configservers（配置服务器）:

Config Server是配置服务器，该服务器存储了集群的配置信息：数据和片的对应关系。路由器将根据数据和分片的关系映射，把数据操作分配到特定的分片上。

ShardServer（片服务器）:

用来保存子集合的数据容器。片服务器可以是单个的mongod服务器，也可以是一个副本集。

## 13.1.分片集群组件 ##

![Center 73][]

Mongodb分片服务器结构（非副本集结构）

服务器列表：

2台Shard数据库服务器：10.190.130.29，10.190.130.30

1台Config库服务器：10.190.130.81

1台Mongos服务器：10.190.130.80

### 13.1.1.Config服务器 ###

Config server存储Sharded cluster的所有元数据，所有的元数据都存储在config数据库，3.2版本后，Config Server可部署为一个独立的复制集，

极大的方便了Sharded cluster的运维管理。

#### 13.1.1.1.配置Config服务器的mongod.conf文件 ####

![Center 74][]

以下是mongd.config文件配置：

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

storage:

dbPath: /usr/local/mongodb-rh7/data/configdb

processManagement:

fork: true

sharding:

clusterRole: configsvr

#### 13.1.1.2.配置Systemd命令操作Config服务 ####

![Center 75][]

以下是mongodb.service文件配置：

\[Unit\]

Description=Mongodbservice daemon

After=network.target

\[Service\]

Type=forking

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

ExecStop=/usr/local/mongodb-rh7/bin/mongod

\--shutdown -f/usr/local/mongodb-rh7/bin/mongod.conf

PrivateTmp=true

\[Install\]

WantedBy=multi-user.target

### 13.1.1.3.启动Config服务器 ###

![Center 76][]

\#systemctl start mongodb          \#启动服务器

\#systemctl status mongodb         \#查看mongodb状态

\#netstat –ntlp                    \#查看mongdb端口，configserver的默认端口是27019

### 13.1.2.Mongos服务器 ###

Mongos作为分片集群（Shardedcluster）的访问入口，所有的请求都由mongos来路由、分发、合并，这些动作对客户端driver透明，即用户连接mongos就像连接mongod一样。

Mongos会根据请求类型及shard key将请求路由到对应的Shard

查询请求

1.查询数据请求不包含shard key，则必须将查询分发到所有的shard，然后合并查询结果返回给客户端

2.查询数据请求包含shard key，则直接根据shardkey计算出需要查询的chunk，向对应的shard发送查询请求

写请求

插入数据操作必须包含shard key，mongos根据shard key算出文档应该存储到哪个chunk，然后将写请求发送到chunk所在的shard。

更新/删除请求

更新、删除请求的查询条件必须包含shard key或者\_id，如果是包含shard key，则直接路由到指定的chunk，如果只包含\_id，则需将请求发送至所有的shard。

其他命令请求

除增删改查外的其他命令请求处理方式都不尽相同，有各自的处理逻辑，比如listDatabases命令，会向每个Shard及Config Server转发listDatabases请求，然后将结果进行合并。

#### 13.1.2.1.配置mongos服务器的mongos.conf文件 ####

![Center 77][]

以下是mongos服务器的mongos.conf文件：

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongos.log

logAppend: true

\#storage:

\#        dbPath: /usr/local/mongodb-rh7/data

\#        journal:

\#        enabled:true

processManagement:

fork: true

net:

\#        bindIP: 127.0.0.1

port: 2080

\#security:

\#        authorization: enabled

sharding:

configDB:10.190.130.81:27019     \#需要指定config服务器的地址和端口号

保存mongos.conf文件

想了解更多的信息，请参考官方文档：

[https://docs.mongodb.com/manual/reference/configuration-options/\#configuration-file][https_docs.mongodb.com_manual_reference_configuration-options_configuration-file]

#### 13.1.2.2.配置Systemd命令操作Mongos服务 ####

![Center 78][]

以下是mongos服务器下的mongos.service文件：

\[Unit\]

Description=Mongodbservice daemon

After=network.target

\[Service\]

Type=forking

ExecStart=/usr/local/mongodb-rh7/bin/mongos-f /usr/local/mongodb-rh7/bin/mongos.conf

PrivateTmp=true

\[Install\]

WantedBy=multi-user.target

![Center 79][]

保存的文件名为mongos.service

#### 13.1.2.3.启动mongos服务器 ####

![Center 80][]

启动mongos服务并查看服务状态，确保mongos启动成功，没有出现错误。

\#systemctl start mongos

\# systemctl status mongos

\#netstat –ntlp

### 13.1.3.Shared服务器 ###

Shard Mongodb是分片数据库服务器，是用来存储分片的数据，可以存储一个chunk或多个chunks.

### 13.1.3.1.配置mongod服务器的mongod.conf文件 ###

在cd /usr/local/mongodb-rh7/bin目录下创建一个mongod.conf文件：

![Center 81][]

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

storage:

dbPath: /usr/local/mongodb-rh7/data

processManagement:

fork: true

#### 13.1.3.2.配置Systemd命令操作mongod服务 ####

![Center 82][]

在cd /usr/lib/systemd/system目录下创建一个mongodb.service文件：

\[Unit\]

Description=Mongodbservice daemon

After=network.target

\[Service\]

Type=forking

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

ExecStop=/usr/local/mongodb-rh7/bin/mongod--shutdown -f /usr/local/mongodb-rh7/bin/mongod.conf

PrivateTmp=true

\[Install\]

WantedBy=multi-user.target

#### 13.1.3.3.启动mongod服务 ####

![Center 83][]

输入命令启动mongod服务并查看状态确保服务启动正常。

\# systemctl start mongodb        \#启动mongod服务

\# systemctl status mongodb       \#查看mongod状态

\#netstat –ntlp                  \#查看mongod端口

注意：shared服务器都是以这样的方式去配置（10.190.130.29；10.190.130.30）

## 13.2.在mongos中添加分片服务器 ##

由于client直接跟mongos打交道，也就说明我们要连接mongos服务器，然后将10.190.130.29和10.190.130.30的mongod交给mongos,添加分片也就是addshard()。

![Center 84][]

\#./mongo 10.190.130.80:2080/admin    \#连接mongos服务器，并且默认选择admin数据库

\#db.runCommand(\{addshard:"10.190.130.29:27017"\})  \#添加分片服务器

\#db.runCommand(\{addshard:"10.190.130.30:27017"\})  \#添加分片服务器

函数结构：db.runCommand(\{addshard:mongodb服务器地址：端口号 \})

如果添加的是副本分片，函数结构：

db.runCommand(\{addshard:"副本集名称/服务器地址：端口号"\})

## 13.3.在mongos中添加分片数据库 ##

![Center 85][]

开启数据库分片功能，命令很简单 enablesharding(),这里我就开启copp数据库

\#db.runCommand(\{enablesharding:"copp"\})  \#开启copp数据库分片

## 13.4.设置片键 ##

### 13.4.1.片键 ###

当设置分片时，需要从集合中选择一个或几个键（即集合中的字段），将选择出来的键作为数据拆分的依据，这个键叫做片键。选好片键后，MongoDB将不允许插入没有片键的文档，但是允许不同的文档的片键类型不一样。

![Center 86][]

指定集合中分片的片键，这里我就指定为UserInfo.userName，即userInfo集合中的userName字段。

\#db.runCommand(\{shardcollection:"copp.userInfo",key:\{"userName":1\}\})

函数结构：

db.runCommand(\{shardcollection:"数据库名称.集合名称 ",key:\{"字段名称":1\}\})

注意：在mongos分片模式中，默认分片模式是Ranged Sharding。

db.runCommand(\{shardcollection:"copp.userInfo",key:\{"userName":1\}\})该命令就是默认Ranged Sharding

## 13.5.块（chunk） ##

在一个shard server内部，MongoDB还是会把数据分为chunks，每个chunk代表这个shard server内部一部分数据，每个chunk的大小默认是64MB。

chunk的产生，会有以下两个用途：

### 13.5.1.Splitting（切分） ###

当一个chunk的大小超过配置中的chunk size时，MongDB的后台进程会把这个chunk切分成更小的chunk，从而避免chunk过大的情况

### 13.5.2.Balancing（均衡） ###

在MongoDB中，balancer是一个后台进程，负责chunk的迁移，从而均衡各个shard server的负载

## 13.6.测试分片结果 ##

### 13.6.1.通过mongos向mongodb插入数据 ###

![Center 87][]

配置完分片后，我们将通过mongos向mongodb插入10万条记录

\#for(vari=0;i<100000;i++)\{db.userInfo.insert(\{"userName":"user"+i,"depart":"towngas","userNo":"no."+i\})\}

插入数据成功后，会返回提示信息：WriteResult(\{“nInserted”:1\})

#### 13.6.2.分别查看mongod数据库的userInfo数据 ####

![Center 88][]

查看10.190.130.29的mongod数据库的记录。

\#db.userInfo.count()  \#查看userInfo集合下所有的记录数量

\#db.userInfo.find()   \#查看userInfo集合下记录

![Center 89][]

查看10.190.130.30的mongod数据库的记录。

\#db.userInfo.count()  \#查看userInfo集合下所有的记录数量

\#db.userInfo.find()   \#查看userInfo集合下记录

## 13.7.打印数据库分片信息 ##

官方参考地址：[https://docs.mongodb.com/manual/reference/method/js-database/][https_docs.mongodb.com_manual_reference_method_js-database]

![Center 90][]

在mongos数据服务器（10.190.130.80）下，必须进入到admin数据库下，

输入db.runCommand(\{“listShards”:1\})查看所有分片服务器。

\#./mongo 10.190.130.80:2080

\#use admin

\# db.runCommand(\{"listShards":1\})

![Center 91][]

输入sh.status()或db.printShardingStatus()可以打印状态信息。

## 13.8.打印服务器信息 ##

![Center 92][]

登录数据库后在，在admin数据库下输入db.serverStatus()

请参考官方指南：

[https://docs.mongodb.com/manual/reference/method/db.serverStatus/\#db.serverStatus][https_docs.mongodb.com_manual_reference_method_db.serverStatus_db.serverStatus]

## 13.9.删除分片 ##

![Center 93][]

db.runCommand(\{"removeshard":"分片服务器地址和端口"\})

# 14.分片策略 #

Sharded cluster支持将单个集合的数据分散存储在多个shard上，用户可以指定根据集合内文档的某个字段即shard key来分布数据，目前根据mongodb官方的文档描述，

可支持3种数据分布的策略，范围分片（Range based sharding），哈希分片（Hash based sharding）和标识符分片（Tag Aware sharding）。

参考：http://chuansong.me/n/349871651738

## 14.1.哈希分片（Hashed Sharding） ##

![Center 94][]

Hash分片是根据用设定的Shard Key计算出hash指，根据hash值（范围分片）的策略来将文档分布到不同的chunk中。Hash分片和Ranged分片是互补的，能将文档随机分配到各个chunk中，有充分的扩展写的能力，拟补了Ranged范围分片的不足，但会影响到查询的效率问题，不能高效率地去范围查询，所有的范围查询都分发到后端所有Shard服务器才去找出满足条件的记录（Document）。

Mongodb会自动计算hash值来解决查询时，使用hash的索引，不需要应用程序来计算hash值。

指定初始化chunk数量

如果使用一个hash片键来分片一个空集合，mongodb会自动创建或迁移一个空的chunk，因此，每个shard上都有2个chunk。当分片集合时可以去控制mongodb可以创建多少个chunk，使用shardCollection来初始化chunk的数量。

\#sh.shardCollection("new.person", \{ "\_id": "hashed" \} )

## 14.2.范围分片（Ranged Sharding） ##

![Center 95][]

如上图所示，集合根据x字段来分片，x的取值范围为\[minKey, maxKey\]（x为整型，这里的minKey、maxKey为整型的最小值和最大值），将整个取值范围划分为多个chunk，每个chunk（通常配置为64MB）包含其中一小段的数据。

Chunk1包含x的取值在\[minKey,-75)的所有文档，而Chunk2包含x取值在\[-75, 25)之间的所有文档…每个chunk的数据都存储在同一个Shard上，每个Shard可以存储很多个chunk，chunk存储在哪个shard的信息会存储在Config server种，mongos也会根据各个shard上的chunk的数量来自动做负载均衡。

范围分片能很好的满足『范围查询』的需求，比如想查询x的值在\[-30, 10\]之间的所有文档，这时mongos直接能将请求路由到Chunk2，就能查询出所有符合条件的文档。

范围分片的缺点在于，如果shardkey有明显递增（或者递减）趋势，则新插入的文档多会分布到同一个chunk，无法扩展写的能力，比如使用\_id作为shard key，而MongoDB自动生成的id高位是时间戳，是持续递增的。

sh.shardCollection("database.collection", \{ <shard key> \} )

在没有设置hash分片或标识符分片的情况下，默认是范围分片。

##  14.3.标识符分片（Tag Aware Sharding） ##

![Center 96][]

在分片集群中，可以使用标签为分片指定片键(shard key)的范围或者分片的子集，当在插入数据到数据库时，插入的数据必须带有标识符。

### 14.3.1.添加标签识别 ###

在分片集群中，可以使用用标签为分片指定片键(shard key)的范围或者分片的子集。

连接mongos服务器，使用sh.addShardTag()方法去指定一个标签给片键范围。任何的片键范围只能指派一个标签，或标签只能用一次。

\#sh.addShardTag("shard0000","NYC")              \#添加分片标签

### 14.3.2.删除标签识别 ###

Mongod不提供删除标签访问的帮助，你可以删除标签，从片键访问使用相关的文档从config数据库的标签集合

\#use config

\#sh.removeShardTag("shard0000","NYC")           \#删除分片标签

### 14.3.3.查看片键标签 ###

从sh.status()输出一个分片标签列表，如果有，每个分片。一个分片的标签存在分片文档的config data的分片集合中。返回所有分片指定的标签。

使用以下一系列的类似操作，将只返回这些分片标签。

\#use config

\#db.shards.find(\{tags:”NYC”\})

你也可以在config database的标签集合中去找所有命名空间的标签范围，sh.status()的输出显示所有标签范围。返回所有NYC的片键范围，使用以下操作：

\#use config

\#db.tags.find(\{tags:“NYC”\})

## 14.4.手动预先分片 ##

MongoDB自动分片都是先从一个分片上的一个chunk开始，然后通过不断的分裂和迁移来达到数据的切分和均衡，以来机器来自动执行的的好处是简单，

但对性能造成影响。所以可以采用mongodb手动分片策略来解决这个问题。

虽然mongodb解决了该问题，但也是有缺点的，手动预设分片前，必须预先计算好该数据库的数据来，根据数据量估算出，要分多少个chunk。

# 15.分片和副本结合 #

![Center 97][]

分片和副本架构

分片和副本集的优点在于可实现高可用和数据负载均衡，并且可以水平扩展数据库服务器。

1.当shard副本集中的primary节点宕机后，副本集中的两个secondary节点会通过选举的方式来选择一个节点作为primary节点，接替primary节点工作，所以shard副本集中任何一个节点宕机了，不会影响到数据集操作。

2.Config Server副本集中存储的是分片和shard的元数据，当ConfigServer中的一个节点宕机后，不会影响到数据的操作，副本集中的两个secondary节点会通过选举的方式来选择一个节点作为primary节点，接替primary节点工作，不会影响到mongos路由器。

3.Mongos路由服务器集群，所有客户端的请求都是经过mongos服务器来转发给shard服务器。当其中一台mongos路由服务器宕机后，不会影响到客户端的请求。Mongos服务器不用配置副本集，只要在代码中将所有的mongos服务器地址添加到代码中，便可实现mongos路由服务器高可用。3台服务器的mognos.conf配置文件是一致的。而在mongos配置的过程中，只有1台服务器配置添加shard副本集和添加片键设置即可，另外2台mongos服务器不再添加配置。

注意：根据mongodb官方的推荐，mongos，config和shard最少分别各需要3台服务器

参考地址：http://chuansong.me/n/349871651738

以下是配置mongodb分片+副本集的整个过程。

![Center 98][]

分片+副本集

服务器要求：

Mongos路由集群2台服务器：

10.190.130.73，10.190.130.80

Config服务器副本集2台服务器：

10.190.130.81，10.190.130.74

Shard服务器副本集1需要3台shard服务器：

10.190.130.27，10.190.130.28，10.190.130.79

Shard服务器副本集2需要3台shard服务器：

10.190.130.29，10.190.130.30，10.190.130.78

## 15.1.启动副本集服务器 ##

关于如何配置shard服务器的副本集，这里就不会再进行描述了，请参考<12.数据库副本集>章节的步骤去配置。shard副本集有2个，副本集1服务器

（10.190.130.27，10.190.130.28，10.190.130.79），副本集2服务器（10.190.130.29，10.190.130.30，10.190.130.78）

![Center 99][]

启动第一个副本集，并使用rs.status()命令查看当前副本集的状态以及shard服务器信息。

\#rs.status() 查看副本集状态信息

![Center 100][]

启动第2个副本集，并使用rs.status()命令查看当前副本集的状态以及shard服务器信息。

\#rs.status() 查看副本集状态信息

## 15.2.启动config副本集服务器 ##

为了实现高可用性，所以config服务器也进行设计成副本集结构。共有2个config服务器，如果配置config服务器副本，请参考<12.数据库副本集>章节的步骤去配置。

### 15.2.1.配置config服务器的配置文件 ###

![Center 101][]

启动config副本集中的第1台服务器，关于如何配置config中的mongod.conf文件请参考<13.1.1Config服务器>的章节进行配置。但副本集的配置有点小区别是：需要添加上replication节点，需要加上副本集名称。

以下是mongod.conf配置文件内容。

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

storage:

dbPath: /usr/local/mongodb-rh7/data/configdb

processManagement:

fork: true

sharding:

clusterRole: configsvr

replication:

oplogSizeMB: 5

replSetName: config01        \#定义副本集名称

![Center 102][]

启动config副本集中的第2台服务器，关于如何配置config中的mongod.conf文件请参考<13.1.1Config服务器>的章节进行配置。但副本集的配置有点小区别是：需要添加上replication节点，需要加上副本集名称。

以下是mongod.conf配置文件内容。

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

storage:

dbPath: /usr/local/mongodb-rh7/data/configdb

processManagement:

fork: true

sharding:

clusterRole: configsvr

replication:

oplogSizeMB: 5

replSetName: config01        \#定义副本集名称

注意：2台config服务器的mongod.conf文件中的replSetName名称必须一致。

### 15.2.2.定义config服务器副本集变量 ###

![Center 103][]

使用mogno连一个副本集中任意一台机器后，进行定义副集变量。

config=\{\_id:"config01",members:\[\{\_id:0,host:"10.190.130.81:27019"\},\{\_id:1,host:"10.190.130.74:27019"\}\]\}

语法如下：

cofig=\{\_id:"副本集名称，与文件中的replsetName一致

",members:\[\{\_id:0,host:"服务器地址:端口号"\},\{\_id:1,host:"服务器地址:端口号"\}\],依次类推下去\}，config名称可以自定义

### 15.2.3.初始化config服务器副本集 ###

![Center 104][]

使用rs.initiate(config)命令进行初始化副本集，只能初始化一次。

\#rs.initiate(config)    \#初始化副本集，config就是前面定义的副本集的变量名称

### 15.2.4.查看config副本集状态 ###

![Center 105][]

初始化副本集成功后，输入rs.status()命令查看副本集的状态。可当前的信息看出，该服务器的状态是主节点。

![Center 106][]

连接副本集中的secondary节点服务器，显示的状态是secondary。

## 15.3.启动mongos服务器 ##

![Center 107][]

由于config服务器是副本集结构，所以在配置mognos.conf文件也有所变化。

跟以前不同，这里需要在服务器地址前添加副本集名称，每个服务器之间都要用逗号隔开就可以。这是启动第一个mongos服务器。

以下是mongos.conf文件配置内容：

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongos.log

logAppend: true

processManagement:

fork: true

net:

port: 2080

sharding:

configDB: config01/10.190.130.81:27019, 10.190.130.74:27019 \#(副本集名称/config服务器1地址,config服务器2地址)

![Center 108][]

第2个mognos.conf的配置文件内容与第一个mongos的配置文件一样。以下是mongos.conf文件文件内容：

systemLog:

destination: file

path: /usr/local/mongodb-rh7/log/mongodb.log

logAppend: true

processManagement:

fork: true

net:

port: 2080

sharding:

configDB: config01/10.190.130.81:27019, 10.190.130.74:27019

注意：启动第二个mognos服务器,启动成功后，第二个mongos服务器就不需要在添加分片数据库了，以为第一个mongos已经添加分片数据库和片键，所有这些分片信息都在存储config服务器副本集中，所以第一个mongos和第二个mongos的config服务器信息是一致的。

## 15.4.在mongos服务器中添加数据库分片副本集 ##

![Center 109][]

连接任意1台mongos服务器后，必须进入到admin数据库下，添加shard数据库副本集。添加副本集时，只需要添加shard副本集中的主节点（primary node）就可以了。而本案例有两2个shard数据库副本集，所以只要添加2个副本集的主节点就可以了。

\#./mongo 10.190.130.80:2080/admin

\#db.runCommand(\{addshard:"re01/10.190.130.27:27017"\})

\#db.runCommand(\{addshard:"re02/10.190.130.29:27017"\})

## 15.5.在mongos中添加分片数据库 ##

![Center 110][]

在mongos服务器中添加1个分片的数据库。

db.runCommand(\{enablesharding:"copp"\})

## 15.6.在mongos中添加片键 ##

![Center 111][]

db.runCommand(\{shardcollection:"copp.userInfo",key:\{"userName":1\}\})

注意：启动第2个mognos服务器,启动成功后，第2个mongos服务器就不需要在添加分片数据库了，因为第一个mongos已经添加分片数据库和片键，

所有这些分片信息都在存储config服务器副本集中，所以第一个mongos和第二个mongos的config服务器信息是一致的。

## 15.7.测试分片和副本集 ##

http://blog.csdn.net/zzq900503/article/details/8685893

## 15.7.1.通过mongos想mongodb插入数据 ##

![Center 112][]

在第一个mongos中插入100w条数据。插入成功。

for(vari=0;i<1000000;i++)\{db.userInfo.insert(\{"userName":"user"+i,"depart":"towngas","userNo":"no."+i\})\}

![Center 113][]

在第二个mongos服务器中查看数据库数据，显示正确。由于第一个mongos和第二个mongos服务器的config服务器是一致的，所以查看的数据是一模一样的。

### 15.7.2.查看副本集数据 ###

![Center 114][]

副本1主节点

![Center 115][]

副本集1中secondary节点。

![Center 116][]

副本集1中secondary节点

![Center 117][]

副本集2主节点的数据。

![Center 118][]

副本集2secondary节点数据量。

![Center 119][]

副本集2secondary节点数据量。

# 16.导出数据库 #

1.导出功能分为2种格式导出数据，一种是json格式另外一种则是csv格式。

2.常见的mongoexport导出文件的参数如下：

\-h 远程数据库地址和端口号

\-d 数据库名称

\-c 表名(collection集合名称)

\-f field1,field2（列名）

\-o 导出文件名

\-q 查询条件

\--csv 导出csv格式

需要设置更多的参数，请参考官方文档或使用帮助命令查看使用方法

官方文档地址：[https://docs.mongodb.com/manual/reference/program/mongoexport/][https_docs.mongodb.com_manual_reference_program_mongoexport]

命令帮助：./mongoexport --help

## 16.1.本地导出数据 ##

### 16.1.1.导出json格式数据 ###

![Center 120][]

在本地导出copp数据库下的userInfo集合，导出的默认格式是json.

./mongoexport -d copp -c userInfo -o /usr/local/mongodb-rh7/exportFile/copp.userInfo.json

命令格式：

./mongoexport -d 数据库名称-c 集合名称 -o 输出文件的位置和文件名称.json

![Center 121][]

进入到exportFile目录下输入more copp.userInfo.json命令后，便可查看导出的数据，显示的格式是json格式。

### 16.1.2.导出csv格式数据 ###

![Center 122][]

在本地导出copp数据库下的userInfo集合，以cvs格式导出数据。

./mongoexport -d copp -c userInfo -fuserName,depart,userNo --type=csv

\-o/usr/local/mongodb-rh7/exportFile/copp.userInfo.csv

命令格式：

./mongoexport -d 数据库名称-c 集合名称 -f 导出的字段名称--type=格式名称

\-o 输出文件的位置和文件名称.cvs

![Center 123][]

进入到exportFile目录下输入more copp.userInfo.csv命令后，便可查看导出的数据，显示的格式是csv格式。

## 16.2.远程导出数据 ##

### 16.2.1.导出json格式数据 ###

![Center 124][]

从远程数据库导出数据到本地exportDatabaseFile目录中。需要注意的时，本地需要连接数据库的mongoexport文件。  
  
导出数据命令如下：  
./mongoexport -h 192.168.238.132 -d copp -c userInfo   
\-o /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json  
  
命令格式：  
./mongoexport -h数据库连接地址和端口号 -d 数据库名称-c 集合名称 -o 输出文件的位置和文件名称.json

![Center 125][]

进入到exportDatabaseFile目录下输入more copp.userInfo.json命令后，便可查看导出的数据，显示的格式是json格式

### 16.2.2.导出csv格式数据 ###

![Center 126][]

远程导出copp数据库的userInfo集合数据，以csv格式导出  
  
导出命令如下：  
./mongoexport -h 192.168.238.132 --port 27017 -d copp -c userInfo -f userName,depart,userNo --type csv -o /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.csv  
  
语法结构：  
./mongoexport -h 远程数据库地址 --port 数据库端口号 -d 数据库名称 -c集合名称  
 -f 字段名称1,字段名称2...  --type csv -o 指定文件路径和名称.csv

![Center 127][]

连接远程copp数据库，查看userInfo集合下的数据量和数据

查询语句如下：

\#./mongo 192.168.238.132:27017/copp

\#db.userInfo.count()

\# db.userInfo.find()

### 16.3.身份认证导出数据 ###

当连接数据库需要输入身份认证时，需要添加用户名和密码参数。  
\#./mongoexport -h 192.168.238.132 --port 27017 -u root -p root -d copp -c userInfo   
\-o /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json  
  
  
语法结构如下：  
  
  
./mongoexport -h 数据库地址 --port 数据库端口号 -u 用户名 -p 密码 -d 数据库名称  
 -c 集合名称  
\-o 集合的目录和文件名称.json

# 17.导入数据库 #

1.导出功能分为2种格式导入数据，一种是json格式另外以各种则是csv格式。  
  
  
常见mongoimport导入命令如下：  
\-h  数据库地址  
\-d  指定要导入的数据库  
\-c  要导入的集合名称  
\--headerline 去掉文件第一行数据  
\--type 文件类型.csv/json(默认)  
\--file 导入的数据文件  
  
  
需要设置更多的导入参数，请参考官方文档或者查看命令帮助文档：  
官方文档地址：https://docs.mongodb.com/manual/reference/program/mongoimport/  
命令文档：./mongoimport --help

## 17.1.本地导入数据 ##

### 17.1.1.导入json格式数据 ###

![Center 128][]

在进入到bin目录下，将copp.userInfo.json导入copp数据库下的userInfo集合，以json格式导入数据库。  
  
导入命令如下：  
./mongoimport -d copp -c userInfo --type json   
\--file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json  
  
命令格式：  
./mongoimport -d 数据库名称 -c 集合名称 --type 格式名称 --file 输出文件的位置和文件名称.json

![Center 129][]

连接数据库，切换到copp数据库下查看userInfo集合的数据。

输入命令以下：

\#./mongo localhost:27017

\#use copp

\#db.userInfo.count()

\#db.userInfo.find()

### 17.1.2.导入csv格式数据 ###

![Center 130][]

使用csv格式导入数据，导入数据时候，必须要加入--headerline参数，该参数可过滤掉csv文件的第一行数据，避免将字段名称导入到数据库中。  
  
以下是导入数据命令：  
 ./mongoimport -d copp -c userInfo --type csv --headerline   
\--file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.csv  
  
命令格式如下：  
 ./mongoimport -d 数据库名称-c 集合明后层--type csv格式 --headerline  
 --file 导入数据的文件路径和名称.csv

![Center 131][]

连接数据库，查看导入到copp数据库下的userInfo集合数据。

输入命令如下：

./mongo localhost

use copp

db.userInfo.count()

db.userInfo.find()

## 17.2.远程导入数据 ##

### 17.2.1.导入json格式数据 ###

![Center 132][]  
远程导入json格式的数据到copp数据库的userInfo集合中。  
输入以下命令：  
./mongoimport -h 192.168.238.132 --port 27017 -d copp -c userInfo --type json   
\--file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json  
  
语法结构：  
./mongoimport -h 远程服务器地址 --port 数据库的端口号 -d 数据库名称 -c 集合名称  
\--type json --file 文件路径和文件名称.json

![Center 133][]

连接到远程数据库，查询导入数据。

查询命令如下：

\#./mongo 192.168.238.132:27017/copp

\#db.userInfo.count()

\#db.userInfo.find()

### 17.2.2.导入csv格式数据 ###

![Center 134][]

远程导入csv格式数据到copp数据库下的userInfo集合中。

\#./mongoimport -h 192.168.238.132 --port 27017 -d copp -c userInfo --type csv

\--headerline--file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.csv

语法结构：

./mongoimport -h 数据库地址--port 数据库端口号 -d 数据库名称 -c 集合名称 --typecsv --headerline\--file 文件路径和文件名称.csv

注意：导入csv格式数据时，必须要加入--headerline参数，可避免将csv数据的第一行导入到数据库中，第一行是数据一般都是集合的字段名称。

![Center 135][]

连接远程copp数据库，查看copp数据库下userInfo集合中的数据量和数据。

查询命令如下：

\#./mongo192.168.238.132:27017/copp

\#db.userInfo.count()

\#db.userInfo.find()

## 17.3.身份认证导入数据 ##

当连接数据库需要输入身份认证时，需要添加用户名和密码参数。  
\#./mongoimport -h 192.168.238.132 --port 27017 -u root -p root -d copp -c userInfo   
\--type json --file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json  
  
  
语法结构如下：  
./mongoimport -h 数据库地址 --port 数据库端口号 -u 用户名 -p 密码 -d 数据库名称  
 -c 集合名称 --type json  
\--file 集合的目录和文件名称.json

# 18.备份数据库 #

使用mongodump导出二进制bson结构的数据以及其索引信息

\-h 远程数据库地址

\-d 数据库名称

\-c 集合名称

\-f field1,field2...列名

需要了解跟多的参数设置，请参考官方帮助文档或者数据库命令的帮助文档：

官方文档地址：

[https://docs.mongodb.com/manual/reference/program/mongodump/\#bin.mongodump][https_docs.mongodb.com_manual_reference_program_mongodump_bin.mongodump]

命令帮助文档：./mongodump --help

![Center 136][]

连接远程数据库输入导出命令，导出copp数据库下userInfo集合中的数据。没有指定导出文件的目录，默认会导出到mongo下的dump目录。  
  
\#./mongodum -h 192.168.238.132 --port 27017 -d copp -c userInfo  
  
  
语法结构：  
\#./mongodum -h 远程数据库地址/本地数据库地址 --port 数据库端口号 -d 数据库名称 -c 集合名称  
  
语法说明：  
1.导出的文件存放在database命名的目录下。  
2.每个表导出2哥文件，分别是bson文件和json的元数据文件  
3.如果不加入-c集合参数，那么会导出该数据库下所有的集合数据。

![Center 137][]

进入到dump该目录会有一个文件夹，该文件以数据库名称命令，进入到里面可以看到两个文件一个是bson数据文件，另外一个是元数据文件。

由于bson文件是二进制文件，所以只能使用vi编辑bson文件才能看到里面的内容。

![Center 138][]

通过 more userInfo.metadata.json可以查看到元数据文件的内容。

![Center 139][]

连接远程数据库，将copp数据库下所有的集合数据全部导出，并将文件保存到指定的目录

\#./mongodump -h 192.168.238.132 --port27017 -d copp -o /usr/local/mongodb-rh7/backup

![Center 140][]

进入到指定的输出目录下，可查看到导出所有集合的数据文件。

# 19.还原数据库 #

使用mongorestore还原二进制文件

\-h 远程数据库地址/本地数据库地址

\--port 数据库端口号

-d数据库

\--dir 还原数据库文件目录

二进制文件不仅可以备份数据，还可以备份索引，而且备份文件比较小，速度快。

需要了解跟多的参数设置，请参考官方帮助文档或者数据库命令的帮助文档：

官方文档地址：[https://docs.mongodb.com/manual/reference/program/mongorestore/][https_docs.mongodb.com_manual_reference_program_mongorestore]

命令帮助文档：./mongorestore --help

![Center 141][]

连接远程或本地数据库后，指定还原数据库文件的目录，将多个集合数据还原到copp数据库中。还原所有集合数据到copp数据库中的命令如下：

\#./mongorestore -h 192.168.238.132 --port27017 -d copp

\--dir /usr/local/mongodb-rh7/backup/copp

语法结构：

./mongorestore -h 远程数据库地址/本地数据库地址--port 数据库端口号 -d 数据库名称

\--dir 还原的数据库文件目录

![Center 142][]

连接到copp数据库，查看还原到copp数据库下的所有集合数据。  
  
查询命令如下：  
\#./mongo 192.168.238.132/copp  
\#show collections  
\#db.userInfo.count()  
\#db.companyInfo.count()  
\#db.companyInfo.find()  
\#db.userInfo.find()

![Center 143][]

连接远程数据库还原指定的集合到copp数据库中。

命令如下：

./mongorestore -h 192.168.238.132 --port27017 -d copp -c userInfo

/usr/local/mongodb-rh7/backup/copp/userInfo.bson

语法结构：

./mongorestore -h 远程数据库地址--port 数据库端口号 -d 数据库名称 -c 集合名称

还原的集合数据路径和文件名称.bson（即还原指定的bson数据的目录和文件名称）

![Center 144][]

连接远程的copp数据库，查看还原的copp数据库下的userInfo集合数据。  
  
\#./mongo 192.168.238.132/copp  
\#show collections  
\#db.userInfo.count()  
\#db.userInfo.find()

# 20.监控数据库状态 #

使用mongostat查看mongos或mongod服务器的状态，常见参数如下：

\-h      数据库地址

\--port   数据库端口号

\-u      登录数据库的用户名

\-p      登录数据库的密码

多个参数的设置，请查看官方文档或命令帮助文档：

官方文档地址：[https://docs.mongodb.com/manual/reference/program/mongostat/][https_docs.mongodb.com_manual_reference_program_mongostat]

命令帮助文档：./mongostat --help

![Center 145][]

连接mongos或mongod查看服务器状态，命令如下：

./mongostat -h 192.168.238.132 --port 27017

# 21.数据库读写数据跟踪 #

使用mongostop来跟踪mongodb数据库读写数据的统计，默认情况下，每秒返回数据，常见参数如下：

\-h      数据库地址

\--port   数据库端口号

\-u      登录数据库的用户名

\-p      登录数据库的密码

多个参数的设置，请查看官方文档或命令帮助文档：

官方文档地址：[https://docs.mongodb.com/manual/reference/program/mongotop/][https_docs.mongodb.com_manual_reference_program_mongotop]

命令帮助文档：./mongotop --help

![Center 146][]

输入./mongotop –h 192.168.238.132 –port 27017命令后，可跟踪数据库读写数据的统计，默认情况下，每秒返回一次数据。

# 22.附录    #

## 22.1.键值对格式配置Mongod.conf文件 ##

进入到mongodb的bin目录下，输入命令vi mongod.conf创建配置文件。输入配置信息后，进行保存。

![Center 147][]

\#dbpath=/usr/local/mongodb-rh7/data              \#表示存储mongodb数据库文件目录

\#logpath=/usr/local/mongodb-rh7/log/mongodb.log  \#表示存储日志文件

\#logappend=true                              \#日志是追加模式，false是覆盖模式

![Center 148][]

在bin目录下可看到新建的mongod.conf文件

## 22.2.命令配置方式启动 ##

进入到mongodb的bin目录下，输入命令./mongod--dbpath=/usr/local/mongodb-rh7/data/--logpath=/usr/local/mongodb-rh7/log/mongodb.log启动mongodb服务，并设置mongodb数据库的文件存放到/usr/local/mongodb-rh7/data目录下。

\--dbpath=/usr/local/mongodb-rh7/data 设置存放文件目录。

\--logpath=/usr/local/mongodb-rh7/log/mongodb.log设置存放日志目录

![Center 149][]

\#`.` ./mongod --dbpath=/usr/local/mongodb-rh7/data/--logpath=/usr/local/mongodb-rh7/log/mongodb.log

![Center 150][]

\#ps -ef | grep mongodb

\#netstat -ntlp

新建一个命令窗口，查看mongodb的端口和进程信息。

## 22.3.键值对的Mongod.conf配置文件参数说明 ##

在和bin目录同级的目录下面建一个mongod.config文件（编码格式为utf8无bom格式，否则会报错），作为mongodb的配置文件。\[ps:在启动的时候会用到\]

---mongo.config文件内容如下：

\#\#数据文件

dbpath=D:\\mongodb\\data\\db

\#\#日志文件

logpath=D:\\mongodb\\data\\log\\mongo.log

\#错误日志采用追加模式，配置这个选项后mongodb的日志会追加到现有的日志文件，而不是从新创建一个新文件

logappend=true

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

journal=true

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

quiet=false

\#端口号 默认为27017，注意这里端口修改为9888后，要用mongo--port=9888连接，否则报错。

port=9888

## 22.4.查看运行参数 ##

在bin目录下输入：

\#./mongo –help        \#查看mongo的帮助说明

![Center 151][]

\#./mongod –help       \#查看mongod运行帮助说明

![Center 152][]![Center 153][]![Center 153][]![Center 154][]![Center 155][]

## 22.5.查看日志信息 ##

\[root@localhost system\]\# systemctl startmongodb.service

Job for mongodb.service failed because thecontrol process exited with error code. See "systemctl statusmongodb.service" and "journalctl -xe" for details.

当使用systemctl操作mongodb服务出现以上错误信息时，需要查看日志文件:

![Center 156][]

\#cat /var/log/messages    \#查看整个messages文件的信息

![Center 157][]

\#cat /var/log/messages       \#对messages的文件信息进行筛选

## 22.6.设置MongoDB环境变量 ##

![Center 158][]

输入命令进行编辑profile文件

\#vi /etc/profile.

![Center 159][]

在文件最后追加上脚本后，进行保存。

\#PATH=$PATH:/usr/local/mongodb-rh7/bin

\#export PATH

![Center 160][]

输入\# source /etc/profile，可使文件立即生效，如果没有出现错误，说明环境变量配置成功。

之前运行mongodb服务需要进入到cd /usr/mongodb-rh7/bin，再输入./mongod，而现在直接输入mongod就可以启动服务。

## 22.7.删除数据库管理员 ##

db.system.users.remove(\{user:'root'\})

WriteResult(\{ "nRemoved" : 1 \})

## 22.8.MongoDB帮助手册 ##

成功启动MongoDB后，再打开一个命令行窗口输入mongo，就可以进行数据库的一些操作。

输入help可以看到基本操作命令：

show dbs:显示数据库列表

show collections：显示当前数据库中的集合（类似关系数据库中的表）

show users：显示用户

use <db name>：切换当前数据库，这和MS-SQL里面的意思一样

db.help()：显示数据库操作命令，里面有很多的命令

db.foo.help()：显示集合操作命令，同样有很多的命令，foo指的是当前数据库下，一个叫foo的集合，并非真正意义上的命令

db.foo.find()：对于当前数据库中的foo集合进行数据查找（由于没有条件，会列出所有数据）

db.foo.find( \{ a : 1 \} )：对于当前数据库中的foo集合进行查找，条件是数据中有一个属性叫a，且a的值为1

MongoDB没有创建数据库的命令，但有类似的命令。

如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。

查看聚集集合基本信息

1、查看帮助  db.yourColl.help();

2、查询当前集合的数据条数  db.yourColl.count();

3、查看数据空间大小db.userInfo.dataSize();

4、得到当前聚集集合所在的dbdb.userInfo.getDB();

5、得到当前聚集的状态db.userInfo.stats();

6、得到聚集集合总大小db.userInfo.totalSize();

7、聚集集合储存空间大小db.userInfo.storageSize();

8、Shard版本信息  db.userInfo.getShardVersion()

9、聚集集合重命名db.userInfo.renameCollection("users"); 将userInfo重命名为users

10、删除当前聚集集合db.userInfo.drop();

![Center 161][]

查看显示数据库操作命令\#db.help()

![Center 162][]

查看用户集合操作命令：db.users.help()

## 22.9.Q&A ##

### 22.9.1.1.Mongos配置正确，但启动mongs服务器失败 ###

原因分析：

Mongos.config文件配置正确，mongos.service配置正确，但是输入systemctlstart mongos命令后，启动失败，提示：

![Center 163][]

显示超时错误。

![Center 164][]

输入命令查看mongos.log文件，从文件信息中可以看出无法连接config服务器，是因为config服务器开启防火墙导致无法通信：

\#cd /usr/local/mongodb-rh7/log

\#more mongos.log     \#查看mongos日志

解决方法：

1.关闭config服务器防火墙

2.在config服务器中添加config服务的端口和mongos的端口到firewalld中。

\#firewall-cmd --permanent--add-port=27017/tcp

\#firewall-cmd –reload

\#firewall-cmd --list-all

![Center 165][]

### 22.9.1.2.连续添加副本集成员会出现错误？ ###

原因：根据官方的文档说明，添加一个成功后当前会处于secondary。

解决方法：添加一个成员成功后，再从新连接primary数据库服务器添才能加第二个成员。

![Center 166][]

### 22.9.1.3.在secondary节点上查询数据显示错误。 ###

原因：副本集环境下，进入到secondary节点，进行数据查询时，显示错误信息：count failed: \{ "ok" : 0, "errmsg" : "notmaster and slaveOk=false", "code" : 13435 \}？

解决方法：在secondary节点必须先执行rs.slaveOk()语句后，才能进行执行数据查询，否则出错。

![Center 167][]

### 22.9.1.4.重新启动故障主节点后，显示故障的节点的状态为RECOVERING。 ###

原因：由于以前的主节点数据库还有残留数据。

解决方法：启动被停止的主节点服务器之前，先清空启动服务器下的数据文件。

![Center 168][]

### 22.9.1.5.使用rs.initiate(config)方法初始化config服务器副本集时报错。 ###

原因：初始化时，提示Missingexpected field \\”version\\””,”code”:93经过搜索信息，是一个issue来的，根据官方的记录是在3.2.3版本中发现，

但是已经在3.2.4和3.2.8中已经解决该问题。而我的版本是3.2.8版本来的，应该不会出现该问题，感觉非常郁闷。请参考issue记录：

[https://jira.mongodb.org/browse/SERVER-22731][https_jira.mongodb.org_browse_SERVER-22731]

解决方法：找了很多资料还是没有找到解决方法，最后，将两个副本集的config服务器停止并删除data文件重新启动，最后可以初始化成功。

![Center 169][]

[Chris_111X]: http://my.csdn.net/Chris_111X
[Center]: /images/20220715/dc887fb1f7f84de58ba9f5d1596896f5.png
[Center 1]: /images/20220715/ca72fbd1acde43b3a9b20233e5845532.png
[Center 2]: /images/20220715/ee287a7bb5ef415fae48188fd5f1e772.png
[Center 3]: /images/20220715/7c012144bd60485cacbe6cf4911c5b43.png
[Center 4]: /images/20220715/653061a9e1304b3dac03f7a3ba494f34.png
[Center 5]: /images/20220715/4100d13d344c4b0bb2bce56923f54688.png
[Center 6]: /images/20220715/cff0aaf443d143228bcbb04c6f3ee5fa.png
[Center 7]: /images/20220715/9b5363c4451e4ecdb55549d316129058.png
[Center 8]: /images/20220715/1f04f6303f7640c8b62918129e922a6c.png
[Center 9]: /images/20220715/886aeed520604acc9bcc77ec510256c7.png
[Center 10]: /images/20220715/069b16d47e4c4bf4af376691147a9104.png
[Center 11]: /images/20220715/23747a435ca54615879525ce27c6f886.png
[Center 12]: /images/20220715/cced8fa899eb40a2900a9b7ec5250065.png
[Center 13]: /images/20220715/7906b5e61d224d25a02cb928e424be5a.png
[Center 14]: /images/20220715/25d12758b485436da86e094699d9aa7e.png
[Center 15]: /images/20220715/c776870a928c4c23b3499334c19e8b09.png
[Center 16]: /images/20220715/b7c8de8248da49abbf0a5077d1163bf2.png
[Center 17]: /images/20220715/c4a58ec60f6045c3833e82ced20513bd.png
[Center 18]: /images/20220715/edadf27b918341b3beb40fdec34d0198.png
[Center 19]: /images/20220715/0e303e3e6fa94d35890446761cdc6220.png
[https_docs.mongodb.com_manual_core_security-users]: https://docs.mongodb.com/manual/core/security-users/
[https_docs.mongodb.com_manual_tutorial_create-users]: https://docs.mongodb.com/manual/tutorial/create-users/
[https_docs.mongodb.com_manual_reference_built-in-roles_all-database-roles]: https://docs.mongodb.com/manual/reference/built-in-roles/#all-database-roles
[Center 20]: /images/20220715/23272461dded47f99975c33e33835503.png
[Center 21]: /images/20220715/837d7494b5e945d0847f6dcc2c0c1ba1.png
[Center 22]: /images/20220715/d98c5023068f4ed792913e8eca483786.png
[Center 23]: /images/20220715/b4c3ab0a3fc4407092cc0b38ba961c7a.png
[Center 24]: /images/20220715/611d1a09d7e04d17b9945b7a3e35927f.png
[Center 25]: /images/20220715/40307915326d4b74812efd7b3e146367.png
[Center 26]: /images/20220715/246a98e5c1154242a57127a0322152f0.png
[Center 27]: /images/20220715/d467e79b6bd84a588911564a5122b0b7.png
[Center 28]: /images/20220715/18ba0a1f2e164e8eb8b7083b7f548a3a.png
[Center 29]: /images/20220715/13f2294cee0a47c2b661c5753c76430b.png
[Center 30]: /images/20220715/18855b948cd74ff89684a5ab58121b73.png
[Center 31]: /images/20220715/77498d69b15345f0a572b53238e98a1c.png
[Center 32]: /images/20220715/919c9d4f15a14c438139dcbb73f70d06.png
[Center 33]: /images/20220715/4a7acf9d4a614eefb672fc4a3a3f727e.png
[Center 34]: /images/20220715/cffe5087a6284047965ee3d51d251700.png
[Center 35]: /images/20220715/9dbb20f67abf4b65aa27089a75f7fecc.png
[Center 36]: /images/20220715/abaa6db5eefa415281d23202cecadf7b.png
[Center 37]: /images/20220715/1e37a98a27cc4ffbb119b1229639b576.png
[Center 38]: /images/20220715/9a16abde530b420d8b18fbd529a4a0a8.png
[Center 39]: /images/20220715/a5e1fea05c744695a87071532959ddf7.png
[Center 40]: /images/20220715/1098ed9b9291470aab7dba2718ea0bc0.png
[Center 41]: /images/20220715/74aad59ab9be48f9b9ad82cb3db5bacc.png
[Center 42]: /images/20220715/8d6995353cf6409da89d432bf1fe80e1.png
[Center 43]: /images/20220715/607fed10c3744b9bb8917c211c4ec8ce.png
[Center 44]: /images/20220715/ee889c7741984040b72b6e1da73d0ccd.png
[Center 45]: /images/20220715/1c9534770bc3405bbfa54a4420c2d9a3.png
[https_docs.mongodb.com_manual_reference_replica-states]: https://docs.mongodb.com/manual/reference/replica-states/
[Center 46]: /images/20220715/001c38d0807d489a91f970b67bd00b7a.png
[Center 47]: /images/20220715/76be810224e940d295e3f7c3636848af.png
[Center 48]: /images/20220715/86ff37fd2df34220b5020bf6ca0b7384.png
[Center 49]: /images/20220715/6cd8c9bcbe5f4d48920a3a5f1600d4cf.png
[Center 50]: /images/20220715/97d3ad960f3049609365d99f83f08838.png
[Center 51]: /images/20220715/a94652e14e8d4d77b61fa1e311e3faba.png
[Center 52]: /images/20220715/6d990b0488c342bfbd6a60c716489651.png
[Center 53]: /images/20220715/ede2d1e247a5421794ea35e5521c4fbc.png
[Center 54]: /images/20220715/b5f66ef979ab4d8d95c95190f89de5d2.png
[Center 55]: /images/20220715/f192a380c72a4b10b41a36d3bcd65510.png
[https_docs.mongodb.com_manual_tutorial_remove-replica-set-member]: https://docs.mongodb.com/manual/tutorial/remove-replica-set-member/
[Center 56]: /images/20220715/e5b9d406a03140dca234ed4f29ad2236.png
[Center 57]: /images/20220715/0e2c3a9cc82445748f6fd972e6ed63bd.png
[Center 58]: /images/20220715/2daf523c94d844ef9fd0674c56ab7323.png
[Center 59]: /images/20220715/3c213b2f8c8a4c01a6468a8c177194e5.png
[Center 60]: /images/20220715/d8f2088a15af4ffca08472592b406607.png
[Center 61]: /images/20220715/1dab2d77fc9b4e08b5b3963b8006fa83.png
[Center 62]: /images/20220715/434558d96f35423f987c53f88084b267.png
[Center 63]: https://img-blog.csdn.net/20160905170851131?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 64]: /images/20220715/ce747629a6424ea49fc9eecd9233464e.png
[Center 65]: https://img-blog.csdn.net/20160905171035288?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 66]: /images/20220715/2ccecb59446f402ab35fd7fecb472724.png
[Center 67]: /images/20220715/99f5abe239ac4ec59c4352c031122494.png
[Center 68]: /images/20220715/740745ea66fc4ec78afef83d4977c725.png
[Center 69]: /images/20220715/2cca85054a564dc3a6a07f44676d2e42.png
[Center 70]: /images/20220715/70c69a5a650145b7b57163cd36b7ed3b.png
[Center 71]: /images/20220715/6d4f85b74bc34263b34cbe753df05c3d.png
[https_docs.mongodb.com_manual_tutorial_force-member-to-be-primary]: https://docs.mongodb.com/manual/tutorial/force-member-to-be-primary/
[Center 72]: /images/20220715/2b78b32cc12c4c79b244a1e7a18d9845.png
[Center 73]: /images/20220715/0d8c897d464b4a6e849e45de6a1da189.png
[Center 74]: /images/20220715/2f6603411db646cda8e3f5fa9a23500a.png
[Center 75]: /images/20220715/e91c989c86f24ed88d2782a790829750.png
[Center 76]: /images/20220715/b8981a88f309468cad6ff0e13a8296de.png
[Center 77]: /images/20220715/630c9baeb6f442be9171c71412250dbc.png
[https_docs.mongodb.com_manual_reference_configuration-options_configuration-file]: https://docs.mongodb.com/manual/reference/configuration-options/#configuration-file
[Center 78]: /images/20220715/5d7c4991e1774fef80b580b7f247bad2.png
[Center 79]: /images/20220715/68b1af02668c4ed7934c70008dffa6d0.png
[Center 80]: /images/20220715/75409bfc4fab493abdce23a291350297.png
[Center 81]: /images/20220715/e731422650134e4ba003f6d486797be6.png
[Center 82]: /images/20220715/4283422e834048e08e020a7fcd1f3b2d.png
[Center 83]: /images/20220715/80b04a27517e4651874020daba965b61.png
[Center 84]: /images/20220715/841c34f5795049048683b1364653bf7a.png
[Center 85]: /images/20220715/51b6f4f6181e408baabe43ff71eac9bb.png
[Center 86]: /images/20220715/e8ac4c98ec684e1db596f917e75bdd86.png
[Center 87]: /images/20220715/6723a8f734694834a8bbc788e2cc046b.png
[Center 88]: /images/20220715/0bec32dd1f904a80bfac88cc8895daf6.png
[Center 89]: /images/20220715/7be163fd79ab411cbac5a8cbf654e564.png
[https_docs.mongodb.com_manual_reference_method_js-database]: https://docs.mongodb.com/manual/reference/method/js-database/
[Center 90]: /images/20220715/4e38fca50e884c6fb928dd6d6260f83e.png
[Center 91]: /images/20220715/dca97a57100a4e22a89c9a91bbcfb0cc.png
[Center 92]: /images/20220715/9fe5964b04014edc9a976fdc61353efb.png
[https_docs.mongodb.com_manual_reference_method_db.serverStatus_db.serverStatus]: https://docs.mongodb.com/manual/reference/method/db.serverStatus/#db.serverStatus
[Center 93]: /images/20220715/c0df32d539b24ae3863b5c99bb0b335e.png
[Center 94]: /images/20220715/1c31b7b668354d96bb1fc2caf03c5f7c.png
[Center 95]: /images/20220715/ebb936ee113244c4b4c9f8b4f779d54b.png
[Center 96]: /images/20220715/cd57a1420e8b4649b481f5681ad47757.png
[Center 97]: /images/20220715/b6e93a2499154860939a5113ed06110b.png
[Center 98]: /images/20220715/25bde0c19c8b4e3f8c2a85c6d68897c5.png
[Center 99]: /images/20220715/e1503f44f3304415972ff2cce179a0aa.png
[Center 100]: /images/20220715/1d67bb36279f4a21aa6f295197d798d7.png
[Center 101]: /images/20220715/71661efee2724dbdbfd1ed77b5e3b4d2.png
[Center 102]: /images/20220715/2da3e9c00cdb46d8a254cfad4dd207dc.png
[Center 103]: /images/20220715/c5d6bfc166354446be2944cd420cef94.png
[Center 104]: /images/20220715/e39413b7132245488ccab8ab4b9e3bb9.png
[Center 105]: /images/20220715/63ee5af7ccb541d19065c73668b0d861.png
[Center 106]: /images/20220715/be899cbaf3ff4a2099927d8cecac48c9.png
[Center 107]: /images/20220715/a7491a7372fb46a28769ca75d22cc21f.png
[Center 108]: /images/20220715/eead04156b714257bb11fefab7dc7c9e.png
[Center 109]: /images/20220715/20816568655b4688a5f59cf47f4904e9.png
[Center 110]: /images/20220715/1ebd9aa5069445a4a9598917872799be.png
[Center 111]: /images/20220715/d6baaa0d25c84a99b501d993ce55eb7d.png
[Center 112]: /images/20220715/e078fa6387254819aaa124b9c4815df7.png
[Center 113]: /images/20220715/52b43d51888a4732aade07897ef7aa49.png
[Center 114]: /images/20220715/75facbc3bd51451fa6c4d0789bf0c1ab.png
[Center 115]: /images/20220715/7ced2c9b29d34ca59acf7340246298c9.png
[Center 116]: /images/20220715/703e306669a24e89a7a595ec101b8b78.png
[Center 117]: /images/20220715/a45070ed42a44f978895a82e9bc196a7.png
[Center 118]: /images/20220715/df2a20c83d7e425daf499f7f2fa1623d.png
[Center 119]: /images/20220715/26fb53343fb24d059b3770c81b4a067e.png
[https_docs.mongodb.com_manual_reference_program_mongoexport]: https://docs.mongodb.com/manual/reference/program/mongoexport/
[Center 120]: /images/20220715/362e19ca23814f1794925311e38d172a.png
[Center 121]: /images/20220715/7393408956744c0ea223dfea0ff2f41b.png
[Center 122]: /images/20220715/57a25124ad314e888643d4bd391c8fcd.png
[Center 123]: /images/20220715/9b2d931353cd4940841dad46071b15f1.png
[Center 124]: /images/20220715/d0562e7f42924e0fa29fe7084c3c0ecf.png
[Center 125]: /images/20220715/4b64424f9443471580b5adefcf395245.png
[Center 126]: /images/20220715/587f6f70a89743a38bf5260b50ae1c8a.png
[Center 127]: /images/20220715/e8521e7e374745edbcc8bc73d37aff61.png
[Center 128]: /images/20220715/3c00546f43b34753a397780431c020ed.png
[Center 129]: /images/20220715/d757a8681d184b879fc2ccae8079e9c8.png
[Center 130]: /images/20220715/538e40ccbaea4688b238b95e39d34324.png
[Center 131]: /images/20220715/bf435064adff4e66a5076a1183e4339d.png
[Center 132]: /images/20220715/0ae786eed10d4a55875b9ba6115766e0.png
[Center 133]: /images/20220715/108cb9fd64774494838bc0a48ec09b24.png
[Center 134]: /images/20220715/bb76814b8f0d4aa7be4fee07c48b0535.png
[Center 135]: /images/20220715/acd2de83f2c04d5299c8ee48f7e4a753.png
[https_docs.mongodb.com_manual_reference_program_mongodump_bin.mongodump]: https://docs.mongodb.com/manual/reference/program/mongodump/#bin.mongodump
[Center 136]: /images/20220715/5185e95c31484381af4ee2576b54c215.png
[Center 137]: /images/20220715/94b948c2cfac45188919fd115c1865fa.png
[Center 138]: /images/20220715/cd14912b88374862abeefe5905757723.png
[Center 139]: /images/20220715/676ee030284f4830907b8db55b68748f.png
[Center 140]: /images/20220715/f10a57dcdf6c4901ba58cd598c0e8b03.png
[https_docs.mongodb.com_manual_reference_program_mongorestore]: https://docs.mongodb.com/manual/reference/program/mongorestore/
[Center 141]: /images/20220715/6660bfb3d75e4d32831eb9a034275f3d.png
[Center 142]: /images/20220715/b5a018af77a546d29576f93ad4b16737.png
[Center 143]: /images/20220715/b1c204e6b72d4aa09c9bf0b2b49999d1.png
[Center 144]: /images/20220715/9177727594274d598952d38e23ea250e.png
[https_docs.mongodb.com_manual_reference_program_mongostat]: https://docs.mongodb.com/manual/reference/program/mongostat/
[Center 145]: /images/20220715/a6d0eac4b6274924bb9059358ed3f3c7.png
[https_docs.mongodb.com_manual_reference_program_mongotop]: https://docs.mongodb.com/manual/reference/program/mongotop/
[Center 146]: /images/20220715/b8b38258dba547d49a635b280d9b9274.png
[Center 147]: /images/20220715/afd4bca917d44a0ebe3de2bed0f50cd2.png
[Center 148]: /images/20220715/7c29879597784b18b8969c2ba38f7076.png
[Center 149]: /images/20220715/daf45d89ca5e44b3ab3158e8e2f5305a.png
[Center 150]: /images/20220715/2b6dcf49d31a47ce99cd13db830470a7.png
[Center 151]: /images/20220715/b376fcf22fc84cc799fae2186b725e74.png
[Center 152]: https://img-blog.csdn.net/20160905180635313?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 153]: https://img-blog.csdn.net/20160905180639063?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 154]: https://img-blog.csdn.net/20160905180710729?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 155]: /images/20220715/7e8be072259943ed9dfe2edf2138c740.png
[Center 156]: /images/20220715/6b5b9f1efc18485d97a6889fc2b2425d.png
[Center 157]: /images/20220715/7c2c5e2435c94cb88349e08f34a2bbe2.png
[Center 158]: /images/20220715/2b98ca38566445c695c964ae1e5d51b4.png
[Center 159]: /images/20220715/3b969c34a7f543d99be0490d43616980.png
[Center 160]: /images/20220715/4a6e3be3b33e47a18c151ed84895bee1.png
[Center 161]: /images/20220715/d239598d03b34af28b2cf0d0a780b528.png
[Center 162]: /images/20220715/a8639af787174a3a88da232d0dae900a.png
[Center 163]: /images/20220715/9dac17f9e198467cb29519cc9218ace0.png
[Center 164]: /images/20220715/f4a470f2c4174c1fbed9d70fb0c0fafb.png
[Center 165]: /images/20220715/e802859d0dbb4acb9427ff1f32defe24.png
[Center 166]: /images/20220715/f3fe55e4527b4bd08eaa590f69f568af.png
[Center 167]: /images/20220715/f2bad7140bbb4da3b265606ae0d86e41.png
[Center 168]: /images/20220715/d070756c539843efaa7557386203a0e0.png
[https_jira.mongodb.org_browse_SERVER-22731]: https://jira.mongodb.org/browse/SERVER-22731
[Center 169]: /images/20220715/4f6ed16de17b4de68aa04003bf1cf671.png