默认情况下，MongoDB实例启动运行时是没有启用用户访问权限控制的，也就是说，在实例本机服务器上都可以随意连接到实例进行各种操作，MongoDB默认不会对连接客户端进行用户验证，在实际开发中无权限访问操作非常危险。
Mongodb存储所有的用户信息在 admin 数据库的集合 system.users中，保存用户名、密码和数据库信息。
如果不指定数据库，则创建的指定的权限的用户在所有的数据库上有效。

角色：

角色说明：

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

常用角色配置：

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

单机配置：

这里以《MongoDB安装》章节搭建的环境为例进行演示

管理用户创建：

登录单机MongoDB，选择 admin 数据库进行角色创建

  1. #使用单机MongoDB配置进行登录
  2. /usr/local/mongo/bin/mongod -f /mongod.conf 
  4. #选择数据库
  5. use admin
  7. #创建超级用户
  8. db.createUser({user:"myroot",pwd:"123456",roles:["root"]})                                
  10. #创建专门用来管理admin库的账号myadmin，只用来作为用户权限的管理
  11. db.createUser({user:"myadmin",pwd:"123456",roles:[{role:"userAdminAnyDatabase",db:"admin"}]})

查看所有角色创建目录：

  1. db.system.users.find().pretty()                                                        需切换到admin库，格式化输出角色数据
  1.  ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21405095/1626855246888-899c0472-2cb6-4074-a6be-e1fc612c9a7f.png#clientId=u81a83289-b881-4&from=paste&height=377&id=u242f3d15&margin=%5Bobject%20Object%5D&name=image.png&originHeight=753&originWidth=700&originalType=binary&ratio=1&size=61608&status=done&style=stroke&taskId=u29ac7d5a-7df4-4527-85c5-c2abc93a8c2&width=350)<br />**角色配置成功**

验证角色配置可用性：

  1. use admin                                                                                                                    选择admin数据库
  2. db.auth("myroot","12345")                                                                                    输入错误的密码，返回错误信息
  3. db.auth("myroot","123456")                                                                                验证成功，返回1

image.png
验证成功

普通用户创建：

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

  1. #切换到目标数据库
  2. use articledb                                                                                                                            
  4. #创建用户，拥有articledb数据库的读写权限readWrite，密码是123456
  5. db.createUser({user: "bobo", pwd: "123456", roles: [{ role: "readWrite", db:"articledb" }]})
  7. #测试可用性
  8. db.auth("bobo","123456")

开启认证登录：

开启认证登录后，在未登录角色账号的情况下无法对MongoDB进行任何操作
参数方式开启：

  1. /usr/local/mongodb/bin/mongod -f mongod.conf --auth                                                参数开启认证,不推荐

配置文件方式开启：
在配置文件中添加认证

  1. security:
  2.     #开启授权认证
  3.     authorization: enabled

image.png
修改配置文件

用户登录：

开启认证配置后进入Shell界面，每个MongoShell只能认证一个用户，当已经使用 A 数据库的用户认证后，其他数据库的用户将无法认证，需要先退出再进行认证

  1. use admin                                                                                                                        使用admin 数据库
  2. db.system.users.find()                                                                                          未认证下进行查询操作将报错
  3. db.auth("myroot","123456")                                                                                    进行用户认证
  4. db.system.users.find()                                                                                            再次查询数据，成功返回
  1.  ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21405095/1626858122324-7efd7c98-c7e1-4d05-8e22-f35702a529e8.png#clientId=ubd0783f6-3d05-4&from=paste&height=129&id=ubc862b03&margin=%5Bobject%20Object%5D&name=image.png&originHeight=305&originWidth=1656&originalType=binary&ratio=1&size=80930&status=done&style=stroke&taskId=u213233f1-231b-45f9-b0ae-2fb460cbbf3&width=700)<br />**未认证下无法进行任何操作，认证后数据查询成功**

切换数据库后进行再次认证，提示用户过多，需要先退出Shell再重新选择数据库进行用户认证才能完成操作

  1. use articledb                                                                                                                使用articledb数据库
  2. db.comment.find()                                                                                                未认证下进行查询操作将报错
  3. db.auth("bobo","123456")                                                                                      进行用户认证
  4. db.comment.find()                                                                                                  再次查询数据，成功返回
  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21405095/1626858309927-eb4279a5-6d2a-47f5-a3be-716e0fb00632.png#clientId=ubbfead7a-393c-4&from=paste&height=99&id=uaecaa1a5&margin=%5Bobject%20Object%5D&name=image.png&originHeight=204&originWidth=1437&originalType=binary&ratio=1&size=19644&status=done&style=stroke&taskId=uf12c2dba-4a69-4bee-8b2d-515a82cb8f0&width=700)<br />**     已经认证了admin的用户，此时在认证articledb的用户将会超出认证数量限制**

一键登录：
在登录命令中直接指定需要操作的数据库和用户信息即可实现访问

  1. /usr/local/mongo/bin/mongo  --port 端口号 --authenticationDatabase 数据库 -u 用户名 -p 密码

SpringBoot整合：

指定用户名、密码、操作的数据库、端口即可

  1. #uri的效果和注释的四条注解一致
  3. spring:
  4.   data:
  5.     mongodb:
  6.             uri: mongodb://bobo:123456@192.168.182.147:27017/articledb
  7.       #username: bobo
  8.       #password: 123456
  9.       #database: articledb
  10.       #host: 192.168.182.147:27017

复制集配置：

对于用户账号，只需要在主节点上添加用户，副节点即会自动同步；外部访问需要认证用户，且复制集和分片集群内的各个节点需要使用秘钥文件来进行认证
所有副本集节点都必须要用同一份keyfile，一般是在一台机器上生成，然后拷贝到其他机器上，且必须有读的权限，否则会报错：permissions on 秘钥文件路径 are too open
这里以《复制集》章节搭建的集群为例进行演示

管理用户添加：

  1. #启用副本集
  2. /usr/local/mongo/bin/mongod -f /mongodb/replica_sets/myrs_27017/mongod.conf
  3. /usr/local/mongo/bin/mongod -f /mongodb/replica_sets/myrs_27018/mongod.conf
  4. /usr/local/mongo/bin/mongod -f /mongodb/replica_sets/myrs_27019/mongod.conf
  7. #切换数据库并添加管理员用户
  8. use admin                                                                                                                                        
  9. db.createUser({user:"myroot",pwd:"123456",roles:["root"]})


创建秘钥文件：

  1. openssl rand -base64 90 -out ./mongo.keyfile
  2. chmod 400 ./mongo.keyfile                                                                                                设置为对当前用户可读
  3. ll mongo.keyfile

image.png
创建秘钥文件成功

将秘钥文件拷贝到具体的文件夹（模拟集群位于不同的Linux主机）

  1. cp mongo.keyfile /mongodb/replica_sets/myrs_27017
  2. cp mongo.keyfile /mongodb/replica_sets/myrs_27018
  3. cp mongo.keyfile /mongodb/replica_sets/myrs_27019

修改各节点配置文件：
依次修改27017、27018、27019节点的配置文件，添加 security 参数即可，这里以 27017节点为例进行演示

  1. vim /mongodb/replica_sets/myrs_27017/mongod.conf
  1. systemLog:
  2.    destination: file
  3.    path: "/mongodb/replica_sets/myrs_27017/log/mongod.log"
  4.    logAppend: true
  5. storage:
  6.    dbPath: "/mongodb/replica_sets/myrs_27017/data/db"
  7.    journal:
  8.       enabled: true
  9. processManagement:
  10.    fork: true
  11.    pidFilePath: "/mongodb/replica_sets/myrs_27017/log/mongod.pid"
  12. net:
  13.    bindIp: 0.0.0.0
  14.    port: 27017
  15. replication:
  16.    replSetName: myrs
  17. security:
  18.    #KeyFile鉴权文件
  19.    keyFile: /mongodb/replica_sets/myrs_27017/mongo.keyfile
  20.    #开启认证方式运行
  21.    authorization: enabled

重启服务：
依次停止各个节点服务并进行重启，停止方式参考《复制集》章节的“关闭副本集”操作

普通用户添加：

切换到复制集的主节点，创建和单机配置中相同的用户账号

  1. #切换数据库
  2. use admin
  4. #管理员账号认证
  5. db.auth("myroot","123456")
  7. #切换到需要创建用户账号的数据库
  8. use articledb
  10. #创建用户账号
  11. db.createUser({user: "bobo", pwd: "123456", roles: ["readWrite"]})

SpringBoot整合：

和单机认证一致，在未认证的基础上添加用户名:密码即可

  1. spring:
  2.   data:
  3.     mongodb:
  4.       uri: mongodb://bobo:123456@192.168.182.147:27017,192.168.182.147:27018,192.168.182.147:27019/articledb??maxIdleTimeMS=3000&connect=replicaSet&slaveOk=true&replicaSet=myrs

分片集群配置：

分片集群环境下的认证和复制集一致，各个节点之间都需要使用秘钥文件进行认证。如果在添加认证之前已存入数据，应先进行数据备份然后再还原，数据备份操作参考《MongoExport》章节，这里以《数据分片》章节搭建环境进行讲解
通过mongos添加的账号信息，只会保存到配置服务器节点中，具体的数据节点不保存账号信息，因 此，分片中的账号信息不涉及到同步问题。

创建秘钥文件：

  1. openssl rand -base64 90 -out ./mongo.keyfile
  2. chmod 400 ./mongo.keyfile                                                                                                设置为对当前用户可读
  3. ll mongo.keyfile

image.png
创建秘钥文件成功

拷贝到分片集群各节点目录中：

  1. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs01_27018/
  2. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs01_27118/
  3. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs01_27218/
  6. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs02_27318/
  7. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs02_27418/
  8. cp mongo.keyfile /mongodb/sharded_cluster/myshardrs02_27518/
  11. cp mongo.keyfile /mongodb/sharded_cluster/myconfigrs_27019/
  12. cp mongo.keyfile /mongodb/sharded_cluster/myconfigrs_27119/
  13. cp mongo.keyfile /mongodb/sharded_cluster/myconfigrs_27219/
  16. cp mongo.keyfile /mongodb/sharded_cluster/mymongos_27017/
  17. cp mongo.keyfile /mongodb/sharded_cluster/mymongos_27117/

修改配置文件：
mongos不需要认证，因此比mongod少了authorization：enabled的配置。配置文件修改方式参考复制集配置，这里各举一例：

副本集一 27018 节点修改：

  1.  vim /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf
  1. systemLog:
  2.    destination: file
  3.    path: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.log"
  4.    logAppend: true
  5. storage:
  6.    dbPath: "/mongodb/sharded_cluster/myshardrs01_27018/data/db"
  7.    journal:
  8.       enabled: true
  9. processManagement:
  10.    fork: true
  11.    pidFilePath: "/mongodb/sharded_cluster/myshardrs01_27018/log/mongod.pid"
  12. net:
  13.    bindIp: 0.0.0.0
  14.    port: 27018
  15. replication:
  16.    replSetName: myshardrs01
  17. sharding:
  18.    #分片角色
  19.    clusterRole: shardsvr
  20. security:
  21.    #KeyFile鉴权文件
  22.    keyFile: /mongodb/sharded_cluster/myshardrs01_27018/mongo.keyfile
  23.    #开启认证方式运行
  24.    authorization: enabled

副本集二 27318 节点修改：

  1. vim /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf
  1. systemLog:
  2.    destination: file
  3.    path: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.log"
  4.    logAppend: true
  5. storage:
  6.    dbPath: "/mongodb/sharded_cluster/myshardrs02_27318/data/db"
  7.    journal:
  8.       enabled: true
  9. processManagement:
  10.    fork: true
  11.    pidFilePath: "/mongodb/sharded_cluster/myshardrs02_27318/log/mongod.pid"
  12. net:
  13.    bindIp: 0.0.0.0
  14.    port: 27318
  15. replication:
  16.    replSetName: myshardrs02
  17. sharding:
  18.    #分片角色
  19.    clusterRole: shardsvr
  20. security:
  21.    #KeyFile鉴权文件
  22.    keyFile: /mongodb/sharded_cluster/myshardrs02_27318/mongo.keyfile
  23.    #开启认证方式运行
  24.    authorization: enabled

配置服务器 27019节点修改：

  1. vim /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf
  1. systemLog:
  2.    destination: file
  3.    path: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.log"
  4.    logAppend: true
  5. storage:
  6.    dbPath: "/mongodb/sharded_cluster/myconfigrs_27019/data/db"
  7.    journal:
  8.       enabled: true
  9. processManagement:
  10.    fork: true
  11.    pidFilePath: "/mongodb/sharded_cluster/myconfigrs_27019/log/mongod.pid"
  12. net:
  13.    bindIp: 0.0.0.0
  14.    port: 27019
  15. replication:
  16.    replSetName: myconfigrs
  17. sharding:
  18.    clusterRole: configsvr
  19. security:
  20.    #KeyFile鉴权文件
  21.    keyFile: /mongodb/sharded_cluster/myconfigrs_27019/mongo.keyfile
  22.    #开启认证方式运行
  23.    authorization: enabled

MongOS 27017节点修改：

  1. vi /mongodb/sharded_cluster/mymongos_27017/mongos.conf
  1. systemLog:
  2.    destination: file
  3.    path: "/mongodb/sharded_cluster/mymongos_27017/log/mongod.log"
  4.    logAppend: true
  5. processManagement:
  6.    fork: true
  7.    pidFilePath: "/mongodb/sharded_cluster/mymongos_27017/log/mongod.pid"
  8. net:
  9.    bindIp: 0.0.0.0
  10.    port: 27017
  11. sharding:
  12.    #指定配置节点副本集
  13.      configDB: myconfigrs/192.168.182.147:27019,192.168.182.147:27119,192.168.182.147:27219
  14. security:
  15.       #KeyFile鉴权文件
  16.       keyFile: /mongodb/sharded_cluster/mymongos_27017/mongo.keyfile

创建用户：

按照配置节点 > 分片节点 > 路由节点的顺序启动分片集群，先启动分片节点会提示启动失败，原因不明

  1. #配置节点启动:
  2. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27019/mongod.conf  
  3. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27119/mongod.conf  
  4. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myconfigrs_27219/mongod.conf
  8. #副本节点启动:
  9. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27018/mongod.conf  
  10. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27118/mongod.conf  
  11. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs01_27218/mongod.conf  
  13. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27318/mongod.conf  
  14. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27418/mongod.conf  
  15. /usr/local/mongo/bin/mongod -f /mongodb/sharded_cluster/myshardrs02_27518/mongod.conf  
  19. #MongOS节点启动:
  20. /usr/local/mongo/bin/mongos -f /mongodb/sharded_cluster/mymongos_27017/mongos.conf 
  21. /usr/local/mongo/bin/mongos -f /mongodb/sharded_cluster/mymongos_27117/mongos.conf

登录任意一个MongOS路由进行用户添加操作：

  1. #切换数据库创建管理员:
  2. use admin
  3. db.createUser({user:"myroot",pwd:"123456",roles:["root"]})
  6. #验证管理员切换数据库创建普通用户:
  7. use articledb
  8. db.auth("myroot","123456")
  9. db.createUser({user: "bobo", pwd: "123456", roles: [{ role: "readWrite",db: "articledb" }]})

SpringBoot整合：

  1. spring:
  2.   data:
  3.     mongodb:
  4.       uri: mongodb://bobo:123456@192.168.182.147:27017,192.168.182.147:27117/articledb