简介
1.安装准备
系统环境：Centos7.2-redhat release7.2
MongoDB安装包：mongodb-linux-x86_64-rhel70-3.2.8.tgz
下载地址：https://www.mongodb.com/download-center#community
下载MongoDB安装，选择Community Server选项，选中RHEL 7 Linux 64-bit版本下载。
2.解压MongoDB安装包
3.将MongoDB文件夹移动到指定目录下
输入mvmongodb-linux-x86_64-rhel70-3.2.8 /usr/local将mongoDB的文件夹移动到usr/local目录下。
#mv mongodb-linux-x86_64-rhel70-3.2.8 /usr/local
输入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)。
进入到mongodb-rh7目录下输入mkdir –p data命令创建一个data的文件夹。
#mkdir -p data
在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.
更详细的配置请参考官方配置：https://docs.mongodb.com/manual/reference/configuration-options/#core-options
我们采用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文件配置
保存成功后，在bin目录下可看到新建的mongod.conf文件
6.启动MongoDB服务
进入到bin目录下，输入命令./mongod -f mongod.conf启动mongod服务
#./mongod -fmongod.conf #./mongod –f(指定配置文件参数) 配置文件名称
新打开一个窗口，连接服务器，查看启动mongodb的服务和端口，说明已经启动成功.
7.停止MongoDB服务
新建一个窗口，连接服务器，进入到bin目录下，输入命令./mongod -f mongod.conf –shutdown停止mongod服务
#./mongod -fmongod.conf –shutdown
8.客户端连接MongoDB
在bin目录下，输入命令./mongo localhost:27017登录mongodb，登录成功后，查看数据库。
# ./mongo localhost:27017 #./mongo 主机名:端口号
创建一个数据，并在该数据下新建一个collection，在该collections下插入一条数据，插入成功，并且可以查询出来。
9.设置systemd命令自定义开机系统服务
9.1.配置mongodb.service文件
输入命令cd /usr/lib/systemd/system进入到目录下，输入vimongodb.service创建文件
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
保存mongodb.service文件后，需要输入命令进行重新加载.
#systemctl daemon-reload
9.2.Systemd命令操作mongodb服务
#systemctl start mongodb #启动mongodb服务
#systemctl status mongodb #查看mongodb服务状态
#systemctl Stop mongodb #停止mongodb服务
#netstat -ntlp #查看端口
9.3.设置启动/停止开机系统服务
启动开机服务之前，必须要先启动mongodb服务。确认mongodb服务是否开机启动，需要输入systemctl is-enabled mongodb.service的值是否enabled.
#systemctl start mongodb #启动mongodb服务
#systemctl enable mongodb.service #设置开机启动mongodb服务
#systemctl is-enabled mongodb.service #查看mongodb服务是否设置开机启动10.Firewall下设置MongoDB端口
在服务器启动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/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-roles11.2.创建管理员用户
11.2.1.创建超级管理员角色用户
在创建数据库超级管理员用户，必须进入到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'}] }
)
创建成功后，会显示用户信息
输入#db.system.users.find()查看users集合下的所有记录。
11.2.1.1.配置用户认证
创建超级管理员后，使用管理员账户登录前，必须要先在配置mongod.conf文件，启用数据库认证。
进入到mongodb的bin目录下，输入vi mongod.conf命令编辑文件，输入命令。命令如下：
#security:
# authorization: enabled
保存文件成功后需要输入systemctl restart mongodb命令重启mongodb服务。
11.2.1.2. 验证超级管理员权限
在mongodb的bin目录下输入：
#./mongo localhost:27017 #登录远程数据库地址和端口
选择admin数据库进行登录
#use admin #进入到amdin数据库下
#db.auth(‘root’,’root123456’) #.db.auth(用户名，密码)
登录成功后，显示返回值1.
登录成功后，可对任意数据数据库进行操作，例如，插入数据或创建数据库。
11.2.2.创建管理所有数据库角色用户
userAdminAnyDatabase 角色，用来管理所有数据库用户，可以通过这个角色来创建、删除用户。使用该用户进行登录后，可选择指定的数据为该数据库创建相应的用户。
# use admin
#db.createUser({user:'sa',pwd:'sa123456',roles:[{role:'userAdminAnyDatabase',db:'admin'}]})
11.2.3. 创建普通数据库管理员角色用户
#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文件身份认证
进入到mongodb的bin目录下，输入vi mongod.conf命令编辑文件，输入命令。命令如下：
#security:
# authorization: enabled #enabled启用，disabled禁用或者输入#注释掉。
保存文件成功后需要输入systemctl restart mongodb命令重启mongodb服务。
11.4.客户端身份登录
在mongodb的bin目录下输入：
#./mongo localhost:27017 #登录远程数据库地址和端口
#use admin #进入到amdin数据库下
#db.auth(‘root’,’root123456’) #.db.auth(用户名，密码)
登录成功后，显示返回值1.
另外一种方式登录：
远程登录默认的数据库。
# ./mongo --host localhost --port 27017 -usa -p sa123456 --authenticationDatabase admin
# ./mongo --host 数据库地址--port 端口-u 用户名-p 密码--authenticationDatabase默认的数据库。
除了可以设置以上的参数登录，在命令行中输入./mongo –h查看帮助
，参考帮助文档的语法来自定义选不同的字段来进行登录。
11.5.删除用户
进入到admin数据下，输入删除语句
#db.system.users.remove({user:'root'})
#remove({查询条件})
11.6.更改用户密码
使用管理员账户登录后，然后在进入到修改用户密码的所属数据，进入后，输入命令进行密码修改。
#db.changeUserPassword("sa","sa0123456") #db.changeUserPassword(用户名，新密码)
使用密码进行登录。
登录成功后可对集合进行查询。
11.7.获取用户权限
输入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
副本集架构
12.1.1.Mongod.conf文件配置
在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服务器
启动mognodb数据库服务后，选择任意一台mongodb服务器，使用mongo进行登录。
#/mongo 10.190.130..27:27017
12.2.2.定义副本集配置变量
定义副本集变量
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.初始化副本集
初始化副本集rs.initiate(config)
语法结构：
rs.initiate(定义的副本集变量名称)
12.2.4.检查副本集状态
输入rs.status()查看副本集状态。
health：1 //1表明状态是正常，0表明异常
state:1 // 1表明是primary，2表明是slave，即做备份的机器
查看更多状态信息，请参考官方文档：
https://docs.mongodb.com/manual/reference/replica-states/
12.3.测试副本集配置
12.3.1.主节点创建测试数据
使用mongo连接primary数据库，插入10W条数据。
语句如下：
#for(var i=0;i<100000;i++){db.userInfo.insert({"userName":"user"+i,"depart":"towngas","userNo":"no."+i})}
12.3.2.从节点查看同步数据
登录从节点（Secondary Node）数据库后，必须输入rs.slaveOk()后，才能执行查询操作。
输入命令如下：
#./mong 10.190.130.130.28:27017
#use copp
#rs.slaveOk()
#db.userInfo.count()
#db.userInfo.find()
查询第二个从节点（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. 主节点故障后副本集重新选举主节点
将primary的mongodb服务停止后，再查看另外两台服务器的状态。
选择任意一台secondary服务器进行查看副本集状态。显示之前的primary服务器已经停止服务health：0表明异常。而且之前的一台secondary服务器的
stateStr已经成为primary。说明副本集内部选举primary已经成功。
12.3.3.2. 测试新主节点下数据同步
登录新的主节点（primary：10.190.130.79:27017），插入数据成功后，再查看secondary节点同步数据。
登录到从节点（secondary：10.190.130.28:27017）下，查看同步数据，已经跟primary数据一致。
12.3.3.3. 重新启动故障节点
必须先进入到数据库目录下，删除故障节点下数据库文件，然后重新启动之前被停止的主节点
（10.190.130.27:27017），查看状态。显示启动的节点已经成从节点（secondary）。
查看该节点的数据，该节点已经完成数据同步，并且查询数据正常。
12.4.删除副本集成员
连接主节点后，输入rs.remove("10.190.130.27:27017")命令删除从节点后，再输入rs.status()
查看副本集状态，显示删除节点成功，不在显示被删除的从节点信息。
语法结构：
rs.remove(服务器地址和端口号)
从副本集中删除一个节点服务器，更多具体的信息请参考官方文档：
https://docs.mongodb.com/manual/tutorial/remove-replica-set-member/
12.5.添加副本集成员
首先启动要添加到副本集中的节点服务器。该服务器是10.190.130.27:27017
注意：该节点下的配置其它节点的配置是一致的。
连接到主节点服务器（primary：10.190.130.79:27017），下输入rs.add("10.190.130.27:27017")后，添加副本节点成功。
输入rs.status()查看添加一个副本集成功后的副本集状态。
连接新增的副本集服务器，查看数据同步。
12.6.强制成员为主节点
希望某一个从节点成为主节点时，可通过最高优先设置和数据库命令这两种方式，将从节点强制转换为主节点。
12.6.1.使用数据库命令强制一个从节点成为主节点
副本集成员：
10.190.130.27:27017 ---从节点（将该节点转成主节点）
10.190.130.28:27017 ---从节点
10.190.130.79:27017 ---主节点
1.使用mongo连接数据，运行rs.status()确认副本集状态。
2.使用mongo连接10.190.130.28:27017服务器，并输入rs.freeze(120)，表示冻结该服务器，在120秒内不会尝试成为主节点。
3. 使用mongo连接10.190.130.79:27017主节点服务器，并输入rs.stepDown(120)，在120秒内不会尝试成为主节点。
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 ---从节点
1.连接主节点服务器，并查看副本集状态。
2.连接主节点成功后，输入cfg=rs.conf()命令。
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开始的。
4.rs.reconfig(cfg)执行该命令后回去修改配置文件去配置最高优先级成员为主节点。
再执行rs.status()后，之前的主节点状态变成为从节点状态。显示节点3服务器重新连接成功。
5.再次输入rs.status()查看副本集节点，显示10.190.130.28:27017服务器已经成为主节点。
6.登录./mongo10.190.130.28:27017，显示服务器的状态为主节点。
更详细的配置信息请参考官方文档：
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. 垂直扩展价格昂贵
上图中主要有如下所述三个主要组件：
MongosServer（路由服务器）:
Mongos路由服务器是MongoDB中的一个路由进程，它接受所有的用户请求，并分发到每个分片服务器，让后它将聚合各个分片的服务器的结果，返回给客户端。Mongos本身并不持久化数据，Sharded cluster所有的元数据都会存储到Config Server，而用户的数据则会分散存储到各个shard。Mongos启动后，会从config server加载元数据，开始提供服务，将用户的请求正确路由到对应的Shard。
Configservers（配置服务器）:
Config Server是配置服务器，该服务器存储了集群的配置信息：数据和片的对应关系。路由器将根据数据和分片的关系映射，把数据操作分配到特定的分片上。
ShardServer（片服务器）:
用来保存子集合的数据容器。片服务器可以是单个的mongod服务器，也可以是一个副本集。
13.1.分片集群组件
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文件
以下是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服务
以下是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服务器
#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文件
以下是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
13.1.2.2. 配置Systemd命令操作Mongos服务
以下是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
保存的文件名为mongos.service
13.1.2.3. 启动mongos服务器
启动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文件：
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服务
在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服务
输入命令启动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()。
#./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中添加分片数据库
开启数据库分片功能，命令很简单 enablesharding(),这里我就开启copp数据库
#db.runCommand({enablesharding:"copp"}) #开启copp数据库分片
13.4.设置片键
13.4.1.片键
当设置分片时，需要从集合中选择一个或几个键（即集合中的字段），将选择出来的键作为数据拆分的依据，这个键叫做片键。选好片键后，MongoDB将不允许插入没有片键的文档，但是允许不同的文档的片键类型不一样。
指定集合中分片的片键，这里我就指定为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插入数据
配置完分片后，我们将通过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数据
查看10.190.130.29的mongod数据库的记录。
#db.userInfo.count() #查看userInfo集合下所有的记录数量
#db.userInfo.find() #查看userInfo集合下记录
查看10.190.130.30的mongod数据库的记录。
#db.userInfo.count() #查看userInfo集合下所有的记录数量
#db.userInfo.find() #查看userInfo集合下记录
13.7.打印数据库分片信息
官方参考地址：https://docs.mongodb.com/manual/reference/method/js-database/
在mongos数据服务器（10.190.130.80）下，必须进入到admin数据库下，
输入db.runCommand({“listShards”:1})查看所有分片服务器。
#./mongo 10.190.130.80:2080
#use admin
# db.runCommand({"listShards":1})
输入sh.status()或db.printShardingStatus()可以打印状态信息。
13.8.打印服务器信息
登录数据库后在，在admin数据库下输入db.serverStatus()
请参考官方指南：
https://docs.mongodb.com/manual/reference/method/db.serverStatus/#db.serverStatus
13.9.删除分片
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）
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）
如上图所示，集合根据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）
在分片集群中，可以使用标签为分片指定片键(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.分片和副本结合
分片和副本架构
分片和副本集的优点在于可实现高可用和数据负载均衡，并且可以水平扩展数据库服务器。
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分片+副本集的整个过程。
分片+副本集
服务器要求：
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）
启动第一个副本集，并使用rs.status()命令查看当前副本集的状态以及shard服务器信息。
#rs.status() 查看副本集状态信息
启动第2个副本集，并使用rs.status()命令查看当前副本集的状态以及shard服务器信息。
#rs.status() 查看副本集状态信息
15.2.启动config副本集服务器
为了实现高可用性，所以config服务器也进行设计成副本集结构。共有2个config服务器，如果配置config服务器副本，请参考<12.数据库副本集>章节的步骤去配置。
15.2.1.配置config服务器的配置文件
启动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 #定义副本集名称
启动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服务器副本集变量
使用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服务器副本集
使用rs.initiate(config)命令进行初始化副本集，只能初始化一次。
#rs.initiate(config) #初始化副本集，config就是前面定义的副本集的变量名称
15.2.4.查看config副本集状态
初始化副本集成功后，输入rs.status()命令查看副本集的状态。可当前的信息看出，该服务器的状态是主节点。
连接副本集中的secondary节点服务器，显示的状态是secondary。
15.3.启动mongos服务器
由于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地址)
第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服务器中添加数据库分片副本集
连接任意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中添加分片数据库
在mongos服务器中添加1个分片的数据库。
db.runCommand({enablesharding:"copp"})
15.6.在mongos中添加片键
db.runCommand({shardcollection:"copp.userInfo",key:{"userName":1}})
注意：启动第2个mognos服务器,启动成功后，第2个mongos服务器就不需要在添加分片数据库了，因为第一个mongos已经添加分片数据库和片键，
所有这些分片信息都在存储config服务器副本集中，所以第一个mongos和第二个mongos的config服务器信息是一致的。
15.7.测试分片和副本集
15.7.1.通过mongos想mongodb插入数据
在第一个mongos中插入100w条数据。插入成功。
for(vari=0;i<1000000;i++){db.userInfo.insert({"userName":"user"+i,"depart":"towngas","userNo":"no."+i})}
在第二个mongos服务器中查看数据库数据，显示正确。由于第一个mongos和第二个mongos服务器的config服务器是一致的，所以查看的数据是一模一样的。
15.7.2.查看副本集数据
副本1主节点
副本集1中secondary节点。
副本集1中secondary节点
副本集2主节点的数据。
副本集2secondary节点数据量。
副本集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/
命令帮助：./mongoexport --help
16.1.本地导出数据
16.1.1.导出json格式数据
在本地导出copp数据库下的userInfo集合，导出的默认格式是json.
./mongoexport -d copp -c userInfo -o /usr/local/mongodb-rh7/exportFile/copp.userInfo.json
命令格式：
./mongoexport -d 数据库名称-c 集合名称 -o 输出文件的位置和文件名称.json
进入到exportFile目录下输入more copp.userInfo.json命令后，便可查看导出的数据，显示的格式是json格式。
16.1.2.导出csv格式数据
在本地导出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
进入到exportFile目录下输入more copp.userInfo.csv命令后，便可查看导出的数据，显示的格式是csv格式。
16.2.远程导出数据
16.2.1.导出json格式数据
从远程数据库导出数据到本地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
进入到exportDatabaseFile目录下输入more copp.userInfo.json命令后，便可查看导出的数据，显示的格式是json格式
16.2.2.导出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
连接远程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.导入数据库
常见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格式数据
导入命令如下：
./mongoimport -d copp -c userInfo --type json
--file /usr/local/mongodb-rh7/exportDatabaseFile/copp.userInfo.json
命令格式：
./mongoimport -d 数据库名称 -c 集合名称 --type 格式名称 --file 输出文件的位置和文件名称.json
连接数据库，切换到copp数据库下查看userInfo集合的数据。
输入命令以下：
#./mongo localhost:27017
#use copp
#db.userInfo.count()
#db.userInfo.find()
17.1.2.导入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
连接数据库，查看导入到copp数据库下的userInfo集合数据。
输入命令如下：
./mongo localhost
use copp
db.userInfo.count()
db.userInfo.find()
17.2.远程导入数据
17.2.1.导入json格式数据
远程导入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
连接到远程数据库，查询导入数据。
查询命令如下：
#./mongo 192.168.238.132:27017/copp
#db.userInfo.count()
#db.userInfo.find()
17.2.2.导入csv格式数据
远程导入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数据的第一行导入到数据库中，第一行是数据一般都是集合的字段名称。
连接远程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
命令帮助文档：./mongodump --help
#./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集合参数，那么会导出该数据库下所有的集合数据。
进入到dump该目录会有一个文件夹，该文件以数据库名称命令，进入到里面可以看到两个文件一个是bson数据文件，另外一个是元数据文件。
由于bson文件是二进制文件，所以只能使用vi编辑bson文件才能看到里面的内容。
通过 more userInfo.metadata.json可以查看到元数据文件的内容。
连接远程数据库，将copp数据库下所有的集合数据全部导出，并将文件保存到指定的目录
#./mongodump -h 192.168.238.132 --port27017 -d copp -o /usr/local/mongodb-rh7/backup
进入到指定的输出目录下，可查看到导出所有集合的数据文件。
19.还原数据库
使用mongorestore还原二进制文件
-h 远程数据库地址/本地数据库地址
--port 数据库端口号
-d数据库
--dir 还原数据库文件目录
二进制文件不仅可以备份数据，还可以备份索引，而且备份文件比较小，速度快。
需要了解跟多的参数设置，请参考官方帮助文档或者数据库命令的帮助文档：
官方文档地址：https://docs.mongodb.com/manual/reference/program/mongorestore/
命令帮助文档：./mongorestore --help
连接远程或本地数据库后，指定还原数据库文件的目录，将多个集合数据还原到copp数据库中。还原所有集合数据到copp数据库中的命令如下：
#./mongorestore -h 192.168.238.132 --port27017 -d copp
--dir /usr/local/mongodb-rh7/backup/copp
语法结构：
./mongorestore -h 远程数据库地址/本地数据库地址--port 数据库端口号 -d 数据库名称
--dir 还原的数据库文件目录
连接到copp数据库，查看还原到copp数据库下的所有集合数据。
查询命令如下：
#./mongo 192.168.238.132/copp
#show collections
#db.userInfo.count()
#db.companyInfo.count()
#db.companyInfo.find()
#db.userInfo.find()
连接远程数据库还原指定的集合到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数据的目录和文件名称）
连接远程的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/
命令帮助文档：./mongostat --help
连接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/
命令帮助文档：./mongotop --help
输入./mongotop –h 192.168.238.132 –port 27017命令后，可跟踪数据库读写数据的统计，默认情况下，每秒返回一次数据。
22.附录
22.1.键值对格式配置Mongod.conf文件
进入到mongodb的bin目录下，输入命令vi mongod.conf创建配置文件。输入配置信息后，进行保存。
#dbpath=/usr/local/mongodb-rh7/data #表示存储mongodb数据库文件目录
#logpath=/usr/local/mongodb-rh7/log/mongodb.log #表示存储日志文件
#logappend=true #日志是追加模式，false是覆盖模式
在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设置存放日志目录
#. ./mongod --dbpath=/usr/local/mongodb-rh7/data/--logpath=/usr/local/mongodb-rh7/log/mongodb.log
#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的帮助说明
#./mongod –help #查看mongod运行帮助说明
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服务出现以上错误信息时，需要查看日志文件:
#cat /var/log/messages #查看整个messages文件的信息
#cat /var/log/messages #对messages的文件信息进行筛选
22.6.设置MongoDB环境变量
输入命令进行编辑profile文件
#vi /etc/profile.
在文件最后追加上脚本后，进行保存。
#PATH=$PATH:/usr/local/mongodb-rh7/bin
#export PATH
输入# 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();
查看显示数据库操作命令#db.help()
查看用户集合操作命令：db.users.help()
22.9.Q&A
22.9.1.1. Mongos配置正确，但启动mongs服务器失败
原因分析：
Mongos.config文件配置正确，mongos.service配置正确，但是输入systemctlstart mongos命令后，启动失败，提示：
显示超时错误。
输入命令查看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 --permanent--add-port=27017/tcp
#firewall-cmd –reload
#firewall-cmd --list-all
22.9.1.2. 连续添加副本集成员会出现错误？
原因：根据官方的文档说明，添加一个成功后当前会处于secondary。
解决方法：添加一个成员成功后，再从新连接primary数据库服务器添才能加第二个成员。
22.9.1.3. 在secondary节点上查询数据显示错误。
原因：副本集环境下，进入到secondary节点，进行数据查询时，显示错误信息：count failed: { "ok" : 0, "errmsg" : "notmaster and slaveOk=false", "code" : 13435 }？
解决方法：在secondary节点必须先执行rs.slaveOk()语句后，才能进行执行数据查询，否则出错。
22.9.1.4. 重新启动故障主节点后，显示故障的节点的状态为RECOVERING。
原因：由于以前的主节点数据库还有残留数据。
解决方法：启动被停止的主节点服务器之前，先清空启动服务器下的数据文件。
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
解决方法：找了很多资料还是没有找到解决方法，最后，将两个副本集的config服务器停止并删除data文件重新启动，最后可以初始化成功。
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
