MongoDB快速上手

MongoDB快速上手

MongoDB用起来-快速上手&集群和安全系列

课程目标：

• 理解MongoDB的业务场景、熟悉MongoDB的简介、特点和体系结构、数据类型等
• 能够在windows和linux下安装和启动MongoDB、图形化管理界面Compass的安装使用
• 掌握MongoDB基本常用命令实现数据的CRUD
• 掌握MongoDB的索引类型、索引管理、执行计划
• 使用Spring Data MongoDB完成文章评论业务的开发

一.MongoDB相关概念

1.1业务应用场景

传统的关系型数据库（如Mysql），在数据操作的“三高”需求以及应对web2.0的网站需求面前，显得力不从心，。

解释： “三高”解释：

• High performance:对数据库高并发读写的需求
• Huge Storage: 对海量数据的高效率存储和访问的需求
• High Scalability && High Avaliability:对数据库的高拓展性和高可用性的需求

而MongoDB可应对“三高”需求

具体的应用场景：

• 社交的应用场景，使用MongoDB存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能。
• 游戏场景，使用MongoDB存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便从哈寻高效率存储和访问。
• 物流场景，使用MongoDB存储订单信息，订单状态在运送过程中会不断更新，以MongoDB内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
• 物联网场景，使用MongoDB存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析。
• 视频直播，使用MongoDB存储用户信息、点赞互动信息等。

这些应用场景中，数据操作方面的共同特点是：

• 数据量大
• 写入操作频繁（读写都很频繁）
• 价值较低的数据，事务性要求不高

对于这样的数据，我们更适合使用MongoDB来实现数据的存储

什么时候选择MongoDB？

在架构选型上，除了上述的三个特点外，如果你还有序是否要选择它？可以考虑以下的一些问题：

• 应用不需要事务以及复杂的join支持
• 新应用，需求会变，数据库模型无法确定，想快速迭代开发
• 应用需要2000-3000以上的读写QPS(更高也可以)
• 应用需要TB甚至PB级别数据存储
• 应用发展迅速，需要能快速水平拓展
• 应用要求存储的数据不丢失
• 应用需要99.999%高可用
• 应用需要大量的地理位置查询、文本查询

如果上述有1个符合，可以考虑MongoDB，2个以及以上的符合，选择MongoDB绝不会后悔

思考：如果用Mysql呢？

答： 相对Mysql，可以以更低的成本解决问题（包括学习、开发、运维等成本）

1.2MongoDB简介

MongoDB是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便拓展，是Nosql数据库产品中的一种。是最像关系型数据库（Mysql）的非关系型数据库。

它支持的数据结构非常松散，是类似JSON的BSON格式，所以它既可以存储比较复杂的数据类型，又相当的灵活。

MongoDB中的记录是一个文档，它是一个由字段和值对组成的数据结构，MongoDb文档类似于JSON对象，即一个文档认为就是一个对象，字段的数据类型是字符型，它的值除了使用基本的一些类型外，还可以包括其他文档、普通数组和文档数组。

1.2.1体系结构

Mysql和mongoDB对比

1.2.2数据模型

MongoDB的最小存储单元就是文档对象。文档对象对应于惯性数据库的行，数据在MongoDB中以BSON(Binary-JSON)文档的格式存储在磁盘上。

BSON是一种类JSON的一种二进制形式的存储格式，简称Binary JSON。BSON和JSON一样，支持内嵌的文档对象和数组对象，但是BSON由JSON没有的一些数据类类型，如Date和BinData类型。

BSON采用了类似于C语言结构体的名称、对表示方法，支持内嵌的文档对象和数组对象，具有轻量性、可遍历性、高效性的三个特点，可以有效描述非结构化数据和结构化数据。这种格式的有点是灵活性高，但它的却段是空间利用率不是很理想。

BSON中，除了基本的JSON类型：string,integer,boolean,double,null,array和object，mongoDB还是用了特殊的数据类型。这些类型包括date,object,id,binary,data,regular expression和code,每一个驱动都以特定语言的方式实现了这些类型，查看你的驱动的文档来获取详细信息。

BSON数据类型参考列表：

1.3MongoDB的特点

MongoDB主要有以下特点：

1.高性能

MongoDB提供高性能的数据持久化。特别是，对嵌入式数据模型的支持减少了数据库系统上的I/O活动。

索引支持更快的查询，并且可以包含来自嵌入式文档和数组的建。（文本索引解决搜索的需求，TTL索引解决历史数据自动过期的需求，地理位置索引可用于构建各种020应用）

mmapv1,wiredtiger,mongorocks(rocksdb),in-memory等多引擎支持满足各种场景需求。

2.高可用

MongoDB的复制工具称为副本集，它可提供自动故障转移和数据冗余。

3.高拓展性

MongoDB提供了水平可拓展性作为其核心功能的一部分。

分片将数据分布在一组集群的机器上。（海量数据存储，服务能力水平拓展）

从3.4开始，MongoDB支持基于片键创建数据区域，在一个平衡的集群中，MongoDB将一个区域所有覆盖的读写只定向到该区域内的哪些片。

4.丰富的查询支持

MongoDB支持丰富的额查询语言，支持读和写操作，比如数据聚合、文本搜索和地理空间查询等。

5.其他特点

如无模式（动态模式）、灵活的文本模型。

二、单机部署

2.1window系统中的安装启动

第一步：下载安装包

MongoDB提供了可用于32位和64位系统的预编译二进制包，你可以从MongoDB官网下载安装，MongoDB预编译二进制包下载地址:

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "D:\SOFTWARE\mongodb\data\db"

2.2Shell连接（mongo命令）

在命令提示符输入以下shell命令即可完成登陆

mongo
或
mongo --host=127.0.0.1 --port=27017

查看已经有的数据库

show databases

退出mongodb

exit

更多的参数可以通过帮助查看：

mongodb --help

提示:

MongoDB javasctipt shell是一个基于javascipt的解释器，故事只是js程序的。

2.3Compass图形化界面客户端

2.4Linux系统中的安装启动和连接

配置文件的内容如下：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path:  "/mongodb/single/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/mongodb/single/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定的IP
  bindIp: localhost, 192.168.0.2
  #bindIp
  #绑定的端口
  port: 27017

【补充】

如果一旦是因为数据损坏，则需要进行如下操作（了解）：

1.删除lock文件：

2.修复数据

三、基本常用命令

3.1案例需求

存放文章评论的数据存放到MongoDB中，数据结构参考如下：

数据库：articledb

3.2数据库操作

3.2.1选择和创建数据库

选择和创建数据数据库的语法格式：

use 数据库名称

如果数据库不存在则自动创建，例如，以下语句创建spitdb数据库：

use articledb

查看有权限的所有数据库命令

show dbs
或
show databases

注意：在Mongodb中，集合只有在内容插入后擦胡创建！就是说，创建集合（数据表）后要再插入一个文档（记录），集合才会真正创建。

查看当前正在使用的数据库命令

db

MongoDB中默认的数据库位test,如果你没有选择数据库，集合将存放再test数据库中。

另外；

数据库明可以是满足以下条件的任意UTF-8字符串。

• 不能是空字符串（“”）
• 不得含有’'（空格）、.、$、/、\和\0（空字符）
• 应全部小写
• 最多64字节

有一些数据库名是保留的，可以直接访问这些有特俗作用的数据库。

• admin:从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
• local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合，防止被复制数据可以放在本数据库中。
• config:当MongoDB用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

3.2.2数据库的删除

MongoDB删除数据库的语法格式如下：

db.dropDatabases()

提示：主要用来删除已经持久化的数据库

3.3集合操作

集合，类似关系型数据库中的表。

可以显示的创建，也可以隐式的创建。

3.3.1集合的显示创建（了解）

基本语法格式：

db.createCollection(name)

参数说明：
name:要创建的集合名称
例如：创建一个名为mycollection的普通集合。

db.createCollection("mycollection")

查看当前库中的表：show tables命令

show collections
或
show tables

集合的命名规范：
集合名不能为空字符串“”。
集合名不能含有\0字符（空字符），这个字符表示集合名的结尾。
集合名不能以“system.”开头，这是系统集合预留的前缀。

3.3.2集合的隐式创建

当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。
详见文档的插入章节。
提示：通常我们使用隐式创建文档即可。

3.3.3集合的删除

集合删除语法格式如下：

db.collection.drop()
或
db.集合.drop()

返回值
如果成功删除选定集合，则drop方法返回true，否则返回false.
例如：要删除mycollection集合

db.mycollection.drop()

3.4文档基本CRUD

3.4.1文档的插入

1.当个文档插入
使用insert()或者save()方法向集合中插入文档，语法如下：

db.collection.insert(
    <document or array of documents>,
    {
       writeConcern: <document>,
       ordered: <boolean> 
    }
)

参数：

【示例】
要向comment的集合（表）中插入一条测试数据：

db.comment.insert({"articleid": "100000",  "content":"今天天气真好，阳光明媚", “userid”: "1001", "nickname": "Rose", "createdatetime": new Date(),  "likenum": NumberInt(10), "state": null})

提示：
1.comment集合不存在，则会隐式创建
2.mongo中的数组，默认情况下是double类型,如果要存整型，必须使用函数NumberInt（整型数字），否则取出来就会有问题了。
3.插入当前日期使用 new Date()
4.插入的数据没有指定_id,会自动生成主键值
5.如果某字段没值，可以赋值为null，或不写该字段。
执行后，如下，说明插入一个数据成功了。

注意：

1. 文档中的键/值对是有序的
2. 文档中的值不仅可以使在双引号里面的字符串，还可以使其他几种数据类型（甚至可以是整个嵌入的文档）
3. MongoDB区分类型和大小写
4. MongoDB的文档不能有重复的键
5. 文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符串

文档键命名规范：

• 键不能含有\0（空字符）。这个字符用来表示键的结尾
• .和$有特别的意义，只能在特定环境下才能使用
• 以下划线“_”开头的键是保留的（不是严格要求的）

2.批量插入
语法：

db.collection.insertMany(
     [<document 1>,<document 2>, ...],
     {
          writeConcern: <document>,
          ordered: <boolean>
     }
)

参数：

[示例]
批量插入多条文章评论：

db.comment.insertMany([{
				"_id": "1",
				"articleid": "100001",
				"content": "我们不应该吧清晨浪费在手机上，健康很重要，一杯温水幸福你我她。",
				"userid": "1001",
				"nickname": "相忘于江湖 ",
				"createdatetime": new Date("2019-08-05T22:08:15.522Z"),
				"likenum": NumberInt(1000),
				"state": "1"
			},
			{
				"_id": "2",
				"articleid": "100001",
				"content": "我夏天空腹喝凉开水，冬天喝温开水。",
				"userid": "1002",
				"nickname": "伊人憔悴",
				"createdatetime": new Date("2019-08-05T23:58:51.485Z"),
				"likenum": NumberInt(888),
				"state": "1"
			},
			{
				"_id": "3",
				"articleid": "100001",
				"content": "我一直喝凉开水，冬天夏天都喝。",
				"userid": "1003",
				"nickname": "杰克船长",
				"createdatetime": new Date("2019-08-06T01:05:06.321Z"),
				"likenum": NumberInt(666),
				"state": "1"
			},
			{
				"_id": "4",
				"articleid": "100001",
				"content": "专家说不能空腹吃饭，影响健康。",
				"userid": "1004",
				"nickname": "凯撒",
				"createdatetime": new Date("2019-08-06T08:18:35.288Z"),
				"likenum": NumberInt(2000),
				"state": "1"
			},
			{
				"_id": "5",
				"articleid": "100001",
				"content": "研究表明，刚烧开的说千万不能喝，因为烫嘴。",
				"userid": "1005",
				"nickname": "凯撒",
				"createdatetime": new Date("2019-08-06T11:01:02.521Z"),
				"likenum": NumberInt(3000),
				"state": "1",
			}
		]);

提示：

插入时绑定了_id，则主键就是该值。

如果某条数据插入失败，将会终止插入，但是插入成功的数据不会回滚掉。

因为批量插入由于数据较多容易出现失败，因此，可以使用try-catch进行异常捕获处理，测试的时候可以不处理。如（了解）：

try{
	db.comment.insertMany([{
				"_id": "1",
				"articleid": "100001",
				"content": "我们不应该吧清晨浪费在手机上，健康很重要，一杯温水幸福你我她。",
				"userid": "1001",
				"nickname": "相忘于江湖 ",
				"createdatetime": new Date("2019-08-05T22:08:15.522Z"),
				"likenum": NumberInt(1000),
				"state": "1"
			},
			{
				"_id": "2",
				"articleid": "100001",
				"content": "我夏天空腹喝凉开水，冬天喝温开水。",
				"userid": "1002",
				"nickname": "伊人憔悴",
				"createdatetime": new Date("2019-08-05T23:58:51.485Z"),
				"likenum": NumberInt(888),
				"state": "1"
			},
			{
				"_id": "3",
				"articleid": "100001",
				"content": "我一直喝凉开水，冬天夏天都喝。",
				"userid": "1003",
				"nickname": "杰克船长",
				"createdatetime": new Date("2019-08-06T01:05:06.321Z"),
				"likenum": NumberInt(666),
				"state": "1"
			},
			{
				"_id": "4",
				"articleid": "100001",
				"content": "专家说不能空腹吃饭，影响健康。",
				"userid": "1004",
				"nickname": "凯撒",
				"createdatetime": new Date("2019-08-06T08:18:35.288Z"),
				"likenum": NumberInt(2000),
				"state": "1"
			},
			{
				"_id": "5",
				"articleid": "100001",
				"content": "研究表明，刚烧开的说千万不能喝，因为烫嘴。",
				"userid": "1005",
				"nickname": "凯撒",
				"createdatetime": new Date("2019-08-06T11:01:02.521Z"),
				"likenum": NumberInt(3000),
				"state": "1",
			}
		]);
}catch(e){
    print(e);
}

3.4.2文档

查询数据的语法格式如下：

db.collection.find(<query>, [projection])

参数：

[示例]

1.查询所有

如果我们要查询spit集合的所有文档，我们输入以下命令：

db.comment.find()
或
db.comment.find({})

这里你会发现每条文档会有一个叫_id的字段，这个相当于我们原来关系型数据库中表的主键，当你插入文档记录的时没有指定该字段，MongoDB会自动创建，其类型时ObjectID类型。

如果我们在插入文档记录时指定该字段也是可以，其类型可以是ObjectID类型，也可以是MongoDB支持的任意类型。

如果我们想按一定条件来查询，比如我们想查询userid为1003的记录，怎么办？很简单，只要在find()中添加参数即可，参数也是json格式，如下：

db.comment.find({userid: "1003"})

如果你只需要返回符合条件的第一条数据，我们可以使用findOne命令来实现，语法和find一样。

如：查询用户编号是1003的记录，但最多返回符合条件的第一条记录：

db.comment.findOne({userid: "1003"})

2.投影查询

如果要查询结果返回部分字段，则需要使用投影查询（不显示所有字段，只显示指定的字段）。

如:查询结果只显示_d,userid,nickname:

db.comment.find(
	{userid: "1003"},
	{
	  userid: 1,
	  nickname: 1
	}
)

默认_id会显示。

如：查询结果只显示userid,nickname不显示_id

db.comment.find(
	{userid: "1003"},
	{
	  _id: 0,
	  userid: 1,
	  nickname: 1
	}
)

再例如：查询所有数据，但只显示_id,userid,nickname

db.comment.find(
	{},
	{
	  _id: 0,
	  userid: 1,
	  nickname: 1
	}
)

3.4.3文档的更新

更新文档的语法：

db.collection.update(query, update, options)
或
db.collection.update(<query>, <update>, {
   upsert: <boolean>,
   multi: <boolean>,
   writeConcern: <document>,
   collation: <document>,
   arrayFilters: [<filterdocument1>,...],
   hint: <document|string> //Available starting in MongoDB 4.2 
})

参数：

提示：

主要关注前四个参数即可：

[示例]

1.覆盖的修改

如果我们想修改_id为1的记录，点赞量为1001，输入以下语句：

db.comment.update({_id:"1"}, {
	likenum: NumberInt(1001)
})

执行后，我们会发现，这条文档除了likenum字段其他字段都不见了。

2.局部修改

为了解决这个问题，我们需要使用修改器$set来实现，命令如下：

我们想修改_id为2的记录，浏览量为889，输入以下语句：

db.comment.update({_id:"2"}, {
	$set: {
		likenum: NumberInt(889)
	}
})

这样就OK了。

3.批量的修改

更新所有为1003的用户的昵称为凯撒大帝

//默认只修改第一条数据
db.comment.update({userid: "1003"}, {
	$set: {
		nickname: "凯撒2"
	}
})
//修改所有符合条件的数据
db.comment.update({userid: "1003"}, {
	$set: {
		nickname: "凯撒2"
	}
},{
	multi: true
})

提示：如果不加后面的参数，则只更新符合条件的第一条记录。

3.列值增长的修改

如果我们想实现对某列值在原有的基础上进行增加或减少，可以使用$inc运算符来实现。

需求：对3号数据的点赞数，每次递增1

db.comment.update({_id:"3"}, {
	$inc: {
		likenum: NumberInt(1)
	}
})

3.4.4删除文档

删除文档的语法结构

db.集合名称.remove(条件)

以下语句可以将数据全部删除，请慎用（暂时不做）

db.comment.remove({})

如果删除_id=1的记录，输入以下语句

db.comment.remove({_id: "1"})

3.5文档的分页查询

3.5.1统计查询

统计查询使用count()方法，语法如下：

db.comment.count(query, options)

参数：

提示：

可选项暂时不使用。

[示例]

1.统计所有记录数

统计comment集合的所有的记录数

db.comment.count()

提示:

默认情况下count()方法返回符合条件的全部记录条数。

3.5.2分页列表查询

可以使用limit()方法来读取指定数量的数据，使用skip()方法来跳过指定数量的数据。

基本语法如下所示：

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

如果你想返回指定条数的记录，可以在find方法后调用limit来返回结果(TopN)，默认值20，例如：

db.comment.find().limit(3)

skip方法同样接受一个数字参数作为跳过的记录条数。（前N个不要），默认值是0.

db.comment.find().skip(3)

分页查询：

需求：每页2个，从第二页开始：跳过前两条数据，按着值显示3和4条数据

//第一页
db.comment.find().skip(0).limit(2)
//第二页
db.comment.find().skip(2).limit(2)
//第三页
db.comment.find().skip(4).limit(2)

3.5.3排序查询

sort()方法对数据进行排序，sort()方法可以通过参数指定排序的字段，并使用1和-1来指定排序的方法，其中1为升序排列，而-1是用于降序排列。

语法如下所示：

db.COLLECTION_NAME.find().sort({KEY: 1})
或
db.集合名称.find().sort(排序方式)

例如：

对userid降序排列，并对访问量进行升序排列

db.comment.find().sort({userid: -1, likenum: 1})

提示：

skip()，limit(),sort()三个放在一起执行的时候，执行的顺序是先sort()，然后skip()，最后是显示的limit(),和命令编写顺序无关。

3.6 文档的更多查询

3.6.1 正则的复杂条件查询

MongoDB的模糊查询是通过正则表达式的方法实现的。格式为：

db.collection.find({field: /正则表达式/})
或
db.集合.find({字段: /正则表达式/})

提示：正则表达式是js的语法，直接量的写法。

例如，我要查询评论内容包含”开水“的所有文档，代码如下：

db.comment.find({content: /开水/})

如果要查询评论的内容中以”专家“开头的，代码如下：

db.comment.find({content: /^专家/})

3.6.2比较查询

<,<=,>,>=这个操作符也是很常用的，格式如下：

db.集合名称.find({field: {$gt:value}}) //大于： field> value
db.集合名称.find({field: {$lt:value}}) //小于： field< value
db.集合名称.find({field: {$gte:value}}) //大于等于： field>= value
db.集合名称.find({field: {$lte:value}}) //小于等于： field<= value
db.集合名称.find({field: {$ne:value}}) //不等于： field!= value
db.集合名称.find({field: {$eq:value}}) //等于： field == value

示例：查询评论点赞数量大于700的记录

db.comment.find({likenum: {$gt: NumberInt(700)}})

3.6.3包含查询

包含使用$in操作符

示例：查询评论的集合中userid字段包含1003或1004的文档

db.comment.find({userid: {$in: ["1003", "1004"]}})

不包含使用$nin操作符

示例： 查询评论的集合中userid字段不包含1003或1004的文档

db.comment.find({userid: {$nin: ["1003", "1004"]}})

3.6.4条件连接查询

我们如果需要查询同时满足两个以上条件，需要使用$and操作符将条件进行关联。（相当于SQL的and）

格式为：

$and:[{}, {},{},...]

示例：查询评论集合中likenum大于等于700并且小于2000的文档

db.comment.find({
   $and:[{
    likenum: {
       $gte: NumberInt(700)
    }
   },{
     likenum: {
       $lt: NumberInt(2000)
    }
   }] 
})

如果两个以上条件之间是或者的关系，我们使用操作符进行关联，与前面$and的使用方式相同。

格式为：

$or:[{}, {},{},...]

示例：查询评论集合中userid为1003,或者点赞数小于1000的文档集合

db.comment.find({
   $or:[{
    userid: "1003"
   },{
     likenum: {
       $lt: NumberInt(1000)
    }
   }] 
})

3.7常用命令小结

选择切换数据库： use articledb

插入数据： db.comment.insert({bson数据})

查询所有数据： db.comment.find()

条件查询数据： db.comment.find({条件})

查询符合条件的第一条记录：db.comment.findOne({条件})

查询符合条件的前几条记录： db.comment.find({条件}).limit(条数)

查询符合条件的跳过的记录：db.comment.find({条件}).skip(条数)

修改数据： db.comment.update({条件},{修改后的数据})或者db.comment.update({条件},{$set: {要修改部分的字段:数据})

修改数据并自增某字段值：db.comment.update({条件},{$inc: {自增的字段:步进值}})

删除数据： db.comment.remove({条件})

统计查询： db.comment.count({条件})

模糊查询：db.comment.find({字段明:/正则表达式/})

条件比较运算： db.comment.find({字段名:{$gt: 值}})

包含查询： db.comment.find({字段名:{KaTeX parse error: Expected 'EOF', got '}' at position 11: in:[值1,值2]}̲})或db.comment.f…nin:[值1,值2]}})

条件连接查询：db.comment.find({KaTeX parse error: Expected 'EOF', got '}' at position 20: … [{条件1}, {条件2}]}̲)或条件连接查询：db.com…or: [{条件1}, {条件2}]})

四、索引

4.1概述

索引支持在MongoDB中高效地执行查询，如果没有索引，MongoDB必须执行全集合扫描，即扫描集合中的每个文档，以选择与查询语句匹配的文档，这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费十几秒甚至几分钟，这对网站的性能是非常致命的，

如果查询存在适当的索引，MongoDB可以使用该索引限制必须查看的文档数。

索引是特俗的数据结构，它以易于遍历的形式存储集合数据集的一小部分，索引存储特定字段或一组字段的值，按字段值排序，索引项的排序支持有效的相等匹配合基于范围的查询操作。此外，MongoDB还可以使用索引中的排序返回排序结果。

了解MongoDB索引使用B树结构（确切的说是B-Tree，MySql是B+Tree）

4.2索引的类型

4.2.1单字段索引

MongoDB支持在文档的单个字段上创建用户定义的升序/降序索引，称为单字段索引，

对于单个字段索引合排序操作，索引键的排序顺序（即升序或降序）并不重要，因为MongoDB可以在任何方向上遍历索引。

4.2.2复合索引

MongoDB还支持多个字段的用户定义索引，即复合索引。

复合索引中列出的字段顺序具有重要意义，例如，如果复合索引由{userId:1, score: -1}组成，则索引首先按userId正序排序，然后在每个userId的值内，再按score倒序排序。

4.2.3 其他索引

地理空间索引、文本索引、哈希索引。

地理空间索引

为了支持地理空间索引坐标数据的有效查询，MongoDB提供了两种特殊的索引：返回结果时使用平面几何的二维索引合返回结果时使用球面几何的二维球面索引。

文本索引

文本索引MongoDB提供了一种文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词（例如“thie”、“a”、“or”）,而将集合中的词作为词干，只存储根词。

文本索引一般由两种情况：

1.和数字没什么区别也是比较大小，就是做字典序比较。

正向索引

正向索引 (forward index) 以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时扫描表中每个文档中字的信息直到找出所有包含查询关键字的文档
这种组织方法在建立索引的时候结构比较简单，建立比较方便且易于维护：

2.全文索引，本质和搜索引擎的原理一样，分词以后做倒排序索引。

例如有3条记录，分别是

1.中国人民大学

2.中国科技大学

3.南方科技大学

分词假设只能分出“中国”、“人民”、“科技”、“大学”，“南方”五个词。

那么生成倒序索引如下：中国：1,2
人民：1
科技：2,3
大学：1,2,3
南方：3
用这个索引就可以根据你输入的“科技”找到第2，3条记录包含这个词
对于like %的模糊查询，如果是给定前缀，如中国%，那么可以利用第一种索引，通过前缀可以缩小查询范围。如果前缀是未知的，如%大学，那么就只能全表扫描逐个做字符串匹配了。
正则查询同理，如果正则中有常量前缀，那么可以利用上字符串的索引，否则不能。

倒排索引
当用户在搜索引擎搜索框中输入关键词的时候，搜索引擎就会把和关键词有关的页面展现给用户，而这个过程就叫做倒排索引。

哈希索引

为了支持基于散列的分片，MongoDB提供了散列索引类型，它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机，但只支持相等匹配， Hash 索引不支持顺序和范围查询。 哈希索引不支持排序,因为哈希表是无序的。 哈希索引不支持范围查找。 哈希索引不支持模糊查询及多列索引的最左前缀匹配。

4.3索引的管理操作

4.3.1索引的查看

说明：

返回一个集合中的所有索引的数组

语法:

db.collection.getIndexes()

提示: 该语法命令运行要求是MongoDB 3.0+

【示例】

查看common集合中所有的索引情况

 db.common.getIndexes()

[ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_" } ]

结果显示的是默认_id索引。

v:代表的MongoDB索引引擎版本，MongoDB底层的数据，不用管；

key:就是在哪个字段上加了索引， 1代表的是升序，-1代表的是降序；

name:索引的名称，默认 字段名称+ “_” +排序方式 ;

ns:命名空间（ 数据库.集合），代表某个数据库下的集合的索引数组。

4.3.2索引的创建

说明：

在结合上创建索引

语法：

db.collection.createIndex(keys, options)

参数：

options（更多选项）列表：

提示：

注意在3.0.0版本前创建索引方法为

db.collection.ensureIndex(keys, options)

之后的版本使用了

db.collection.createIndex(keys, options)

方法，db.collection.ensureIndex(keys, options)还能用，但只是db.collection.createIndex(keys, options)的别名。

【示例】

新增common集合索引

db.common.createIndex({userId: 1})

此时就有两个索引记录。

复合索引创建

db.common.createIndex({userId: 1, ckname: -1})

4.3.3索引的移除

说明：可以移除指定的索引，或者移除所有索引

一、指定索引的移除

语法：

db.collection.dropIndex(index)

参数：

【示例】

删除common集合中userId字段上的升序索引

db.common.dropIndex({userId: 1})

通过名称删除

 db.common.dropIndex("userId_1_ckname_-1")

二、所有索引的移除

语法：

db.collection.dropIndexes()

【示例】

db.common.dropIndexes()

_id不要期望会被干掉，它是永远不会被干掉的。

4.4索引的使用

4.4.1执行计划

分析查询性能通常使用执行计划（解析计划）来查看查询的情况，如查询耗费的时间，是否基于索引查询等。

那么，通常，我们想知道，建立的索引是否有效，效果如何，都需要通过执行计划查看。

语法：

db.collection.find(query, options).explain(options)

【示例】

查看根据userid查询数据的情况：

db.comment.find({userid: "1003"}).explain()

stage: “COLLSCAN”，COLL代表的是当前集合，集合全局扫描。

下面对userid建立索引

db.comment.createIndex({userid: 1})

再次查看执行计划

stage: “FETCH”，代表的是抓取， 下方的stage:“IXSCAN” 是索引扫描，整体就是索引扫描然后再根据索引结果进行抓取

4.4.2涵盖的查询

当查询条件和查询的投影仅包含索引字段时，MongoDB直接从索引返回结果，而不扫描任何文档或者将文档带入内存。这些航海的查询可以非常有效（同Mysql中的回表问题）。

[示例]

db.comment.find({userid: "1003"}, {userid:1, _id:0})

MongoDB集群和安全

课程目标

• MongoDB的副本集： 操作、主要概念、故障转移、选举规则
• MongoDB的分片集群：概念、优点、操作、分片策略、故障转移
• MongoDB的安全认证

一、副本集-Replica Sets

1.1简介

MongoDB中的副本集（Replica Set）是一组维护相同数据集的mongodb服务。副本集可提供冗余和高可用性，是所有生产部署的基础。

也可以说，副本集类似于有自动故障恢复功能的主从集群，通俗的讲就是用多台机器进行同一数据的异步同步， 从而使多台机器拥有同一数据的多个副本，并且当主库宕机时不需要用户干预的情况下自动切换其他被跟服务器做主库。而且还可以利用副本服务器只读服务器，实现读写分离，提高负载。

1，冗余和数据可用性

复制提供冗余并提高数据可用性。通过在不同数据库服务器上提供多个数据副本，复制可提供一定级别的容错功能，以防止丢失单个数据库服务器。

在某种情况下，复制可以提供增加的读取性能，因为客户端可以将读取操作发送到不同的服务上，在不同数据中心维护数据副本可以增加分布式应用程序的数据位置和可用性。您还可以为专用的目的维护其他副本，例如灾难恢复，报告或备份。

2.MongoDB中的复制

副本集是一组维护相同数据集的mongodb实例。副本集包含多个数据承载节点和可选的一个仲裁节点。在承载数据的节点中，有且只有一个成员被视为主节点，而其他节点被视为次要（从）节点。

主节点接收所有写操作。副本集只能有一个主要能确认具有{w: “most”}写入关注的写入;虽然在某些情况下，另一个mongodb实例可能暂时人为自己也是主要的。主要记录其操作日志中的数据集的所有更改，即oplog。

辅助（副本）节点复制节点的oplog并操作用于其数据集，以使辅助节点的数据集反应主节点的数据集。如果主要人员不在，则符合条件的将矩形选举以选出新的主要人员。

3.主从复制和副本集区别

主从集群和副本集最大的区别就是副本集没有固定的"主节点";整个集群会选出一个”主节点“，当其挂掉后，又在剩下的从节点中选中其他节点作为”主节点“,副本集总有一个活跃点（主，primary）和一个或多个备份节点（从， secondary）。

1.2副本集的三个角色

副本集有两种类型三种角色

两种类型

• 主节点（Primary）类型： 数据操作的主要连接点，可读写。
• 次要（辅助、从）连接点（Secondary）类型：数据冗余备份节点，可以读或选举。

三种角色：

主要成员（primary）：主要接收所有写操作。就是主节点。

副本成员（Replicate）：从节点通过复制操作以维护相同的数据集，即备份数据，不可写操作，但可以读操作（但需要配置）。是默认的一种从节点类型。

仲裁者（Arbiter）:不可保留任何数据的副本，只具有投票选举作用。当然也可以将仲裁服务器为副本集的一部分，即副本成员同时也可以是仲裁者。也是一种从节点类型。
## 1.3副本集架构目标

一主一副一仲裁

1.4副本集的创建

1.4.1第一步：创建主节点

mkdir -p /mongodb/relica_sets/myrs_27017/log & \
mkdir -p /mongodb/relica_sets/myrs_27017/data/db

新建或修改配置文件

vim /mongodb/relica_sets/myrs_27017/mongod.conf

linux下的mongod.conf配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27017/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27017/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27017/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: localhost, 192.168.0.2
  #绑定的端口
  port: 27017
replication:
  #副本集的名称
  replSetName: myrs

windows下的mongod.conf配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: D:\SOFTWARE\mongodb_group\mongodb_27017\log\mongod.log
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: D:\SOFTWARE\mongodb_group\mongodb_27017\data\db
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: D:\SOFTWARE\mongodb_group\mongodb_27017\log\mongod.pid
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定的IP
  bindIp: localhost
  #bindIp
  #绑定的端口
  port: 27017
replication:
  #副本集的名称
  replSetName: myrs

1.4.2第二步：创建副本节点

建立存放数据和日志的目录

mkdir -p /opt/mongodb/mongodb-27018/log & \
mkdir -p /opt/mongodb/mongodb-27018/data/db & \
mkdir -p /opt/mongodb/mongodb-27018/conf

新建或修改配置文件

vim /opt/mongodb/mongodb-27018/conf/mongod.yml

linux下的mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27018/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27018/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27018/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: localhost, 192.168.0.2
  #绑定的端口
  port: 27018
replication:
  #副本集的名称
  replSetName: myrs

1.4.3第三步：创建仲裁节点

建立存放数据和日志的目录

mkdir -p /opt/mongodb/mongodb-27019/log & \
mkdir -p /opt/mongodb/mongodb-27019/data/db & \
mkdir -p /opt/mongodb/mongodb-27019/conf

新建或修改配置文件

vim /opt/mongodb/mongodb-27019/conf/mongod.yml

linux下的mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27019/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27019/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27019/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: localhost, 192.168.0.2
  #绑定的端口
  port: 27019
replication:
  #副本集的名称
  replSetName: myrs

1.4.4第四步：启动节点

创建启动脚本

cd /opt/mongodb
touch start.sh
chmod u+x start.sh

start.sh内容如下：

#!/bin/bash
nohup /opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27018/bin/mongod -f /opt/mongodb/mongodb-27018/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27019/bin/mongod -f /opt/mongodb/mongodb-27019/conf/mongod.yml &
exit 1

启动脚本

./start.sh

1.4.5第五步：初始化配置副本集和主节点

使用客户端命令连接节点，但这里尽量连接主节点（27017节点）：

/opt/mongodb/mongodb-27017/bin/mongo --host=局域网ip --port=27017

结果，连接上之后,很多命令无法使用，比如showdbs等，必须初始化副本集才行，准备初始化新的副本集。

语法：

rs.initiate(configuratuin)

选项：

configuratuin是可选项，这里我们不使用configuratuin。

[示例]

使用默认的配置来初始化副本集：

rs.initiate()

1.提示“ok”的值为1，说明创建成功。

2.命令行提示符发生变化，变成了一个从节点角色，此时默认不能读写。稍等片刻，回车，变成主节点。

1.4.6第六步：查看副本集的配置内容

说明：

返回包含当前副本集配置的文档。

语法：

rs.config(configuration)

提示：

rs.config()是该方法的别名。

configuration：可选，如果没有配置，则使用默认主节点配置。

[示例]

rs.config()

1.4.7第七步：查看副本集状态

检查副本集状态。

说明：

返回包含状态信息的文档。此输出使用从副本集的其他成员发送的心跳包中获得的数据反映副本集的当前状态。

语法：

rs.status()

[示例]

在27017上查看副本集状态：

rs.status()

1.4.8第八步：添加副本集从节点

在主节点添加从节点，将其他成员加入到副本集。

语法：

rs.add(host, arbiterOnly)

选项：

arbiterOnly默认为false。

主机成员的配置文档：

[示例]

将27018的副本节点添加到副本集中：

rs.add("局域网ip:27018")

说明：

“ok”： 1，说明添加成功。

1.4.9第九步：添加仲裁从节点

添加一个仲裁节点到副本集

语法：

rs.addArb("ip:port")

将27019的仲裁节点添加到副本集中：

rs.addArb("局域网ip:27018")

查看副本集状态：

rs.status()

说明:
“ok”: 1,说明添加成功。

查看副本集状态:

rs.status()

1.5副本集的数据读写操作

目标： 测试三个不同角色的节点的数据读写情况。

登录主节点27017，写入和读取数据：

/opt/mongodb/mongodb-27017/bin/mongo --host=局域网ip --port=27017

登录主节点27018，写入和读取数据：

/opt/mongodb/mongodb-27018/bin/mongo --host=局域网ip --port=27018

发现，不能读取集合的数据，当前从节点只是一个备份，不是奴隶节点，无法读取数据，写当然更不能了。

因为默认情况下，从节点是没有读写权限的，可以增加读的权限，但需要进行设置。

设置读操作权限：

说明：

设置为奴隶节点，允许在从成员上运行读的操作

语法：

rs.slaveOk()
或
rs.slaveOk(true)
有的时候需要使用
rs.secondaryOk()

提示：

该命令是db.getMongo().setSlaveOk()的简化命令。

[示例]

在27018上设置作为奴隶节点权限，具备读权限：

rs.slaveOk()

此时，在执行查询命令，运行成功！

但仍然不允许插入。

show dbs

现在实现了读写分离，让主节点插入数据。

让从节点读取数据。

如果要取消努力节点的读权限：

rs.slavrOk(false)

仲裁节点，不存在任何业务数据，可以登录查看

rs.slaveOk()
show dbs或show databases

1.6主节点的选举原则

MongoDB的副本集中，会自动进行主节点的选举，主节点选举的触发条件

1.主节点故障

2.主节点网络不可达（默认心跳信息为10秒）

3.人工干预（rs.stepDown(600)）

一旦触发选举，就要根据一定规则来选主节点。

选举规则是根据票数来决定谁获胜：

票数最高，且获得了“大多数”成员的投票支持的节点获胜。

"大多数"的定义为： 假设复制集内投票成员数量为N,则大多数为N/2+1。例如：3个投票成员，则大多数的值是2.当复制集内存活成员数量不足大多数时，整个复制集将无法选举出Primary，复制集将无法提供写服务，处于只读状态。

若票数相同，且都获得了“大多数”成员的投票支持的，数据新的节点获胜。

数据的新旧时通过操作日志oplog来对比的。

在获得票数的时候，优先级参(priority)数影响重大。

可以通过设置优先级（priority）来设置额外票数。优先级即权重，取值为0-1000吗，相当于可额外增加0-1000的票数，优先级的值越大，就越可能获得多数成员的投票数（votes）。指定较高的值可使成员根由资格成为主要成员，更低的值可使成员更不符合条件。

默认情况下，优先级的值时1

rs.config()或rs.conf()

如果发生意外情况：副本集无法正常进行选举可以进行配置文件修改，随便找一个节点进行连接

/opt/mongodb/mongodb-27017/bin/mongo --host=局域网ip --port=27017

进行配置文件修改

config=rs.coonfg()
config.members[0].priority=5
config.members[1].priority=4
config.members[2].priority=3
rs.reconfig(config,{force: true})

成功后等待几分钟将会自动重新选举。

1.7副本节点故障

1.7.1副本节点故障测试

关闭27018副本节点：

发现，主节点和仲裁节点对27018的心跳失败。因为主节点还在，因此，没有触发投票选举。

如果此时，在主节点写入数据。

db.comment.insert({
				"_id": "1",
				"articleid": "100001",
				"content": "我们不应该吧清晨浪费在手机上，健康很重要，一杯温水幸福你我她。",
				"userid": "1001",
				"nickname": "相忘于江湖 ",
				"createdatetime": new Date("2019-08-05T22:08:15.522Z"),
				"likenum": NumberInt(1000),
				"state": "1"
			})

再启动从节点，会发现，主节点写入的数据，会自动同步给从节点。

1.7.2主节点故障测试

关闭27017节点

发现，从节点和仲裁节点对27017的心跳失败，当失败超过10秒，此时因为没有主节点了，会自动发起投票。

而副本节点只有27018，因此，候选人只有一个就是27018，开始投票。

27019向27018投了一票，27018本身自带一票，因此共两票，超过“大多数”。

27019时仲裁节点，没有选举权，27018不向其投票，其票数时0,

最终结果，27018成为主节点。具备读写功能。

从而实现了容错和高可用。

1.7.3仲裁节点和主节点故障

先关掉仲裁节点27019，

关闭现在的主节点27018

登录27017后，发现27017仍然是从节点，副本节点没有主节点了，导致此时，副本集是只读状态，无法写入。为什么不选举了？因为27017的票数没有获得“大多数”，即没有大于等于2，它只有默认的一票（优先级是1）如果要触发选举，祟拜你加入一个成员即可。

如果加入27019仲裁节点，则主节点一定是27017，因为没得选了，仲裁节点不参与选举，但参与投票（不演示）

如果加入27018节点，会发起选举，因为27017和27018都是1票，则按照谁数据新，谁当主节点。

1.7.4仲裁节点和从节点故障

先关掉仲裁节点27019，

关闭现在的副本节点27018

10秒后，27017主节点自动降级为副本节点。（服务降级）

副本集不可写数据了，已经故障了。

1.8Compass连接副本集

如果使用云服务需要修改配置中的主节点ip

config=rs.config()
config.members[0].host="ip:port"
rs.reconfig(config, {force: true})

这也是为什么节点在生产环境绑定ip的时候为什么不要使用127.0.0.1和localhost的原因，因为各个节点有个能在很多一擦汗给你请款会成为主节点，会导致无法通过公网被范围跟到。

compass连接：

虽然我们连接的是从节点，但是仍然可以写，从节点会将写操作转发给主节点进行操作。整个流程和zookeeper非常相似。

1.9SpringDataMongoDB连接副本集

副本集语法：

mongodb://host1,host2,host3/articledb?connect=replicaSet&slaveOk=true&replicaSet=副本集名称

其中：

slaveOk=true:开启副本节点读的功能，可实现读写分离。

connect=relicaSet：自动到副本集中选择读写的主机。如果slaveOK是打开的，则实现了读写分离

[示例]

连接replicaSet三台服务器（端口27017、27018、27019），直接连接第一个服务器，无论是replicaset一部分或者主服务器或者从服务器，写入作用在主服务器并且分布查询到从服务器。

修改配置文件application.yml

spring:
  data:
    mongodb:
	 uri: mongodb://host1,host2,host3/articledb?connect=
	 replicaSet&slaveOk=true&replicaSet=myrs

注意：

主机必须副本集中所有的主机，包括主节点、副本几点、仲裁节点。

二、分片集群-Sharded Cluster

2.1分片概念

分片（Sharding）是一种跨多台机器分布数据的方法，MongoDB使用分片来支持具有非常大的数据集和高吞吐量操作的部署。

换句话说：分片（sharding）是指将数据库拆分，将其分散存在不同的机器撒上的过程。有时也用分区（partitioning）来表示这个概念。将数据分散到不同的机器上，步需要功能强大的大型计算机就可以存储更多的数据，处理更多的负载。

具有大型数据集或高吞吐量应用程序的数据库系统可以会挑战单个服务器的容量。例如，高查询率耗尽服务器的CPU容量。工作集大小大于系统的RAM会强调磁盘驱动器的I/O容量。

有这两种解决系统增长的方法：垂直扩展和水平扩展。

垂直拓展意味着增加单个服务器的容量，列入使用更强大的CPU，添加更多的RAM或者增加存储空间量。可用技术的局限性可能会限制单个机器对于给定工作负载而言足够强大。此外，基于云的提供商基于可用的硬件配置具有硬性上限。结果，垂直缩放有实际的最大值。

水平拓展意味着划分系统数据集并加载多个服务器，添加其他服务器以根据需要增加容量。虽然单个机器的总体速度或容量可能不高，但每台机器处于整个工作负载的子集，可能提供比单个高速大容量服务器更高的效率。扩展部署容量只需要根据需要添加额外的服务器，这可能比打死你个机器的高端硬件的总体成本更低。权衡是基础架构和部署维护的复杂性增加。

MongoDB支持通过分片进行水平扩展。

2.2分片集群包含的组件

MongoDB分片集群包含以下组件：

• 分片（存储）：每个分片包含分片数据的子集。每个分片都可以部署为副本集。
• mongos(路由)：mongos充当查询路由器，在客户端应用程序和分片集群之间提供接口。
• config servers(“调度”的配置)：配置服务器存储群集的元数据和配置设置。从MongoDB3.4开始，必须将配置服务器部署为副本集(CSRS)。

下图描述了分片集群中组件的交互：
MongoDB在集合几倍对数据进行分片，将集合数据分布在集群中的分片上。

27017 if mongod is a shard member;

27019 if mongod is a shard member;

2.3分片集群架构目标

两个分片节点副本集（3+3）+一个配置节点副本集（3）+两个路由节点（2），共11个服务节点。

2.4分片（存储）节点副本集的创建

所有的配置文件都直接放到sharded_cluster的相应的子目录下面，默认配置文件名称：mongod.conf

2.4.1第一套副本集

准备存放数据库和日志的目录

mkdir -p /opt/mongodb/mongodb-27017/log & \
mkdir -p /opt/mongodb/mongodb-27017/data/db & \
mkdir -p /opt/mongodb/mongodb-27017/conf

mkdir -p /opt/mongodb/mongodb-27018/log & \
mkdir -p /opt/mongodb/mongodb-27018/data/db & \
mkdir -p /opt/mongodb/mongodb-27018/conf

mkdir -p /opt/mongodb/mongodb-27019/log & \
mkdir -p /opt/mongodb/mongodb-27019/data/db & \
mkdir -p /opt/mongodb/mongodb-27019/conf

新建配置文件

vim /opt/mongodb/mongodb-27017/conf/mongod.yml
vim /opt/mongodb/mongodb-27018/conf/mongod.yml
vim /opt/mongodb/mongodb-27019/conf/mongod.yml

/opt/mongodb/mongodb-27017/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27017/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27017/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27017/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27017
replication:
  #副本集的名称
  replSetName: myshardrs01
sharding:
  #分片角色
  clusterRole: shardsvr

/opt/mongodb/mongodb-27018/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27018/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27018/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27018/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27018
replication:
  #副本集的名称
  replSetName: myshardrs01
sharding:
  #分片角色
  clusterRole: shardsvr

/opt/mongodb/mongodb-27019/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27019/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27019/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27019/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27019
replication:
  #副本集的名称
  replSetName: myshardrs01
sharding:
  #分片角色
  clusterRole: shardsvr

注意：设置sharding.clusterRole需要mongod示例运行复制。需将实例部署为副本集成员，请使用replSetName设置并指定副本集的名称。

编写第一套副本集启动脚本start01.sh

#!/bin/bash
nohup /opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27018/bin/mongod -f /opt/mongodb/mongodb-27018/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27019/bin/mongod -f /opt/mongodb/mongodb-27019/conf/mongod.yml &
exit 1

启动第一套副本集（一主一副一仲裁）

./start01.sh

查看副本集启动状态

ps -aux| grep mongod

2.4.2第二套副本集

准备存放数据库和日志的目录

mkdir -p /opt/mongodb/mongodb-27117/log & \
mkdir -p /opt/mongodb/mongodb-27117/data/db & \
mkdir -p /opt/mongodb/mongodb-27117/conf

mkdir -p /opt/mongodb/mongodb-27118/log & \
mkdir -p /opt/mongodb/mongodb-27118/data/db & \
mkdir -p /opt/mongodb/mongodb-27118/conf

mkdir -p /opt/mongodb/mongodb-27119/log & \
mkdir -p /opt/mongodb/mongodb-27119/data/db & \
mkdir -p /opt/mongodb/mongodb-27119/conf

新建配置文件

vim /opt/mongodb/mongodb-27117/conf/mongod.yml
vim /opt/mongodb/mongodb-27118/conf/mongod.yml
vim /opt/mongodb/mongodb-27119/conf/mongod.yml

/opt/mongodb/mongodb-27117/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27117/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27117/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27117/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27117
replication:
  #副本集的名称
  replSetName: myshardrs02
sharding:
  #分片角色
  clusterRole: shardsvr

/opt/mongodb/mongodb-27118/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27118/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27118/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27118/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27118
replication:
  #副本集的名称
  replSetName: myshardrs02
sharding:
  #分片角色
  clusterRole: shardsvr

/opt/mongodb/mongodb-27119/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27119/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27119/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27119/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27119
replication:
  #副本集的名称
  replSetName: myshardrs02
sharding:
  #分片角色
  clusterRole: shardsvr

编写第二套副本集启动脚本start02.sh

#!/bin/bash
nohup /opt/mongodb/mongodb-27117/bin/mongod -f /opt/mongodb/mongodb-27117/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27118/bin/mongod -f /opt/mongodb/mongodb-27118/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27119/bin/mongod -f /opt/mongodb/mongodb-27119/conf/mongod.yml &
exit 1

启动第二套副本集（一主一副一仲裁）

./start02.sh

查看副本集启动状态

ps -aux| grep mongod

2.5配置节点副本集的创建

第一步：准备存放数据和日志的目录：

mkdir -p /opt/mongodb/config-27217/log & \
mkdir -p /opt/mongodb/config-27217/data/db & \
mkdir -p /opt/mongodb/config-27217/conf

mkdir -p /opt/mongodb/config-27218/log & \
mkdir -p /opt/mongodb/config-27218/data/db & \
mkdir -p /opt/mongodb/config-27218/conf

mkdir -p /opt/mongodb/config-27219/log & \
mkdir -p /opt/mongodb/config-27219/data/db & \
mkdir -p /opt/mongodb/config-27219/conf

新建配置文件

vim /opt/mongodb/config-27217/conf/mongod.yml
vim /opt/mongodb/config-27218/conf/mongod.yml
vim /opt/mongodb/config-27219/conf/mongod.yml

/opt/mongodb/config-27217/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/config-27217/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/config-27217/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/config-27217/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27217
replication:
  #副本集的名称
  replSetName: myconfig
sharding:
  #分片角色
  clusterRole: configsvr

/opt/mongodb/config-27218/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/config-27218/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/config-27218/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/config-27218/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27218
replication:
  #副本集的名称
  replSetName: myconfig
sharding:
  #分片角色
  clusterRole: configsvr

/opt/mongodb/config-27219/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/config-27219/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true

storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/config-27219/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/config-27219/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27219
replication:
  #副本集的名称
  replSetName: myconfig
sharding:
  #分片角色
  clusterRole: configsvr

编写配置副本集启动脚本start02.sh

#!/bin/bash
nohup /opt/mongodb/config-27217/bin/mongod -f /opt/mongodb/config-27217/conf/mongod.yml &
nohup /opt/mongodb/config-27218/bin/mongod -f /opt/mongodb/config-27218/conf/mongod.yml &
nohup /opt/mongodb/config-27219/bin/mongod -f /opt/mongodb/config-27219/conf/mongod.yml &
exit 1

启动配置套副本集（一主二副）

./config.sh

查看副本集启动状态

ps -aux| grep mongod

2.6路由节点的创建和操作

2.6.1第一个路由节点的拆功能键和连接

第一步：准备存放数据和日志的目录（路由只分发不会存储数据），所以不用创建data目录只创建log和conf目录即可。

mkdir -p /opt/mongodb/route-27317/log & \
mkdir -p /opt/mongodb/route-27317/conf

/opt/mongodb/route-27317/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/route-27317/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/route-27317/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27317
sharding:
  #指定配置节点副本集
  configDB: myconfig/192.168.0.2:27217,192.168.0.2:27218,192.168.0.2:27219

启动路由节点

nohup /opt/mongodb/route-27317/bin/mongos -f /opt/mongodb/route-27317/conf/mongod.yml &

提示：启动如果失败，可以查看log目录下的日志，查看失败原因。

客户端登录mongos

/opt/mongodb/route-27317/bin/mongo --host=192.168.0.2 --port=27317

此时，写不进去数据，如果写数据会报错：

因为缺少分片

2.6.2在路由节点上进行分片配置操作

使用命令添加分片：

1.添加分片：

语法：

sh.addShard("ip:port")

将第一套分片副本集添加进来：

sh.addShard("myshardrs01/192.168.0.2:27017,192.168.0.2:27018,192.168.0.2:27019")

查看分片状态情况
只有两个是因为仲裁节点没有数据，不被加入。

继续将第二套分片副本集添加进来：

sh.addShard("myshardrs01/192.168.0.2:27117,192.168.0.2:27118,192.168.0.2:27119")

查看分片状态情况

提示：如果添加分片失败，需要先手动移除分片，检查分片的i休尼希的正确性，再次添加分片。

移除分片参考（了解）

user admin
db.runCommand({removeShard: "replSetName"})

注意：如果只剩一个shard,是无法删除的，移除时会自动移除分片数据，需要一个时间过程。

完成后，再次执行删除分片命令才能真正删除。

2.开启分片功能：

语法：

sh.enableSharding("库名")
sh.shardCollection("库名.集合名", {key: 1})

再mongos上的articledb数据库配置sharding:

sh.sh.enableSharding("articledb")

3.集合分片

对集合分片，你必须使用sh.shardCollection()方法指定集合和分片键。

语法：

sh.shardCollection(namespace, options, unique)

对集合进行分片时，你需要选择一个分片键（shard key），shard key是每条记录都必须包含的，且建立了索引的单个字段或复合字段，MongoDB按照片键将数据划分到不同的数据块中，并将数据块均衡地分不到所有分片中，为了按照片键划分数据块，MongoDB使用基于哈希的分片方式（随机平均分配）或者基于范围的分片方式（数值大小分配）。

用什么字段当片键都可以，如： nickname作为片键，但一定是必填字段。

分片规则一：哈希策略

对于基于哈希的分片，MongoDB计算一个字段的哈希值，并用这个哈希值来创建数据块。

再使用基于哈希分片的系统中，拥有“相近”片键的文档很可能不会存储在同一个数据块中，因此数据的分离性更好一些。

使用nickname作为片键，根据其值的哈希值进行数据分片。

sh.shardCollection("articledb.comment", {nickname: "hashed"})

查看分片状态：

sh.status()

分片规则二：范围策略

对于基于范围的分片，MongoDB按照片键的范围把数据分成不同部分，假设有一个数字的片键：想想一个从负无穷刀片正无穷的直线，每一个片键的值都在直线上画一个点，MongoDB把这条直线划分为更短的不重叠的片段，并称之为数据块，每个数据块包含了片键在一定范围内的数据。

在使用片键做范围划分的系统中，拥有“相近”片键的文档很可能存储在同一个数据块中，因此也会存储在同一个分片中。如使用作者年龄字段作为片键，按照点赞数的值进行分片：

sh.shardCollection("articledb.author", {age: 1})

注意的是：

1.一个集合只能指定一个片键，否则报错。

2.一旦对一个集合分片，分片键和分片值就不可改变。如：不能给集合选择不同的分片键、不能更新分片键的值。

3.根据age索引进行分配是数据。

查看分片状态：

sh.status()

基于范围的分片方式与基于哈希的分片方式性能对比：

基于范围的分片方式提供了更高效的范围查询，给定一个片键的范围，分发路由可以很简单地确定哪个数据块存储了请求需要的数据，并将请求转发到相应的分片中。

不过，基于范围的分片会导致数据在不同分片上的不均衡，有时候带来的消极作用会大于查询性能的积极作用。比如：

如果片键所在的字段是线性增长的，一定时间内的所有请求都会落到某个固定的数据块中，最终导致分布在同一个分片中，在这种情况下，一小部分分片承载了集群大部分的数据，系统并不能很好地进行扩展。

与此相比，基于哈希的分片方式以范围查询性能的损失为代价，保证了集群中数据的均衡，哈希值的随机性使数据随机分布在每个数据块中，因此也随机分布在不同分片中，但是也正由于随机性，一个范围查询很难确定应该请求哪些分片，通常为了返回需要的结果，需要请求所有分片。

如无特俗情况，一般推荐使用Hash Sharding.

而使用_id作为片键是一个不错的选择，因为它是必有的，你可以使用数据文档__d的哈希作为片键。

这个方案能够是的读和写都能够平均分布，并且它能够保证每个文档都有不同的片键所以数据块能够很精细。

似乎还是不够完美，因为这样的话对于多个文档的查询必将命中所有的分片。虽说如此，这也是一种比较好的方案了。

理想化的shard key 可以让documents均匀地集群中分布：
显示集群的详细信息：

db.printShardingStatus()
或
sh.status()

查看均衡器是否工作（需要重新均衡时系统才会自动启动，不用管它）:

sh.isBalancerRunning()

2.6.3分片后插入数据测试

测试一（哈希规则）：登录mongos后，向comment循环插入1000条数据做测试：

use artiicledb
for(var i=0;i<1000;i++){db.comment.insert({_id:i+"", nickname:"BoBo" +i})}
db.comment.count()

提示：js的语法，因为mongo的shell是一个javaScript的shell。

注意：从路由上插入的数据，必须包含片键，否则无法插入。

分别登录两个片的主节点，统计文档数量

第一个分片副本集：

/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017

use articledb
db.comment.count()

第二个分片副本集：

/opt/mongodb/mongodb-27117/bin/mongo --host=192.168.0.2 --port=27117

use articledb
db.comment.count()

这种分配方式非常易于水平扩展，一旦数据存储需要更大空间，可以直接在增加分片即可，同时提升了性能。

使用db.comment,status()查看单个集合的完整情况，mongos执行该命令可以查看该集合数据的分片情况。使用sh.status()查看本库内所有集合的分片信息。

测试二（范围规则）：登录mongos后，向author循环插入10000条数据做测试

use articledb
for(var i=0;i<10000;i++){db.author.insert({name:"BoBo" +i, age:NumberInt(i%120)})}

插入成功后，仍然要分别查看两个分片副本集的数据情况。

分片效果：

提示：

如果查看状态风险没有分片，则可能是由于以下原因造成的：

1.系统繁忙，正在分片中

2.数据块（chunk）没有填满。默认的数据文件尺寸（chunksize）是64M，填满后才会考虑向其他片的数据块填充数据，因此，为了测试，可以将其该校，这里改为1M，操作如下；

use config
db.settings.save({_id: "chunksize", value: 1})

测试完改回来

use config
db.settings.save({_id: "chunksize", value: 64})

注意：要先改小，再设置分片。为了测试，可以先删除集合，再重新建立集合的分片策略，再插入数据测试即可。

MongoDB将数据存储在称为数据文件的文件中。每个数据文件的大小默认为64MB，可以通过配置进行更改。当一个数据文件达到其最大大小后，MongoDB会自动创建一个新的数据文件来存储更多的数据。这种自动扩展的机制使得MongoDB能够处理大容量的数据。

数据文件由多个数据块组成，每个数据块默认为4KB。MongoDB会将文档存储在数据块中，其中一个数据块可以存储多个文档。当一个数据块已满时，MongoDB会分配一个新的数据块来存储更多的文档。

2.6.4 再增加一个路由节点

第一步：准备存放数据和日志的目录（路由只分发不会存储数据），所以不用创建data目录只创建log和conf目录即可。

mkdir -p /opt/mongodb/route-27318/log & \
mkdir -p /opt/mongodb/route-27318/conf

/opt/mongodb/route-27318/conf/mongod.yml配置文件内容：

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/route-27318/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/route-27318/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27318
sharding:
  #指定配置节点副本集
  configDB: myconfig/192.168.0.2:27217,192.168.0.2:27218,192.168.0.2:27219

编写启动路由脚本route.sh

#!/bin/bash
nohup /opt/mongodb/route-27317/bin/mongos -f /opt/mongodb/route-27317/conf/mongod.yml &
nohup /opt/mongodb/route-27318/bin/mongos -f /opt/mongodb/route-27318/conf/mongod.yml &
exit 1

启动脚本

./route.sh

提示：启动如果失败，可以查看log目录下的日志，查看失败原因。

2.7Compass连接分片集群

compass连接：
直接连接任意一个路由即可

spring:
  data:
    mongodb:
       #连接路由字符串
       url: mongodb://192.168.0.2:27317,192.168.0.2:27318/articledb

通过日志发现，写入数据的时候会随机选择一个路由写入。

三、安全认证

3.1MongoDB的用户和角色权限简介

默认情况下，MongoDB实例启动运行时是没有启用用户访问权限控制的，也就是说，在实例本机服务器上都可以随意连接到实例进行各种操作，MongoDB不会对连接客户端进行用户校验，这是非常危险的。
mongodb官网说，为了能保障mongodb的安全可以做以下步骤：
1.使用新的端口，默认的27017端口如果一旦知道了ip就能连接上，不太安全。
2.设置mongodb的网络环境，最好将mongodb部署到公司服务器内网，这样外网是访问不到的。公司内部访问使用vpn等。
3.开去安全认证。认证要同时设置服务器之间的内部认证方式。同时要设置客户端连接到集群的站好密码认证方式。
为了强制开启用户访问控制（用户验证），则需要在MongoDB实例启动时使用选项–auth或在指定启动配置文件中添加选项auth=true.

在开始之前需要了解一下概念
1.启用访问控制
MongoDB使用的是基于角色的访问控制（Role-Based- Access Control, RBAC）来管理用户对实例的访问。通过对用户授予一个或者多个角色来控制用户访问数据库资源的权限和数据库操作的权限，在对用户分配角色之前，用户无法访问实例。
在实例启动时添加选项–auth或指定启动配置文件中添加选项auth=true。
2.角色
在MongoDB中通过角色对用户授予相应数据库资源的操作权限，每个角色当中的权限可以通过显示指定，也可以通过继承其他角色的权限，或者两个都存在的权限。
3.权限：
权限由指定的数据库资源（resource）以及允许在指定资源上进行的操作（action）组成。
资源（resource）包括：数据库、集合、部分集合和集群；
操作包括：对资源进行的增、删、改、查（CRUD）操作。
在角色定义时可以包含一个或多个已存在的角色，新创建的角色会继承包含的角色所有的权限。在同一个数据库中，新创建角色可以继承其他角色的权限，在admin数据库中创建角色可以继承在其他任意数据库中角色的权限。
关于角色权限的查看，可以通过如下命令查看（了解）：

//查询所有角色权限（仅用户自定义角色）
db.runCommand({rolesInfo: 1})
//查询所有角色权限（包含内置角色）
db.runCommand({rolesInfo: 1, showBuiltinRoles: true})
//查询当前数据库中的某个角色的权限
db.runCommand({rolesInfo: "<roleName>"})
//查看其他数据库中指定的角色权限
db.runCommand({rolesInfo: {role: "<rolename>", db: "<database>"}})
//查询多个角色权限
db.runCommand({rolesInfo: [ {role: "<rolename>", db: "<database>"}, {role: "<rolename>", db: "<database>"},...] })

常用的内置角色：

• 数据库用户角色： read、readWrite
• 所有数据库用户角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
• 数据库管理角色： dbAdmin、dbOwner、userAdmin
• 集群管理角色: clusterAdmin、clusterManager、clusterMonitor、hostManager
• 备份恢复角色： backup、restore
• 超级用户角色： root
• 内部角色： system
  

3.2单实例环境

目标： 对单实例的MongoDB服务开启安全认证，这里的单实例指的是未开启副本集或者分片的MongoDB实例。

3.2.1关闭已开启的服务（可选）

增加mongod的单实例的安全认证功能，可以在服务搭建的时候直接添加，也可以在之前搭建好的服务上添加。
本文使用之前搭建好的服务，因此，先停止之前的服务。
停止服务的方式由两种：款素关闭和标准关闭，下面一次说明：
1.快速关闭方法（快速，简单，数据坑会出错）
目标：通过系统的kill命令直接杀死进程：
杀完要检查一下，避免有的没有杀掉。

#通过进程编号关闭节点
kill -2 进程号

[补充]
如果一旦是因为数据损坏，则需要进行如下操作（了解）：
1.删除lock文件

rm -fr /opt/mongodb/mongodb-27017/data/db/*.lock

2.修复数据

/opt/mongodb/mongodb-27017/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27017/data/db

2.标准的关闭方法（数据不容易出错，但麻烦）：

目标：通过mongo客户端中的shutdownServer命令来关闭服务

主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录验证才行
mongo --port 27017
//切换到admin库
use admin
//关闭服务
db.shutdownServer()

3.2.2添加用户和权限

1.先按照普通无授权认证的配置，来配置服务端的配置文件/mongodb/mongodb-27017/conf/mongod.yml（参考服用之前文档）

systemLog:
  #MongoDB发送所有日志输出的目标指定为文件
  destination: file
  path: "/opt/mongodb/mongodb-27017/log/mongod.log"
  #当mongos或者mongod实例重新启动时，mongos或者mongod会将新条目附加到现有日志文件的末尾
  logAppend: true
storage:
  #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongodb
  dbPath: "/opt/mongodb/mongodb-27017/data/db"
  journal:
    #启用或者禁用持久性日志以确保数据文件保持有效和可恢复到宕机前
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  #fork: true
  #指定用于保存mongos或mongod进程的额进城ID的文件位置，其中mongos或mongod将写入其PID
  pidFilePath: "/opt/mongodb/mongodb-27017/log/mongod.pid"
net:
  #服务实例绑定所有IP，有副作用，副本集初始化的时候，节点名字会自动设置为本地域名，而不是ip
  #bindIpAll: true
  #服务实力绑定IP,如果是云服务需要绑定局域网ip（而不是127.0.0.1，127.0.0.1是回路用于本地测试，公网找不到，或   #者设置0.0.0.0，这样公网ip就可以转到本机,或者将bindIpAll: true）
  bindIp: 192.168.0.2
  #绑定的端口
  port: 27017

2.按照之前未开启认证的方式（不添加–auth参数）来启动MongoDB服务：

nohup /opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml

提示：再操作用户时，启动mongod服务时尽量不要开启授权。

3.使用Mongo客户端登录：

/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017

4.创建两个管理员用户，一个是系统的超级管理员myroot，一个是admin库的管理用户myadmin:

​ 1)切换到admin库

use admin

​ 2)创建系统超级用户myroot，设置密码123456，设置角色root

db.createUser({user: "myroot", pwd: "123456", roles: ["root"]})

3)创建专门用来管理admin库的账号myadmin.只用来作为用户权限的管理

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

4)查看已经创建了的用户情况

db.system.users.find()

​ 5)删除用户

db.droupUser("myadmin")

​ 6)修改密码

db.changeUserPassword("myroot", "123456")

提示：

1.本案例创建了两个用户，分别对应超管和专门用来管理用户的角色，事实上，你只需要一个用户即可，如果你对安全要求很高，防止超管泄露，则不需要创建超管用户。

2.和其他是数据库（Mysql）一样，权限的管理都差不多一样，也是将用户和权限信息保存到数据库对应的表中。MongoDB存储所有的用户信息在admin数据库的集合system.users中，保存用户名、密码和数据库信息。

3.如果不指定数据库，则创建的指定的权限搞得用户在所有的数据库有效，如：

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

5.认证测试

测试添加的用户是否正确

切换到admin

切换到admin

密码输错

db.auth("myroot", "12345")

密码输入正确

db.auth("myroot", "123456")

6.创建普通用户

创建普通用户可以在没有开启认证的时候添加，也可以在开启认证之后添加，但开启认证之后，必须使用有操作admin库的用户登录认证后才能操作。底层都是将用户信息保存在了admin数据库的集合system.users中。

切换数据库

use articledb

创建普通用户，拥有articledb数据库的读写权限readWrite,密码123456

db.createUser({user: "bobo", pwd: "123456", roles: [{role: "readWrite", db: "articledb"}]})

测试是否可用

db.auth("bobo", "123456")

只能登录一次，如果前面已经登录成功过一次需要重新开启客户端，切换数据库，进行登录，否则，登陆失败。

提示： 如果开启了认证后，登录的客户端的用户必须使用admin库的角色，如拥有root角色的myadmin用户，那就通过myadmin用户去创建其他角色的用户。

3.2.3服务端开启认证和客户端连接登录

1.关闭已经启动的服务

​ 1）使用linux命令杀死进程

ps -ef | grep mongo
kill -2 进程ID

​ 2)在mongo客户端中使用shutdownServer命令来关闭

use admin
db.shutdownServer()

需要几个条件：

• 必须是在admin库下执行该关闭服务命令
• 如果没有开启认证必须是从localhost登录的（mongo --host=localhost --port=27017），才能执行关闭服务命令
• 非loclahost的而是通过远程的，必须有登录且必须登录用户有对admin操作权限才可以

2.以开启认证的方式启动服务

有两种方式开启权限认证启动服务：一种是参数方式，一种是配置文件方式。

​ 1）参数方式

​ 在启动时指定参数–auth，如：

/opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml --auth

​ 2)配置文件方式

在mongod.yml配置文件中加入：

security:
  #开启授权认证
  authorization: enabled

启动时可不加–auth参数：

/opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml

3.开启了认证的情况下的客户端登录

有两种认证方式：一种是先登录，在mongo shell中认证，一种是登录时直接认证。

​ 1）先连接再认证

/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017

​ 2）登录时认证

/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017 -umyroot -p123456

提示：

开启认证后再登录，发现打印的日志比较少了

相关操作需要认证才可以

查询admin库中的system.users集合的用户

//切换库
use admin
//查看用户
db.system.users.find()
//登录
db.auth("myroot", "123456")

查询articledb库中的comment集合的内容

use articledb
db.comment.find()

3.2.4SpringDataMongo连接认证

使用用户名和密码连接到MongoDB服务器，你必须使用username:password@hostname/dbname格式，username为用户名，password是密码。

目标：使用用户bobo使用密码123456连接到MongoDB服务器

application.yml

spring:
	data:
		mongodb:
			uri: mongodb://bobo:123456@192.168.0.2:27017/articledb

提示：

分别测试用户名密码正确以及不正确的情况。

3.3副本集环境

3.3.1前言

对于搭建好的MongoDB副本集，为了安全，启动安全认证，使用账号密码登录。

副本集环境使用之前搭建好的，架构如下：

3.3.2关闭已开启的副本集服务（可选）

1：先关闭从节点、仲裁节点。或者先关闭仲裁节点，最后关闭从节点。则：主节点自动变为从节点

2：先关闭主节点，则从节点自动变为主节点，在仲裁节点关闭之前，新主节点不能关闭

增加副本集的安全认证和服务鉴权功能，可以再副本集搭建的时候直接添加，也可以在之前搭建好的副本集服务上添加。

本文使用之前搭建好的副本集服务，因此，先停止之前的集群服务，停止服务的方式有两种：快速关闭和标准关闭，下面依次说明：

​ 1.快速关闭方法（快速，简单，数据坑会出错）
​ 目标：通过系统的kill命令直接杀死进程：
​ 杀完要检查一下，避免有的没有杀掉。

#通过进程编号关闭节点
kill -2 进程号

[补充]
如果一旦是因为数据损坏，则需要进行如下操作（了解）：
1）删除lock文件

rm -fr /opt/mongodb/mongodb-27017/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27018/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27019/data/db/*.lock

2）修复数据

/opt/mongodb/mongodb-27017/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27017/data/db
/opt/mongodb/mongodb-27018/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27018/data/db
/opt/mongodb/mongodb-27019/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27019/data/db

2.标准的关闭方法（数据不容易出错，但麻烦）：

目标：通过mongo客户端中的shutdownServer命令来关闭服务

关闭副本集中的服务，建议一次关闭仲裁节点、副本节点、主节点。主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行
/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017
//告知副本集说本机要下线了
rs.stepDown()
//切换到admin库
use admin
//关闭服务
db.shutdownServer()

3.3.3通过主节点添加一个管理员账号

只需要在主节点上添加用户，副本集会自动同步。

开启认证之前，创建超管用户： myroot、myadmin，密码：123456

登录主节点

/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017

创建两个管理员用户，一个是系统的超级管理员myroot，一个是admin库的管理用户myadmin:

​ 1)切换到admin库

use admin

​ 2)创建系统超级用户myroot，设置密码123456，设置角色root

db.createUser({user: "myroot", pwd: "123456", roles: ["root"]})

3)创建专门用来管理admin库的账号myadmin.只用来作为用户权限的管理

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

详细操作详见单实例环境的添加用户和权限的相关操作。

提示：

该步骤也可以在开启认账之后，但需要通过localhost登录才能添加用户，用户数据也会自动同步到副本集。

后续再创建其他用户，都可以使用该超管用户创建。

3.3.4创建副本集认证的key文件

第一步：生成一个key文件到当前文件夹中。

可以使用任何方法生成密钥文件。例如，以下操作使用openssl生成密钥文件，然后使用chmod来更改文件权限。仅为文件所有者提供读写权限。

openssl rand -base64 90 -out ./mongo.keyfile
chmod 400 ./mongo.keyfile
ll mongo.keyfile

提示：所有副本集节点都必须要用同一份keyfile，一般实在同一台机器上生成，然后拷贝到其他机器上，且必须有读的权限，否则将来会报错：permission on mongo.keyfile are too open。

一定要保证密钥文件一致，文件位置随便，但是为了方便查找，建议每台机器都放到一份固定的位置，都放到和配置文件一起的目录中。

这里将该文件分别拷贝到多个目录中：

cp mongo.keyfile /opt/mongodb/mongodb-27017/conf
cp mongo.keyfile /opt/mongodb/mongodb-27018/conf
cp mongo.keyfile /opt/mongodb/mongodb-27019/conf

3.3.5修改配置文件指定keyfile

分别编辑几个服务的mongod.yml文件，添加相关内容：

​ /opt/mongodb/mongodb-27017/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27017/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27018/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27018/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27019/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27019/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

3.3.6重新启动副本集

如果副本集是开启状态，则先分贝关闭副本集中的每个mongod。

1：先关闭从节点、仲裁节点。或者先关闭仲裁节点，最后关闭从节点。则：主节点自动变为从节点

2：先关闭主节点，则从节点自动变为主节点，在仲裁节点关闭之前，新主节点不能关闭

拓展：https://blog.csdn.net/sunboylife/article/details/132472810?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22132472810%22%2C%22source%22%3A%22sunboylife%22%7D

启动脚本start01.sh

#!/bin/bash
nohup /opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27018/bin/mongod -f /opt/mongodb/mongodb-27018/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27019/bin/mongod -f /opt/mongodb/mongodb-27019/conf/mongod.yml &
exit 1

启动副本集（一主一副一仲裁）

./start01.sh

查看副本集启动状态

ps -aux| grep mongod

3.3.7在主节点上添加普通账号

#切换库
use admin
#使用管理员账号登录
db.auth("myroot", "123456")
#切换到要认证的库
use articledb
#添加普通用户
db.createUser({user: "bobo", pwd: "123456", roles: "readWrite"})

重新连接，使用普通用户bobo重新登录，查看数据。

注意：也要使用rs.status()命令查看副本集是否健康。

3.3.8 SpringDataMongoDB连接副本集

使用用户名和密码连接到MOngoDB服务器，你必须使用username:password@/dbname格式，username为用户名，password为密码。

目标：使用用户bobo使用密码123456连接到MongoDB服务器。

application.yml

spring:
	data:
		mongodb:
			uri: mongodb://bobo:123456@192.168.0.2:27017,192.168.0.2:27018,192.168.0.2:27019/articledb?connect=replicaSet&slaveOk=true&replicaSet=myrs

3.4分片集群环境（拓展）

3.4.1关闭已开启的集群服务（可选）

分片集群环境下的安全认证和副本集环境下基本一样。

但是分片集群的服务器环境和架构较为复杂，建议在搭建分片集群的时候，直接加入安全认证和服务间的健全，如果之前有数据，可先将之前的数据备份出来，再还原回去。

本文使用之前搭建好的集群服务，因此，先停止之前的集群服务

停止服务的方式有两种：快速关闭和标准关闭，下面依次说明：

​ 1.快速关闭方法（快速，简单，数据坑会出错）
​ 目标：通过系统的kill命令直接杀死进程：
​ 依次杀死mongos路由、配置副本集服务、分片副本集服务，从次节点开始。直到所有成员都离线。副本集杀的时候，建议先杀仲裁者，再杀副本节点，最后主节点。

#通过进程编号关闭节点
kill -2 进程号

[补充]
如果一旦是因为数据损坏，则需要进行如下操作（了解）：
1）删除lock文件

rm -fr /opt/mongodb/mongodb-27017/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27018/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27019/data/db/*.lock

rm -fr /opt/mongodb/mongodb-27117/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27118/data/db/*.lock
rm -fr /opt/mongodb/mongodb-27119/data/db/*.lock

rm -fr /opt/mongodb/config-27217/data/db/*.lock
rm -fr /opt/mongodb/config-27218/data/db/*.lock
rm -fr /opt/mongodb/config-27219/data/db/*.lock

rm -fr /opt/mongodb/route-27317/data/db/*.lock
rm -fr /opt/mongodb/route-27318/data/db/*.lock

2）修复数据

/opt/mongodb/mongodb-27017/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27017/data/db
/opt/mongodb/mongodb-27018/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27018/data/db
/opt/mongodb/mongodb-27019/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27019/data/db

/opt/mongodb/mongodb-27117/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27117/data/db
/opt/mongodb/mongodb-27118/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27118/data/db
/opt/mongodb/mongodb-27119/bin/mongod --repair --dbPath=/opt/mongodb/mongodb-27119/data/db

/opt/mongodb/config-27217/bin/mongod --repair --dbPath=/opt/mongodb/config-27217/data/db
/opt/mongodb/config-27218/bin/mongod --repair --dbPath=/opt/mongodb/config-27218/data/db
/opt/mongodb/config-27219/bin/mongod --repair --dbPath=/opt/mongodb/config-27219/data/db

/opt/mongodb/route-27317/bin/mongod --repair --dbPath=/opt/mongodb/route-27317/data/db
/opt/mongodb/route-27318/bin/mongod --repair --dbPath=/opt/mongodb/route-27318/data/db

2.标准的关闭方法（数据不容易出错，但麻烦）：

目标：通过mongo客户端中的shutdownServer命令来关闭服务

关闭副本集中的服务，建议一次关闭仲裁节点、副本节点、主节点。主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行
/opt/mongodb/mongodb-27017/bin/mongo --host=192.168.0.2 --port=27017
//告知副本集说本机要下线了
rs.stepDown()
//切换到admin库
use admin
//关闭服务
db.shutdownServer()

3.4.2创建副本集认证的key文件

第一步：生成一个key文件到当前文件夹中。

可以使用任何方法生成密钥文件。例如，以下操作使用openssl生成密钥文件，然后使用chmod来更改文件权限。仅为文件所有者提供读写权限。

openssl rand -base64 90 -out ./mongo.keyfile
chmod 400 ./mongo.keyfile
ll mongo.keyfile

提示：所有副本集节点都必须要用同一份keyfile，一般实在同一台机器上生成，然后拷贝到其他机器上，且必须有读的权限，否则将来会报错：permission on mongo.keyfile are too open。

一定要保证密钥文件一致，文件位置随便，但是为了方便查找，建议每台机器都放到一份固定的位置，都放到和配置文件一起的目录中。

这里将该文件分别拷贝到多个目录中：

cp mongo.keyfile /opt/mongodb/mongodb-27017/conf
cp mongo.keyfile /opt/mongodb/mongodb-27018/conf
cp mongo.keyfile /opt/mongodb/mongodb-27019/conf

cp mongo.keyfile /opt/mongodb/mongodb-27117/conf
cp mongo.keyfile /opt/mongodb/mongodb-27118/conf
cp mongo.keyfile /opt/mongodb/mongodb-27119/conf

cp mongo.keyfile /opt/mongodb/config-27217/conf
cp mongo.keyfile /opt/mongodb/config-27218/conf
cp mongo.keyfile /opt/mongodb/config-27219/conf

cp mongo.keyfile /opt/mongodb/route-27317/conf
cp mongo.keyfile /opt/mongodb/route-27318/conf

3.4.3修改配置文件指定keyfile

分别编辑几个服务的mongod.yml文件，添加相关内容：

​ /opt/mongodb/mongodb-27017/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27017/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27018/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27018/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27019/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27019/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27117/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27117/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27118/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27118/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/mongodb-27119/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/mongodb-27119/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/config-27217/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/config-27217/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/config-27218/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/config-27218/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/config-27219/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/config-27219/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/route-27317/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/route-27317/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

​ /opt/mongodb/route-27318/conf/mongod.yml内容如下：

security:
  #keyfile鉴权文件
  keyFile: /opt/mongodb/route-27318/conf/mongo.keyfile
  #开启授权认证
  authorization: enabled

3.4.4重新启动副本集

创建启动脚本

启动脚本start01.sh

#!/bin/bash
nohup /opt/mongodb/mongodb-27017/bin/mongod -f /opt/mongodb/mongodb-27017/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27018/bin/mongod -f /opt/mongodb/mongodb-27018/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27019/bin/mongod -f /opt/mongodb/mongodb-27019/conf/mongod.yml &
exit 1

启动脚本start02.sh

#!/bin/bash
nohup /opt/mongodb/mongodb-27117/bin/mongod -f /opt/mongodb/mongodb-27117/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27118/bin/mongod -f /opt/mongodb/mongodb-27118/conf/mongod.yml &
nohup /opt/mongodb/mongodb-27119/bin/mongod -f /opt/mongodb/mongodb-27119/conf/mongod.yml &
exit 1

启动脚本config.sh

#!/bin/bash
nohup /opt/mongodb/config-27217/bin/mongod -f /opt/mongodb/config-27217/conf/mongod.yml &
nohup /opt/mongodb/config-27218/bin/mongod -f /opt/mongodb/config-27218/conf/mongod.yml &
nohup /opt/mongodb/config-27219/bin/mongod -f /opt/mongodb/config-27219/conf/mongod.yml &
exit 1

启动脚本route.sh

#!/bin/bash
nohup /opt/mongodb/route-27317/bin/mongos -f /opt/mongodb/route-27317/conf/mongod.yml &
nohup /opt/mongodb/route-27318/bin/mongos -f /opt/mongodb/route-27318/conf/mongod.yml &
exit 1

依次执行start01.sh、start02.sh、config.sh、route.sh。

查看mongo服务启动状态

ps -ef| grep mongo

3.4.6在主节点上添加普通账号

#切换库
use admin
#使用管理员账号登录
db.auth("myroot", "123456")
#切换到要认证的库
use articledb
#添加普通用户
db.createUser({user: "bobo", pwd: "123456", roles: "readWrite"})

重新连接，使用普通用户bobo重新登录，查看数据。

注意：也要使用rs.status()命令查看副本集是否健康。

3.4.7SpringDataMongoDb连接分片集群

compass连接：
直接连接任意一个路由即可

spring:
  data:
    mongodb:
       #连接路由字符串
       url: mongodb://bobo:123456@192.168.0.2:27317,192.168.0.2:27318/articledb