# mongodb_基础到进阶 -- MongoDB 高级--MongoDB 集群部署与安全性（五）

段子手-168

已于 2024-08-08 13:37:01 修改

阅读量1k

点赞数 27

分类专栏： # MongoDB文档型数据库文章标签： mongodb 数据库 MongoDB文档型数据库 mongodb集群部署 mongodb安全性 mongodb分片集群安全认证

于 2024-08-05 09:30:00 首次发布

本文链接：https://blog.csdn.net/qfyh_djh/article/details/140906441

版权

MongoDB文档型数据库专栏收录该内容

16 篇文章 0 订阅

订阅专栏

#编程小白如何成为大神？大学新生的最佳入门攻略#

mongodb_基础到进阶 – MongoDB 高级–MongoDB 集群部署与安全性（五）

一、mongodb 安全认证简介

1、MongoDB 的用户和角色权限简介

默认情况下，MongoDB 实例启动运行时是没有启用用户访问权限控制的，也就是说，在实例本机服务器上都可以随意连接到实例进行各种操作，MongoDB 不会对连接客户端进行用户验证，这是非常危险的。

2、mongodb 官网上说，为了能保障 mongodb 的安全可以做以下几个步骤：

1）使用新的端口，默认的27017端口如果一旦知道了ip就能连接上，不太安全。

2）设置 mongodb 的网络环境，最好将 mongodb 部署到公司服务器内网，这样外网是访问不到的。公司内部访问使用vpn等。

3）开启安全认证。认证要同时设置服务器之间的内部认证方式，同时要设置客户端连接到集群的账号密码认证方式。

3、为了强制开启用户访问控制(用户验证)，则需要在MongoDB实例启动时使用选项 – auth 或在指定启动配置文件中添加选项 auth=true 。

4、mongodb 安全认证一此概念

1）启用访问控制：

MongoDB 使用的是基于角色的访问控制(Role-Based Access Control,RBAC)来管理用户对实例的访问。

通过对用户授予一个或多个角色来控制用户访问数据库资源的权限和数据库操作的权限，在对用户分配角色之前，用户无法访问实例。

在实例启动时添加选项 – auth 或指定启动配置文件中添加选项 auth=true 。

2）角色：

在 MongoDB 中通过角色对用户授予相应数据库资源的操作权限，每个角色当中的权限可以显式指定，也可以通过继承其他角色的权限，或者两都都存在的权限。

3）权限：

权限由指定的数据库资源(resource)以及允许在指定资源上进行的操作(action)组成。

1. 资源(resource)包括：数据库、集合、部分集合和集群；
1. 操作(action)包括：对资源进行的增、删、改、查(CRUD)操作。

在角色定义时可以包含一个或多个已存在的角色，新创建的角色会继承包含的角色所有的权限。在同一个数据库中，新创建角色可以继承其他角色的权限，在 admin 数据库中创建的角色可以继承在其它任意数据库中角色的权限。

5、关于角色权限的查看，可以通过如下命令查询（了解）：

// 查询所有角色权限(仅用户自定义角色)
> db.runCommand({ rolesInfo: 1 })

// 查询所有角色权限(包含内置角色)
> db.runCommand({ rolesInfo: 1, showBuiltinRoles: true })

// 查询当前数据库中的某角色的权限
> db.runCommand({ rolesInfo: "<rolename>" })

// 查询其它数据库中指定的角色权限
> db.runCommand({ rolesInfo: { role: "<rolename>", db: "<database>" } }

// 查询多个角色权限
> db.runCommand(
 {
    rolesInfo: [
      "<rolename>",
     { role: "<rolename>", db: "<database>" },
      ...
   ]  
 }
)

6、示例：查看所有内置角色：


> db.runCommand({ rolesInfo: 1, showBuiltinRoles: true })
{
    "roles" : [
       {
            "role" : "__queryableBackup",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "__system",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "backup",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "clusterAdmin",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "clusterManager",
             "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "clusterMonitor",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "dbAdmin",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "dbAdminAnyDatabase",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "dbOwner",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "enableSharding",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "hostManager",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "read",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "readAnyDatabase",
            "db" : "admin",
            "isBuiltin" : true,

            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "readWrite",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "readWriteAnyDatabase",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "restore",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "root",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "userAdmin",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       },
       {
            "role" : "userAdminAnyDatabase",
            "db" : "admin",
            "isBuiltin" : true,
            "roles" : [ ],
            "inheritedRoles" : [ ]
       }
   ],
    "ok" : 1
}

7、常用的内置角色：

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

8、角色说明

角色	权限描述
read	可以读取指定数据库中任何数据。
readWrite	可以读写指定数据库中任何数据，包括创建、重命名、删除集合。
readAnyDatabase	可以读取所有数据库中任何数据(除了数据库config和local之外)。
readWriteAnyDatabase	可以读写所有数据库中任何数据(除了数据库config和local之外)。
userAdminAnyDatabase	可以在指定数据库创建和修改用户(除了数据库config和local之外)。
dbAdminAnyDatabase	可以读取任何数据库以及对数据库进行清理、修改、压缩、获取统计信息、执行检查等操作(除了数据库config和local之外)。
dbAdmin	可以读取指定数据库以及对数据库进行清理、修改、压缩、获取统计信息、执行检查等操作。
userAdmin	可以在指定数据库创建和修改用户。
clusterAdmin	可以对整个集群或数据库系统进行管理操作。
backup	备份MongoDB数据最小的权限。
restore	从备份文件中还原恢复MongoDB数据(除了system.profile集合)的权限。
root	超级账号，超级权限

二、mongodb 添加用户和权限

1、单实例环境

目标：对单实例的 MongoDB 服务开启安全认证。

单实例指的是未开启副本集或分片的 MongoDB 实例。

2、关闭已开启的 mongodb 服务

1）增加 mongod 的单实例的安全认证功能，可以在服务搭建的时候直接添加，也可以在之前搭建好的服务上添加。

2）使用之前搭建好的服务，需要先停止关闭已开启的 mongodb 服务。

3）停止 mongodb 服务的方式有两种：快速关闭和标准关闭。

4）快速关闭 mongodb 服务的方法（快速，简单，数据可能会出错）

通过系统的 kill 命令直接杀死进程：杀完要检查一下，避免有的没有杀掉。

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

5）快速关闭 mongodb 服务补充说明

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

1）删除 lock 文件：
2）修复数据：


# 删除 lock 文件
rm -f /mongodb/single/data/db/*.lock

# 修复数据
/usr/local/mongodb/bin/mongod --repair --dbpath=/mongodb/single/data/db

6）标准的关闭 mongodb 服务的方法（数据不容易出错，但麻烦）：

通过 mongo 客户端中的 shutdownServer 命令来关闭服务，主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。
mongo --port 27017

//#切换到admin库
use admin

//关闭服务
db.shutdownServer()

3、mongodb 添加用户和权限

1）按照普通无授权认证的配置，来配置服务端的配置文件 /mongodb/single/mongod.conf


# 新建或修改配置文件 mongod.conf
vi /usr/local/mongodb/single/mongod.conf

# 配置文件内容如下（注意 yaml 文件格式）：

systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  # #The path of the log file to which mongod or mongos should send all diagnostic logging information
  destination: file
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: "/usr/local/mongodb/single/log/mongod.log"
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾
  logAppend: true
storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod
  # #The directory where the mongod instance stores its data.Default Value is "/data/db"
  dbPath: "/usr/local/mongodb/single/data/db"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
net:
  #服务实例绑定的IP，默认是localhost
  bindIp: localhost,172.18.30.110
  # bindip
  # 绑定的端口，默认是 27017
  port: 27017

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

/usr/local/mongodb/bin/mongod -f /mongodb/single/mongod.conf

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

3）使用 Mongo 客户端登录：

/usr/local/mongodb/bin/mongo --host 180.76.159.126 --port 27017

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


//切换到admin库
> use admin

//创建系统超级用户 myroot,设置密码 123456，设置角色 root
//> db.createUser({user:"myroot",pwd:"123456",roles:[ { "role" : "root", "db" : "admin" } ]})
//或
> db.createUser({user:"myroot",pwd:"123456",roles:["root"]})
Successfully added user: { "user" : "myroot", "roles" : [ "root" ] }

//创建专门用来管理admin库的账号myadmin，只用来作为用户权限的管理
> db.createUser({user:"myadmin",pwd:"123456",roles:
[{role:"userAdminAnyDatabase",db:"admin"}]})
Successfully added user: {
    "user" : "myadmin",
    "roles" : [
       {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
       }
   ]
}

//查看已经创建了的用户的情况：
> db.system.users.find()

//删除用户
> db.dropUser("myadmin")
true

> db.system.users.find()

//修改密码
> db.changeUserPassword("myroot", "123456")

提示：

1）创建两个用户，分别对应超管和专门用来管理用户的角色，事实上，你只需要一个用户即可。如果你对安全要求很高，防止超管泄漏，则不要创建超管用户。
2）和其它数据库（MySQL）一样，权限的管理都差不多一样，也是将用户和权限信息保存到数据库对应的表中。Mongodb存储所有的用户信息在admin 数据库的集合system.users中，保存用户名、密码和数据库信息。
3）如果不指定数据库，则创建的指定的权限的用户在所有的数据库上有效，如 {role: “userAdminAnyDatabase”, db:“”}

5）认证测试：测试添加的用户是否正确


//切换到admin
> use admin

//密码输错
> db.auth("myroot","12345")
Error: Authentication failed.
0

//密码正确
> db.auth("myroot","123456")
1

6）创建普通用户

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


//创建(切换)将来要操作的数据库articledb,
> use articledb
switched to db articledb

//创建用户，拥有articledb数据库的读写权限readWrite，密码是123456
> db.createUser({user: "bobo", pwd: "123456", roles: [{ role: "readWrite", db:
"articledb" }]})

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

//测试是否可用
> db.auth("bobo","123456")

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

三、mongodb 单实例_服务端开启&客户端登录验证

1、关闭已经启动的 mongodb 服务


# 1）使用 linux 命令杀死进程：
[root@bobohost single]# ps -ef |grep mongo
root    23482    1  0 08:08 ?     00:00:55 /usr/local/mongodb/bin/mongod
-f /mongodb/single/mongod.conf
[root@bobohost single]# kill -2 23482

# 2）在mongo客户端中使用shutdownServer命令来关闭。
> db.shutdownServer()
shutdown command only works with the admin database; try 'use admin'
> use admin
switched to db admin
> db.shutdownServer()

需要几个条件：

必须是在 admin 库下执行该关闭服务命令。
如果没有开启认证，必须是从 localhost 登陆的，才能执行关闭服务命令。
非 localhost 的、通过远程登录的，必须有登录且必须登录用户有对 admin 操作权限才可以。

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

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

1）参数方式：在启动 mongodb 服务时，指定参数 – auth ，如：

/usr/local/mongodb/bin/mongod -f /mongodb/single/mongod.conf --auth

2）配置文件方式：在 mongod.conf 配置文件中加入：
vim /mongodb/single/mongod.con

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

3）配置文件 mongod.conf 具体内容如下：
/mongodb/single/mongod.conf


# 新建或修改配置文件 mongod.conf
vi /usr/local/mongodb/single/mongod.conf

# 配置文件内容如下（注意 yaml 文件格式）：

systemLog:
  # MongoDB发送所有日志输出的目标指定为文件
  # #The path of the log file to which mongod or mongos should send all diagnostic logging information
  destination: file
  # mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
  path: "/usr/local/mongodb/single/log/mongod.log"
  # 当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾
  logAppend: true
storage:
  # mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod
  # #The directory where the mongod instance stores its data.Default Value is "/data/db"
  dbPath: "/usr/local/mongodb/single/data/db"
  journal:
    #启用或禁用持久性日志以确保数据文件保持有效和可恢复
    enabled: true
processManagement:
  #启用在后台运行mongos或mongod进程的守护进程模式
  fork: true
net:
  #服务实例绑定的IP，默认是localhost
  bindIp: localhost,172.18.30.110
  # bindip
  # 绑定的端口，默认是 27017
  port: 27017  
security:
  #开启授权认证
  authorization: enabled

配置文件 mongod.conf 配置好后，启动时可不加 – auth 参数：
/usr/local/mongodb/bin/mongod -f /mongodb/single/mongod.conf

4）开启了认证的情况下的客户端登录，有两种认证方式，一种是先登录，在mongo shell中认证；一种是登录时直接认证。


# 1）先连接再认证
[root@bobohost bin]# /usr/local/mongodb/bin/mongo --host 172.18.30.110 --port 27017

> use admin
switched to db admin
> db.system.users.find()
Error: error: {
    "ok" : 0,
    "errmsg" : "command find requires authentication",
    "code" : 13,
    "codeName" : "Unauthorized"
}
> db.auth("myroot","123456")
1
> db.system.users.find()
Error: error: {
    "ok" : 0,
    "errmsg" : "too many users are authenticated",
    "code" : 13,
    "codeName" : "Unauthorized"
}

提示：
这里可能出现错误，说是太多的用户正在认证了。因为我们确实连续登录了两个用户了。

解决方案：退出 shell，重新进来登录认证。


# 2）连接时直接认证
[root@bobohost ~]# /usr/local/mongodb/bin/mongo --host 180.76.159.126 --port 27017 --authenticationDatabase admin -u myroot -p 123456


> show dbs;
admin    0.000GB
articledb  0.000GB
config   0.000GB
local    0.000GB

> use articledb
switched to db articledb
> db.comment.find()

四、mongodb springData 认证连接

1、springData 认证连接 mongodb

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

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

3）修改配置文件 application.yml 添加用户名、密码，连接到 MongoDB 服务


spring:
 #数据源配置
data:
 mongodb:
   # 主机地址
#   host: 180.76.159.126
   # 数据库
#   database: articledb
   # 默认端口是27017
#   port: 27017
   #帐号
#   username: bobo
   #密码
#   password: 123456
   #单机有认证的情况下，也使用字符串连接
  uri: mongodb://bobo:123456@172.18.30.110:27017/articledb

4）提示：分别测试用户名密码正确以及不正确的情况。

2、使用 Compass 添加用户名、密码，连接到 MongoDB 服务

38-compass连接mongodb.png

五、mongodb 副本集安全认证

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

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

39-副本集安全认证-1.png

2、对副本集执行访问控制需要配置两个方面 :

1）副本集和共享集群的各个节点成员之间使用内部身份验证，可以使用密钥文件或x.509证书。密钥文件比较简单，官方推荐如果是测试环境可以使用密钥文件，但是正式环境，官方推荐x.509证书。原理就是，集群中每一个实例彼此连接的时候都检验彼此使用的证书的内容是否相同。只有证书相同的实例彼此才可以访问。

2）使用客户端连接到 mongodb 集群时，开启访问授权。对于集群外部的访问。如通过可视化客户端，或者通过代码连接的时候，需要开启授权。

3、在 keyfile 身份验证中，副本集中的每个 mongod 实例都使用 keyfile 的内容作为共享密码，只有具有正确密钥文件的 mongod 或者 mongos 实例可以连接到副本集。密钥文件的内容必须在6到1024个字符之间，并且在 unix/linux 系统中文件所有者必须有对文件至少有读的权限。

4、关闭已开启的 mongodb 副本集服务（可选）


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

# 或者：

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

5、通过主节点添加一个管理员帐号

只需要在主节点上添加用户，副本集会自动同步。
开启认证之前，创建超管用户：myroot，密码：123456


myrs:PRIMARY> use admin
switched to db admin
myrs:PRIMARY> db.createUser({user:"myroot",pwd:"123456",roles:["root"]})
Successfully added user: { "user" : "myroot", "roles" : [ "root" ] }

6、创建副本集认证的 key 文件

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

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


[root@bobohost ~]# openssl rand -base64 90 -out ./mongo.keyfile
[root@bobohost ~]# chmod 400 ./mongo.keyfile
[root@bobohost ~]# ll mongo.keyfile
-r--------. 1 root root 122 8月  14 14:23 mongo.keyfile

2）提示：

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

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

3）将该文件分别拷贝到多个目录中：


[root@bobohost ~]# cp mongo.keyfile /mongodb/replica_sets/myrs_27017
[root@bobohost ~]# cp mongo.keyfile /mongodb/replica_sets/myrs_27018
[root@bobohost ~]# cp mongo.keyfile /mongodb/replica_sets/myrs_27019

7、修改配置文件指定 keyfile

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


vim /mongodb/replica_sets/myrs_27017/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/replica_sets/myrs_27017/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/replica_sets/myrs_27018/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/replica_sets/myrs_27018/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/replica_sets/myrs_27019/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/replica_sets/myrs_27019/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

8、重新启动副本集

如果副本集是开启状态，则先分别关闭关闭复本集中的每个mongod，从次节点开始。直到副本集的所有成员都离线，包括任何仲裁者。主节点必须是最后一个成员关闭以避免潜在的回滚。


# 分别启动副本集节点：
/usr/local/mongodb/bin/mongod -f /mongodb/replica_sets/myrs_27017/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/replica_sets/myrs_27018/mongod.conf
/usr/local/mongodb/bin/mongod -f /mongodb/replica_sets/myrs_27019/mongod.conf

# 查看进程情况：
ps -ef | grep mongod

9、在主节点上添加普通账号


#先用管理员账号登录
#切换到admin库
use admin

#管理员账号认证
db.auth("myroot","123456")

#切换到要认证的库
use articledb

#添加普通用户
db.createUser({user: "bobo", pwd: "123456", roles: ["readWrite"]})

重新连接，使用普通用户 bobo重新登录，查看数据。
注意：也要使用rs.status()命令查看副本集是否健康。

10、SpringDataMongoDB 连接副本集

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

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

3）application.yml：


spring:
 #数据源配置
data:
 mongodb:
   #副本集有认证的情况下，字符串连接
  uri:
mongodb://bobo:123456@172.18.30.110:27017,172.18.30.110:27018,172.18.30.110:27019/articledb?connect=replicaSet&slaveOk=true&replicaSet=myrs

六、mongodb 分片集群安全认证

1、关闭已开启的 mongodb 集群服务

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

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

使用之前搭建好的集群服务，需先停止之前的集群服务

# 1）快速关闭方法（快速，简单，数据可能会出错）通过进程编号关闭节点
kill -2 54410

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

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。
mongo --port 27018

//告知副本集说本机要下线
rs.stepDown()

//#切换到admin库
use admin

//关闭服务
db.shutdownServer()

# 关闭配置服务器副本集的服务，建议依次关闭副本节点、主节点。主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。
mongo --port 27019

//告知副本集说本机要下线
rs.stepDown()

//#切换到admin库
use admin

//关闭服务
db.shutdownServer()

# 关闭路由服务器的服务，建议依次关闭两个路由节点。主要的操作步骤参考如下：

//客户端登录服务，注意，这里通过localhost登录，如果需要远程登录，必须先登录认证才行。
mongo --port 27017

//告知副本集说本机要下线
rs.stepDown()

//#切换到admin库
use admin

//关闭服务
db.shutdownServer()

2、创建副本集认证的 key 文件

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

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

[root@bobohost ~]# openssl rand -base64 90 -out ./mongo.keyfile
[root@bobohost ~]# chmod 400 ./mongo.keyfile
[root@bobohost ~]# ll mongo.keyfile
-r--------. 1 root root 122 8月  14 14:23 mongo.keyfile

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

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

4）将该文件分别拷贝到多个目录中：


echo '/mongodb/sharded_cluster/myshardrs01_27018/mongo.keyfile
/mongodb/sharded_cluster/myshardrs01_27118/mongo.keyfile
/mongodb/sharded_cluster/myshardrs01_27218/mongo.keyfile
/mongodb/sharded_cluster/myshardrs02_27318/mongo.keyfile
/mongodb/sharded_cluster/myshardrs02_27418/mongo.keyfile
/mongodb/sharded_cluster/myshardrs02_27518/mongo.keyfile
/mongodb/sharded_cluster/myconfigrs_27019/mongo.keyfile
/mongodb/sharded_cluster/myconfigrs_27119/mongo.keyfile
/mongodb/sharded_cluster/myconfigrs_27219/mongo.keyfile
/mongodb/sharded_cluster/mymongos_27017/mongo.keyfile
/mongodb/sharded_cluster/mymongos_27117/mongo.keyfile' | xargs -n 1 cp -v
/root/mongo.keyfile

3、修改配置文件指定 keyfile

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


vim /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs01_27018/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs01_27118/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs01_27218/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs02_27318/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs02_27418/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myshardrs02_27518/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myconfigrs_27019/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myconfigrs_27119/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/myconfigrs_27219/mongo.keyfile
 #开启认证方式运行
 authorization: enabled

vim /mongodb/sharded_cluster/mymongos_27017/mongos.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/mymongos_27017/mongo.keyfile

vim /mongodb/sharded_cluster/mymongos_27117/mongos.conf

# 在文末追加如下内容：

security:
 #KeyFile鉴权文件
 keyFile: /mongodb/sharded_cluster/mymongos_27117/mongo.keyfil

mongos 比 mongod 少了 authorization：enabled 的配置。原因是，副本集加分片的安全认证需要配置
两方面的，副本集各个节点之间使用内部身份验证，用于内部各个mongo实例的通信，只有相同 keyfile 才能相互访问。所以都要开启 keyFile:
/mongodb/sharded_cluster/mymongos_27117/mongo.keyfile 。

然而对于所有的 mongod，才是真正的保存数据的分片。mongos 只做路由，不保存数据。所以所有的 mongod 开启访问数据的授权 authorization:enabled。这样用户只有账号密码正确才能访问到数据。

4、重新启动节点

必须依次启动配置节点、分片节点、路由节点：

/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myconfigrs_27119/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myconfigrs_27219/mongod.conf

/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs01_27118/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs01_27218/mongod.conf

/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs02_27418/mongod.conf
/usr/local/mongodb/bin/mongod -f
/mongodb/sharded_cluster/myshardrs02_27518/mongod.conf

/usr/local/mongodb/bin/mongos -f
/mongodb/sharded_cluster/mymongos_27017/mongos.conf
/usr/local/mongodb/bin/mongos -f
/mongodb/sharded_cluster/mymongos_27117/mongos.conf

注意：

这里有个非常特别的情况，就是启动顺序。先启动配置节点，再启动分片节点，最后启动路由节点。

如果先启动分片节点，会卡住，提示：
about to fork child process, waiting until server is ready for connections
也许是个 bug。原因未知。

5、创建帐号和认证

1）客户端 mongo，通过 localhost 登录任意一个 mongos 路由，

[root@bobohost db]# /usr/local/mongodb/bin/mongo --port 27017

提示：相当于一个后门，只能在 admin下添加用户。

2）创建一个管理员帐号：

mongos> use admin
switched to db admin
mongos>  db.createUser({user:"myroot",pwd:"123456",roles:["root"]})
Successfully added user: { "user" : "myroot", "roles" : [ "root" ] }

提示：如果在开启认证之前已经创建了管理员账号，这里可以忽略。

3）创建一个普通权限帐号：

mongos> use admin
switched to db admin
mongos> db.auth("myroot","123456")
1
mongos> use articledb
switched to db articledb
mongos> db.createUser({user: "bobo", pwd: "123456", roles: [{ role: "readWrite",
db: "articledb" }]})
Successfully added user: {
"user" : "bobo",
"roles" : [
  {
  "role" : "readWrite",
  "db" : "articledb"
  }
 ]
}
mongos> db.auth("bobo","123456")
1

提示：
通过mongos添加的账号信息，只会保存到配置节点的服务中，具体的数据节点不保存账号信息，因此，分片中的账号信息不涉及到同步问题。

4）mongo客户端登录mongos路由，用管理员帐号登录可查看分片情况：

mongos> use admin
switched to db admin
mongos>  db.auth("myroot","123456")
1
mongos> sh.status()

5）退出连接，重新连接服务，使用普通权限帐号访问数据：

[root@bobohost db]# /usr/local/mongodb/bin/mongo --host 172.18.30.110 --port
27017
MongoDB shell version v4.0.10
connecting to: mongodb://172.18.30.110:27017/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("6f84fa91-2414-407e-b3ab-c0b7eedde825")
}
MongoDB server version: 4.0.10
mongos> use articledb
switched to db articledb
mongos> db.auth("bobo","123456")
1
mongos> show collections
comment
comment2
mongos> db.comment.count()
10001

6、SpringData 连接认证 MongoDB

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

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

3）application.yml：

spring:
 #数据源配置
data:
 mongodb:
   # 分片集群有认证的情况下，字符串连接
  uri:
mongodb://bobo:123456@172.18.30.110:27017,172.18.30.110:27117/articledb

上一节关联文档请点击
# mongodb_基础到进阶 – MongoDB 高级–MongoDB 集群部署与安全性（四）

段子手-168

关注

27
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
# mongodb_基础到进阶 -- MongoDB 高级--MongoDB 集群部署与安全性（五）

# mongodb_基础到进阶 -- MongoDB 高级--MongoDB 集群部署与安全性（五）20 安全认证简介 21 添加用户和权限 22 单实例_服务端开启&客户端登录验证 23 springData认证连接 24 副本集安全认证 25 分片集群安全认证
复制链接

扫一扫