NOSQL——mongodb

一、mongodb介绍

1. 之前讲的memcached redis都是属于k-v类型的数据库，而mongodb是文档型数据库。一个json就是一个文档。json类似与一个k-v value里面有多多个数组（k-v对）。关于json http://www.w3school.com.cn/json/index.asp
2. mongodb官网 www.mongodb.com 当前最新版4.0。它是由C++编写，基于分布式的，属于NoSQL的一种。
   在NoSQL中是最像关系型数据库的。
3. MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON对象。字段值可以包含其他文档，数组及文档数组。因为基于分布式，所以MongoDB很容易扩展。

• MongoDB和关系型数据库对比
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QhW65AUW-1575506707699)(http://cxsw.xyz/assets/images/mongodb1.png)]
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GubTT1kS-1575506707700)(http://cxsw.xyz/assets/images/mongodb2.png)])

可以看出MongoDB中的集合相当于MySQL中的表。文档相当于MySQL中的行。文档里面的k-y（域）相当于MySQL中的列（字段）

二、MongoDB安装

epel自带的mongodb版本为2.6，我们需要安装4.0版本
可以参考官方安装文档来下载最新版的: MongoDB https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/

1. 移动到yum.repos.d目录下

[root@zyj02 ~]# cd /etc/yum.repos.d/

2. 创建mongodb-org-4.0库

[root@zyj02 yum.repos.d]# vim mongodb-org-4.0.repo

添加下面内容:
[mongodb-org-4.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.0.asc

3. 查看是否为最新版的源

[root@zyj02 yum.repos.d]# yum list |grep mongodb
mongodb-org.x86_64 4.0.1-1.el7 mongodb-org-4.0
mongodb-org-mongos.x86_64 4.0.1-1.el7 mongodb-org-4.0
mongodb-org-server.x86_64 4.0.1-1.el7 mongodb-org-4.0
mongodb-org-shell.x86_64 4.0.1-1.el7 mongodb-org-4.0
mongodb-org-tools.x86_64 4.0.1-1.el7 mongodb-org-4.0

4. yum下载最新的MongoDB

[root@zyj02 yum.repos.d]# yum install -y mongodb-org

三、连接mongodb

1. 查看并修改mongodb的配置文件

[root@zyj02 ~]# vim /etc/mongod.conf

定义log路径
systemLog: 
destination: file
logAppend: true
path: /var/log/mongodb/mongod.log

定义datadir路径
storage: 
dbPath: /var/lib/mongo
journal:
enabled: true

定义监听IP和端口 多个IP用,分开
net: 
port: 27017
bindIp: 127.0.0.1,192.168.157.130

2. 启动MongoDB服务

[root@zyj02 ~]# systemctl start mongod

3. 连接MongoDB

格式：mongo [--host IP --port 端口]

警告：
2018-08-22T23:06:08.210+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2018-08-22T23:06:08.210+0800 I CONTROL [initandlisten] ** We suggest setting it to 'never'
2018-08-22T23:06:08.210+0800 I CONTROL [initandlisten]
2018-08-22T23:06:08.210+0800 I CONTROL [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2018-08-22T23:06:08.210+0800 I CONTROL [initandlisten] ** We suggest setting it to 'never'
解决：
[root@zyj02 ~]# echo never >> /sys/kernel/mm/transparent_hugepage/enabled
[root@zyj02 ~]# echo never >> /sys/kernel/mm/transparent_hugepage/defrag
[root@zyj02 ~]# systemctl restart mongod

直接使用命令mongo

[root@zyj02 ~]# mongo
MongoDB shell version v4.0.1
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 4.0.1

加上IP和端口号

[root@zyj02 ~]# mongo --host 127.0.0.1 --port 27017
MongoDB shell version v4.0.1
connecting to: mongodb://127.0.0.1:27017/
MongoDB server version: 4.0.1
bash
## 四、MongoDB用户管理
创建用户来登录MongoDB，先进入到admin库里再创建新用户
1. 切换到admin库

格式：`use admin`
```bash
> use admin
switched to db admin

2. 创建新用户

格式：db.createUser( { user: 用户, pwd: 密码, roles: [ { role: 角色", db: “针对的库” } ] } )

> db.createUser( { user: "admin", customData: {description: "superuser"}, pwd: "12341234", roles: [ { role: "root", db: "admin" } ] } )
Successfully added user: {
"user" : "admin",
"customData" : {
"description" : "superuser"
},
"roles" : [
{
"role" : "root",
"db" : "admin"
}
]
}

user指定用户，customData为说明字段，可以省略，pwd为密码，roles指定用户的角色，db指定库名

3. 编辑启动脚本

vim /usr/lib/systemd/system/mongod.service

找到OPTIONS，修改内容如下：

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

4. 重启服务

[root@zyj02 ~]# systemctl daemon-reload
[root@zyj02 ~]# systemctl restart mongod

5. 用户验证登录

格式：mongo -u用户名 -p密码 --authenticationDatabase 登录的数据库

[root@zyj02 ~]# mongo -u 'admin' -p '12341234' --authenticationDatabase "admin"
MongoDB shell version v4.0.1
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 4.0.1

6. 列出当前库下所有用户

格式：show users

> show users
{
"_id" : "admin.admin",
"user" : "admin",
"db" : "admin",
"customData" : {
"description" : "superuser"
},
"roles" : [
{
"role" : "root",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}

7. 列出所有用户，须切换admin库下使用

格式：db.system.users.find()

> use admin ##切换到admin库下
switched to db admin

> db.system.users.find() 
{ "_id" : "admin.admin", "user" : "admin", "db" : "admin", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "AH6WtMoX2KTU2+XqkHAUsA==", "storedKey" : "pqgYQv1TAWdqeIcu3NTrTS3TxGw=", "serverKey" : "DjF/zdOrcVwwogJMIRwgdDbyIJY=" }, "SCRAM-SHA-256" : { "iterationCount" : 15000, "salt" : "RNLMzq80VCtbb5AGM2H7X1FP6Wb6HQRYnCHbhQ==", "storedKey" : "ezXm0EB3lmKgCG/5O7U9N9HtC0VyEx5z+2lQVC0yRYs=", "serverKey" : "YZdZ5grEw01W/bA6/mn49rg9g9+YpKCYWquugutB3cs=" } }, "customData" : { "description" : "superuser" }, "roles" : [ { "role" : "root", "db" : "admin" } ] }

8. 删除用户

格式：db.dropUser('用户名')

> db.createUser({user:"test1",pwd:"12341234",roles:[{role:"read",db:"db1"}]}) ##创建了一个test1针对db1库的新用户 
Successfully added user: {
"user" : "test1",
"roles" : [
{
"role" : "read",
"db" : "db1"
}
]
}

> db.dropUser('test1')
true

9. 命令行来验证用户身份

格式：db.auth("用户", "密码")

## 切换到db1，没有该库会自动创建
> use db1
switched to db db1
## 创建tes1用户 对db1库读写，对db2库只读
> db.createUser( { user: "test1", pwd: "123aaa", roles: [ { role: "readWrite", db: "db1" }, {role: "read", db: "db2" } ] } )
Successfully added user: {
"user" : "test1",
"roles" : [
{
"role" : "readWrite",
"db" : "db1"
},
{
"role" : "read",
"db" : "db2"
}
]
}
## 验证身份
> db.auth("test1", "123aaa")
##验证身份后test1用户才可以去db2来创建数据

• MongoDB用户角色参数含义

参数	含义
Read	允许用户读取指定数据库
readWrite	允许用户读写指定数据库
dbAdmin	允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile
userAdmin	允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户
clusterAdmin	只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限
readAnyDatabase	只在admin数据库中可用，赋予用户所有数据库的读权限
readWriteAnyDatabase	只在admin数据库中可用，赋予用户所有数据库的读写权限
userAdminAnyDatabase	只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
dbAdminAnyDatabase	只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限
root	只在admin数据库中可用。超级账号，超级权限

五、mongodb创建集合、数据管理

1. 创建集合

格式：db.createCollection(name,options)

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

name就是集合的名字，options可选，用来配置集合的参数，参数如下

capped true/false（可选）如果为true，则启用封顶集合。封顶集合是固定大小的集合，当它达到其最大大小，会自动覆盖最早的条目。如果指定true，则也需要指定尺寸参数。

autoindexID true/false （可选）如果为tue，自动创建索引_id字段的默认值是false。

size（可选）指定最大大小字节封顶集合。如果封顶如果是

true，那么你还需要指定这个字段。单位B

max （可选）指定封顶集合允许在文件的最大数量。

2. 查看集合

格式：show tables 或者 show collections

> show tables
mycol
> show collections
mycol

3. 添加文档

格式：db.集合名.insert({key:value,...})

> db.mycol1.insert({AccountID:1,UserName:"123",password:"123456"})
WriteResult({ "nInserted" : 1 }) ##如果集合不存在，直接插入数据，则mongodb会自动创建集合

4. 更新文档

格式：`db.mycol1.update({key:value},{"$set":{key:value}})`
```bash
> db.mycol1.update({"AccountID":1},{"$set":{"Age":20}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

5. 查看所有文档

格式：db.集合名.find()

> db.mycol1.find()
{ "_id" : ObjectId("5b7ec28cae8406dfc4ee5bb1"), "AccountID" : 1, "UserName" : "123", "password" : "123456" }

4. 根据条件查询文档

格式：db.集合名.find({key:value})

> db.mycol1.find({"password" : "123456"}) ##查询密码为123456的文档
{ "_id" : ObjectId("5b7ec28cae8406dfc4ee5bb1"), "AccountID" : 1, "UserName" : "123", "password" : "123456" }

5. 根据条件删除文档

格式：db.集合名.remove({key:value})

> db.mycol1.remove({AccountID:1}) ##删除AccountID是1的文档
WriteResult({ "nRemoved" : 1 })

6. 删除该集合

格式：db.集合名.drop()

> db.mycol1.drop()
true
> show tables ##mycol1集合没有了
mycol

7. 查看所有集合的状态

格式：db.printCollectionStats()

> db.printCollectionStats() 
mycol
{
"ns" : "db1.mycol",
"size" : 80,
"count" : 1,
"avgObjSize" : 80,
"storageSize" : 16384,
"capped" : true,
"max" : 10000,
"maxSize" : 6142976,
"sleepCount" : 0,
"sleepMS" : 0,
"wiredTiger" : {
"metadata" : {
"formatVersion" : 1
},

8. 查看版本

格式：db.version()

> db.version()
4.0.1

9. 切换数据库 不存在会自动创建该库

格式：use 数据库

> use db2
switched to db db2

10 .列出所有数据库

格式：show dbs

> show dbs
db1 0.000GB

11. 查看当前库的信息

格式：db.stats()

> db.stats()
{
"db" : "db1",
"collections" : 1,
"views" : 0,
"objects" : 1,
"avgObjSize" : 80,
"dataSize" : 80,
"storageSize" : 16384,
"numExtents" : 0,
"indexes" : 1,
"indexSize" : 16384,
"fsUsedSize" : 6458290176,
"fsTotalSize" : 19102957568,
"ok" : 1
}

11. 删除当前库 使用root角色登录

格式：db.dropDatabase()

> use db2
switched to db db2
> db.dropDatabase()
{ "ok" : 1 }

12. 查看MongoDB服务器状态 使用root角色登录

格式：db.serverStatus()

> db.serverStatus() 
{
"host" : "zyj02",
"version" : "4.0.1",
"process" : "mongod",
"pid" : NumberLong(1494),
"uptime" : 7621,
"uptimeMillis" : NumberLong(7620755),
"uptimeEstimate" : NumberLong(7620),
"localTime" : ISODate("2018-08-23T15:01:27.002Z"),
"asserts" : {
"regular" : 0,
"warning" : 0,
"msg" : 0,
"user" : 38,
"rollovers" : 0
},

六、PHP的mongodb扩展

php要连接MongoDB是需要安装模块的，和memcached,redis一样。但MongoDB的模块有两个，一个是mongodb.so，另一个是mongo.so。两个的区别是mongo.so是旧版本，只支持php5版本。mongodb.so会逐步代替mongo.so。参考文档 https://docs.mongodb.com/ecosystem/drivers/php/
这里安装mongodb.so有两个途径，一是去官方下载源码包，另一种是去github上克隆mongodb的库到本地来下载。

• 源码包安装

1. 进入src目录下载源码包并解压

[root@zyj02 src]# cd /usr/local/src/
[root@zyj02 src]# wget https://pecl.php.net/get/mongodb-1.3.0.tgz
[root@zyj02 src]# tar zxvf mongodb-1.3.0.tgz

2. 进入mongodb目录并生成configure

[root@zyj02 src]# cd mongodb-1.3.0
[root@zyj02 mongodb-1.3.0]# /usr/local/php-fpm/bin/phpize
Configuring for:
PHP Api Version: 20160303
Zend Module Api No: 20160303
Zend Extension Api No: 320160303

3. 初始化

[root@zyj02 mongodb-1.3.0]# ./configure --with-php-config=/usr/local/php-fpm/bin/php-config

4. 安装编译

[root@zyj02 mongodb-1.3.0]# make
[root@zyj02 mongodb-1.3.0]# make install

5. 加载扩张模块

[root@zyj02 mongodb-1.3.0]# vim /usr/local/php-fpm/etc/php.ini
添加如下内容：
extension=mongodb.so

6. 查看是否加载成功

[root@zyj02 mongodb-1.3.0]# /usr/local/php-fpm/bin/php -m |grep mongodb
mongodb

7. 重启php服务

[root@zyj02 mongodb-1.3.0]# service php-fpm restart

• 使用GitHub的MongoDB库来下载

1. 进入src目录克隆MongoDB仓库

[root@zyj02 mongodb-1.3.0]# cd /usr/local/src/
[root@zyj02 src]# git clone https://github.com/mongodb/mongo-php-driver

2. 进入改仓库目录下

[root@zyj02 src]# cd mongo-php-driver/

3. 更新模块

[root@zyj02 mongo-php-driver]# git submodule update --init

后面和第一种方法的第二个步骤起一样

七、PHP的mongo扩展

1. 进入src目录下载安装包并解压

[root@zyj01 mongo-php-driver]# cd /usr/local/src/
[root@zyj01 src]# wget https://pecl.php.net/get/mongo-1.6.16.tgz
[root@zyj01 src]# tar zxvf mongo-1.6.16.tgz

2. 进入mongo目录并生成configure

[root@zyj01 src]# cd mongo-1.6.16
[root@zyj01 mongo-1.6.16]# /usr/local/php-fpm/bin/phpize

3.初始化

[root@zyj01 mongo-1.6.16]# ./configure --with-php-config=/usr/local/php-fpm/bin/php-config

4. 安装编译

[root@zyj01 mongo-1.6.16]# make
[root@zyj01 mongo-1.6.16]# make install

5.加载扩张模块

[root@zyj01 mongo-1.6.16]# vim /usr/local/php/etc/php.ini
添加内容如下：
extension=mongo.so

6. 查看是否加载成功

[root@zyj01 mongo-1.6.16]# /usr/local/php/bin/php -m |grep mongo
mongo

使用Apache不需要重启PHP服务

• 测试

1. 编辑下面代码 下面代码中的函数只时候在mongo.so中测试。

参考文档 http://www.runoob.com/mongodb/mongodb-php.html

[root@zyj01 mongo-1.6.16]# vim /var/www/test1.com/mongo.php
内容如下：
<?php
$m = new MongoClient(); // 连接
$db = $m->test; // 获取名称为 "test" 的数据库
$collection = $db->createCollection("runoob");
echo "集合创建成功";
?>

[root@zyj01 ~]# curl localhost/mongo.php

2. 集合创建成功
3. 进入mongo看看是否创建了runoob集合

[root@zyj01 ~]# mongo
> use test
switched to db test
> show tables
runoob

八、mongodb副本集介绍

1. mongodb早期版本是使用master-slave，一主一从和MySQL类似，但slave在此架构中为只读，当主库宕机后，从库不能自动切换为主。
2. 目前已经淘汰master-slave模式，改为副本集，这种模式下有一个主(primary)，和多个从(secondary)，只读。支持给它们设置权重，当主宕掉后，权重最高的从切换为主。在此架构中还可以建立一个仲裁(arbiter)的角色，它只负责裁决，而不存储数据。主要让它来判断谁来替代主，防止脑裂。
3. 在此架构中读写数据都是在主上，要想实现负载均衡的目的需要手动指定读库的目标server。
4. mongodb副本集类似于MySQL主从，MySQL主从主宕机后要手动配置，mongodb副本集主宕机后从会自动顶上。

九、MongoDB副本集搭建

主：zyj01 192.168.157.128 primary

从：zyj02 192.168.157.130 secondary

从：zyj03 192.168.157.132 secondary

1. 三台机器安装好MongoDB并编辑配置文件

[root@zyj01 ~]# vim /etc/mongod.conf
修改下面参数
bindIp: 127.0.0.1,192.168.157.128
replication:
oplogSizeMB: 20
replSetName: zyj

bindIp后面添加本机内网ip,用逗号分开
oplogSizeMB定义oplog大小 前面空两格
replSetName定义副本集名字 前面空两格

2. 三台机器启动MongoDB服务

[root@zyj03 mongodb 4.0]# systemctl start mongod
bash
3. 在主上连接MongoDB
```bash
[root@zyj01 ~]# mongo

4. 配置副本集的数据

> config={_id:"zyj",members:[{_id:0,host:"192.168.157.128:27017"},{_id:1,host:"192.168.157.130:27017"},{_id:2,host:"192.168.157.132:27017"}]}

5. 初始化数据

> rs.initiate(config)

6. 查看副本集

格式：rs.status()

>rs.status()
{
"set" : "zyj",
"date" : ISODate("2018-08-25T16:19:06.348Z"),
"myState" : 1,
"term" : NumberLong(1),
"syncingTo" : "",

十、mongodb副本集测试

1. 在主上建库并建立集合

zyj:PRIMARY> use dbtest ##建立dbtest库
zyj:PRIMARY> db.test.insert({AccountID:1,UserName:"123",password:"123456"}) ##创建test集合

2. 现在去从上登录MongoDB并查看是否有该库和集合

zyj:SECONDARY> show dbs
"errmsg" : "not master and slaveOk=false", ##显示slaveOk=false的错误
输入rs.slaveOk()
zyj:SECONDARY> rs.slaveOk()
zyj:SECONDARY> show dbs
admin 0.000GB
config 0.000GB
dbtest 0.000GB
local 0.000GB
test 0.000GB

3. 从库上以有主库上的数据，说明副本集搭建成功

zyj:SECONDARY> use dbtest
switched to db dbtest
zyj:SECONDARY> show tables
test

4. 副本集更改权重模拟主宕机
   在刚刚配置完副本集时所有机器的权重都是1，我们可以设置权重最高的为主，还能够让主宕机后，第二高的权重来顶替主
   在主机器上登录MongoDB
   添加下面命令

zyj:PRIMARY> cfg = rs.conf()
zyj:PRIMARY> cfg.members[0].priority = 3 
zyj:PRIMARY> cfg.members[1].priority = 2
zyj:PRIMARY> cfg.members[2].priority = 1
zyj:PRIMARY> rs.reconfig(cfg) ##初始化数据

5. 查看权重

格式：rs.conf()
现在zyj01权重是3，zyj01权重是2，zyj03权重是1

zyj:PRIMARY> cfg
{
"_id" : "zyj",
"version" : 2,
"protocolVersion" : NumberLong(1),
"writeConcernMajorityJournalDefault" : true,
"members" : [
{
"_id" : 0,
"host" : "192.168.157.128:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 3,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "192.168.157.130:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 2,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "192.168.157.132:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : false,
"priority" : 1,
"tags" : {
},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],

6. 模拟主zyj01宕机看看主是否切换到zyj02上

[root@zyj01 ~]# iptables -I INPUT -p tcp --dport 27017 -j DROP

7. 回去zyj02上发现变为了主

zyj:PRIMARY>

十一、MongoDB分片介绍

1. 分片就是将数据库进行拆分，将大型集合分隔到不同服务器上。比如，本来100G的数据，可以分割成10份存储到10台服务器上，这样每台机器只有10G的数据。

2. 通过一个mongos的进程（路由）实现分片后的数据存储与访问，也就是说mongos是整个分片架构的核心，对客户端而言是不知道是否有分片的，客户端只需要把读写操作转达给mongos即可。

3. 虽然分片会把数据分隔到很多台服务器上，但是每一个节点都是需要有一个备用角色的，这样能保证数据的高可用。

4. 当系统需要更多空间或者资源的时候，分片可以让我们按需方便扩展，只需要把mongodb服务的机器加入到分片集群中即可。

5. mongos: 数据库集群请求的入口，所有的请求都通过mongos进行协调，不需要在应用程序添加一个路由选择器，mongos自己就是一个请求分发中心，它负责把对应的数据请求请求转发到对应的shard服务器上。在生产环境通常有多mongos作为请求的入口，防止其中一个挂掉所有的mongodb请求都没有办法操作。

6. config server: 配置服务器，存储所有数据库元信息（路由、分片）的配置。mongos本身没有物理存储分片服务器和数据路由信息，只是缓存在内存里，配置服务器则实际存储这些数据。mongos第一次启动或者关掉重启就会从 config server 加载配置信息，以后如果配置服务器信息变化会通知到所有的 mongos 更新自己的状态，这样 mongos 就能继续准确路由。在生产环境通常有多个 config server 配置服务器，因为它存储了分片路由的元数据，防止数据丢失！

7. shard: 存储了一个集合部分数据的MongoDB实例，每个分片是单独的mongodb服务或者副本集，在生产环境中，所有的分片都应该是副本集。

分片就是把数据进行拆分，分片的下级就是副本集。分片中三个成员，mongos请求入口，把请求分发给shard上。config server存储配置数据。shard存储MongoDB实例的数据。为了安全三者都应该作副本集。

十二 、mongodb分片搭建

• 服务器规划

三台机器zyj01(192.168.157.128) zyj02(192.168.157.130) zyj03(192.168.157.132)
zyj01搭建：mongos、config server、副本集1主节点、副本集2仲裁、副本集3从节点
zyj02搭建：mongos、config server、副本集1从节点、副本集2主节点、副本集3仲裁
zyj03搭建：mongos、config server、副本集1仲裁、副本集2从节点、副本集3主节点
端口分配：mongos 20000、config 21000、副本集1 27001、副本集2 27002、副本集3 27003
三台机器全部关闭firewalld服务和selinux，或者增加对应端口的规则

1. 三台机器上各自创建下面目录

[root@zyj01 ~]# mkdir -p /data/mongodb/mongos/log
[root@zyj01 ~]# mkdir -p /data/mongodb/config/{data,log}
[root@zyj01 ~]# mkdir -p /data/mongodb/shard1/{data,log}
[root@zyj01 ~]# mkdir -p /data/mongodb/shard2/{data,log}
[root@zyj01 ~]# mkdir -p /data/mongodb/shard3/{data,log}

2. 配置config server
   三台机器上都做下面操作
   创建monogd目录

[root@zyj01 ~]# mkdir /etc/mongod/

3.创建config.conf配置文件

[root@zyj01 ~]# vim /etc/mongod/config.conf
添加下面参数
pidfilepath = /var/run/mongodb/configsrv.pid
dbpath = /data/mongodb/config/data
logpath = /data/mongodb/config/log/congigsrv.log
logappend = true
bind_ip = 192.168.157.128 ##0.0.0.0可以监听全网ip,不完全
port = 21000
fork = true
configsvr = true #declare this is a config db of a cluster;
replSet=configs #副本集名称
maxConns=20000 #设置最大连接数

3. 启动config server服务

[root@zyj01 ~]# mongod -f /etc/mongod/config.conf
[root@zyj01 ~]# netstat -lntp |grep mongo ##查看是否监听21000
tcp 0 0 192.168.157.128:21000 0.0.0.0:* LISTEN 1427/mongod

4. 在任意一台机器上登录mongodb的21000端口

[root@zyj01 ~]# mongo --host 192.168.157.128 --port 21000

5. 建立config server的副本集

> config = { _id: "configs", members: [ {_id : 0, host : "192.168.157.128:21000"},{_id : 1, host : "192.168.157.130:21000"},{_id : 2, host : "192.168.157.132:21000"}] }

6. 初始化数据

> rs.initiate(config)

7. 配置三个节点shard
   三台机器上都做下面操作
   分别创建shard1.conf shard2.conf shard3.conf 配置文件

[root@zyj01 ~]# vim /etc/mongod/shard1.conf
pidfilepath = /var/run/mongodb/shard1.pid
dbpath = /data/mongodb/shard1/data
logpath = /data/mongodb/shard1/log/shard1.log
logappend = true
bind_ip = 192.168.157.128
port = 27001
fork = true
replSet=shard1 #副本集名称
shardsvr = true #declare this is a shard db of a cluster;
maxConns=20000 #设置最大连接数

[root@zyj01 ~]# vim /etc/mongod/shard2.conf
添加下面参数
pidfilepath = /var/run/mongodb/shard2.pid
dbpath = /data/mongodb/shard2/data
logpath = /data/mongodb/shard2/log/shard2.log
logappend = true
bind_ip = 192.168.157.128
port = 27002
fork = true
replSet=shard2 #副本集名称
shardsvr = true #declare this is a shard db of a cluster;
maxConns=20000 #设置最大连接数

[root@zyj01 ~]# vim /etc/mongod/shard3.conf
添加下面参数
pidfilepath = /var/run/mongodb/shard3.pid
dbpath = /data/mongodb/shard3/data
logpath = /data/mongodb/shard3/log/shard3.log
logappend = true
bind_ip = 192.168.157.128
port = 27003
fork = true
replSet=shard3 #副本集名称
shardsvr = true #declare this is a shard db of a cluster;
maxConns=20000 #设置最大连接数

8. 启动shard1服务
   三台机器上都要操作

[root@zyj01 ~]# mongod -f /etc/mongod/shard1.conf

9. 在zyj01上登录登录mongodb

[root@zyj01 ~]# mongo --host 192.168.157.128 --port 27001

10. 建立shard1的副本集
    zyj01为主节点 zyj02为从节点 zyj03为仲裁

> use admin
> config = { _id: "shard1", members: [ {_id : 0, host : "192.168.157.128:27001"}, {_id: 1,host : "192.168.157.130:27001"},{_id : 2, host : "192.168.157.132:27001",arbiterOnly:true}] }
> rs.initiate(config)

11.启动shard2服务
三台机器上都要操作

[root@zyj01 ~]# mongod -f /etc/mongod/shard2.conf

12. 在zyj02上登录登录mongodb

[root@zyj02 ~]# mongo --host 192.168.157.130 --port 27002

13. 建立shard2的副本集
    zyj01为仲裁 zyj02为主节点 zyj03为从节点

> use admin
> config = { _id: "shard2", members: [ {_id : 0, host : "192.168.157.128:27002" ,arbiterOnly:true},{_id : 1, host : "192.168.157.130:27002"},{_id : 2, host : "192.168.157.132:27002"}] }
>rs.initiate(config)

14. 启动shard3服务
    三台机器上都要操作

[root@zyj01 ~]# mongod -f /etc/mongod/shard3.conf

15. 在zyj03上登录登录mongodb

[root@zyj03 ~]# mongo --host 192.168.157.132 --port 27003

16.建立shard3的副本集
zyj01为从节点 zyj02为仲裁 zyj03为主节点

>use admin
> config = { _id: "shard3", members: [ {_id : 0, host : "192.168.157.128:27003"}, {_id : 1, host : "192.168.157.130:27003", arbiterOnly:true}, {_id : 2, host : "192.168.157.132:27003"}] }
> rs.initiate(config)

17. 配置mongos
    三台机器上都做下面操作
    创建mongos.conf配置文件

vim /etc/mongod/mongos.conf
添加下面参数
pidfilepath = /var/run/mongodb/mongos.pid
logpath = /data/mongodb/mongos/log/mongos.log
logappend = true
bind_ip = 192.168.157.128
port = 20000
fork = true
configdb = configs/192.168.157.128:21000,192.168.157.130:21000,192.168.157.132:21000 #监听的配置服务器,只能有1>个或>者3个，configs为配置服务器的副本集名字
maxConns=20000 #设置最大连接数

启动mongos服务

[root@zyj01 ~]# mongos -f /etc/mongod/mongos.conf

在任意一台机器上登录mongodb的20000端口

[root@zyj01 ~]# mongo --host 192.168.157.128 --port 20000

18. 串联所有分片和路由

mongos> sh.addShard("shard1/192.168.157.128:27001,192.168.157.130:27001,192.168.157.132:27001")
mongos> sh.addShard("shard2/192.168.157.128:27002,192.168.157.130:27002,192.168.157.132:27002")
mongos> sh.addShard("shard3/192.168.157.128:27003,192.168.157.130:27003,192.168.157.132:27003")

19. 查看分片状态

格式：sh.status()

mongos> sh.status()
--- Sharding Status ---
sharding version: {
"_id" : 1,
"minCompatibleVersion" : 5,
"currentVersion" : 6,
"clusterId" : ObjectId("5b82b1cd6b7dc181df5c330a")
}
shards:
{ "_id" : "shard1", "host" : "shard1/192.168.157.128:27001,192.168.157.130:27001", "state" : 1 }
{ "_id" : "shard2", "host" : "shard2/192.168.157.130:27002,192.168.157.132:27002", "state" : 1 }
{ "_id" : "shard3", "host" : "shard3/192.168.157.128:27003,192.168.157.132:27003", "state" : 1 }

十三、mongodb分片测试

建立数据在分片中，看看是否平均分配至各个节点（分片）中

1. 登录任何一台20000端口

[root@zyj01 ~]# mongo --host 192.168.157.128 --port 20000
mongos> use admin

2. 指定要分片的数据库

mongos> sh.enableSharding("testdb")

3. 指定数据库里需要分片的集合和片键

mongos> sh.shardCollection("testdb.table1",{"id":1} )

4. 插入数据

mongos> use testdb
mongos> for (var i = 1; i <= 10000; i++) db.table1.save({id:i,"test1":"testval1"})

5. 再查看多个数据库和数据

mongos> sh.enableSharding("test2")
mongos> sh.shardCollection("test2.test2",{"id":1} )
mongos> sh.enableSharding("test3")
mongos> sh.shardCollection("test3.test3",{"id":1} )

6. 查看分片情况

mongos> sh.status()

或者

db.table1.stats() ##查看tablesz状态

十四、mongodb备份恢复

1. 备份指定库

格式：mongodump --host IP地址 --port 端口 -d 指定备份的库 -o 备份到的目录

[root@zyj01 ~]# mongodump --host 192.168.157.128 --port 20000 -d testdb -o /tmp/mongodbbak

其中备份后的目录中会生成要备份指定库的目录，库的目录中会有该库中集合的数据，每个集合都会有两个文件，其中bson文件是真正的数据。json文件是可以查看的数据。

[root@zyj01 ~]# ls /tmp/mongodbbak/
testdb
[root@zyj01 ~]# ls /tmp/mongodbbak/testdb/
table1.bson table1.metadata.json

2. 备份所有库

格式：mongodump --host IP地址 --port 端口 -o 备份到的目录

[root@zyj01 ~]# mongodump --host 192.168.157.128 --port 20000 -o /tmp/mongodbbak1

3. 备份指定集合

格式：mongodump --host IP地址 --port 端口 -d 指定备份的库 -c 指定备份的库 -o 备份到的目录

[root@zyj01 ~]# mongodump --host 192.168.157.128 --port 20000 -d testdb -c table1 -o /tmp/mongodbbak3

4. 备份指定集合为json文件

格式：mongoexport --host IP地址 --port 端口 -d 指定备份的库 -c 指定备份的库 -o 备份为的json文件

[root@zyj01 ~]# mongoexport --host 192.168.157.128 --port 20000 -d testdb -c table1 -o /tmp/table.json

5. 恢复所有库

格式：mongorestore --host IP地址 --port 端口 [--drop] 备份好的目录

[root@zyj01 ~]# mongorestore --host 192.168.157.128 --port 20000 /tmp/mongodbbak1/

–drop可选，意思是当恢复之前先把之前的数据删除，不建议使用

6. 恢复指定库

格式：mongorestore --host IP地址 --port 端口 -d 指定恢复的库 备份好的库目录

[root@zyj01 ~]# mongorestore --host 192.168.157.128 --port 20000 -d testdb /tmp/mongodbbak1/testdb/

7. 恢复指定集合

格式：mongorestore --host IP地址 --port 端口 -d 指定恢复的库 -c 指定恢复的集合 备份好的目录中的bson文件

[root@zyj01 ~]# mongorestore --host 192.168.157.128 --port 20000 -d testdb -c table1 /tmp/mongodbbak1/testdb/table1.bson

8. 使用json文件来恢复集合

格式：mongoimport --host IP地址 --port 端口 -d 指定恢复的库 -c 指定恢复的集合 --file 指定备份好的json文件

[root@zyj01 ~]# mongoimport --host 192.168.157.128 --port 20000 -d testdb -c table1 --file /tmp/table.json