MongoDB 的用户和角色权限

副本和分片集群的安全设置参考这个：高级：https://files.cnblogs.com/files/sanduzxcvbnm/mongodb_advance.pdf

默认情况下，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)组成。

1. 资源(resource)包括：数据库、集合、部分集合和集群；
2. 操作(action)包括：对资源进行的增、删、改、查(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: [
      "<rolename>",
     { role: "<rolename>", db: "<database>" },
      ...
   ]  
 }
)

示例：

查看所有内置角色：

> 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
}

常用的内置角色：

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

角色说明：

单实例环境

添加用户和权限

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

systemLog:
 #MongoDB发送所有日志输出的目标指定为文件
 destination: file
 #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径
 path: "/mongodb/single/log/mongod.log"
 #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾。
 logAppend: true
storage:
 #mongod实例存储其数据的目录。storage.dbPath设置仅适用于mongod。
 dbPath: "/mongodb/single/data/db"
 journal:
   #启用或禁用持久性日志以确保数据文件保持有效和可恢复。
  enabled: true
processManagement:
 #启用在后台运行mongos或mongod进程的守护进程模式。
 fork: true
 #指定用于保存mongos或mongod进程的进程ID的文件位置，其中mongos或mongod将写入其PID
（2）按之前未开启认证的方式（不添加 -- auth 参数）来启动MongoDB服务：
提示：
在操作用户时，启动mongod服务时尽量不要开启授权。
（3）使用Mongo客户端登录：
（4）创建两个管理员用户，一个是系统的超级管理员 myroot ，一个是admin库的管理用户
myadmin ：
 pidFilePath: "/mongodb/single/log/mongod.pid"
net:
 #服务实例绑定的IP
 bindIp: localhost,192.168.0.2
 #绑定的端口
 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")
1

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

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

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

1）参数方式

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

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

2）配置文件方式

在mongod.conf配置文件中加入：vim /mongodb/single/mongod.conf

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

启动时可不加 -- auth 参数：

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

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

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

1）先连接再认证

[root@bobohost bin]# /usr/local/mongodb/bin/mongo --host 180.76.159.126 --port
27017
MongoDB shell version v4.0.10
connecting to: mongodb://180.76.159.126:27017/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("53fef661-35d6-4d29-b07c-020291d62e1a")
}
MongoDB server version: 4.0.10
>

提示：

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

相关操作需要认证才可以：

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

> 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()

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

> use articledb
switched to db articledb
> db.comment.find()
Error: error: {
    "ok" : 0,
    "errmsg" : "not authorized on articledb to execute command { find:
\"comment\", filter: {}, lsid: { id: UUID(\"53fef661-35d6-4d29-b07c-
020291d62e1a\") }, $db: \"articledb\" }",
    "code" : 13,
    "codeName" : "Unauthorized"
}
> db.auth("bobo","123456")
1
> db.comment.find()
Error: error: {
    "ok" : 0,
    "errmsg" : "too many users are authenticated",
    "code" : 13,
    "codeName" : "Unauthorized"
}

提示：

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

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

> exit
bye
[root@bobohost bin]# ./mongo --host 180.76.159.126 --port 27017
MongoDB shell version v4.0.10
connecting to: mongodb://180.76.159.126:27017/?gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("329c1897-566d-4231-bcb3-b2acda301863")
}
MongoDB server version: 4.0.10
> db.auth("bobo","123456")
Error: Authentication failed.
0
> use articledb
switched to db articledb
> db.auth("bobo","123456")
1
> db.comment.find()
>

2）连接时直接认证

对admin数据库进行登录认证和相关操作：

[root@bobohost ~]# /usr/local/mongodb/bin/mongo --host 180.76.159.126 --port
27017 --authenticationDatabase admin -u myroot -p 123456
MongoDB shell version v4.0.10
connecting to: mongodb://180.76.159.126:27017/?
authSource=admin&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("f959b8d6-6994-44bc-9d35-09fc7cd00ba6")
}
MongoDB server version: 4.0.10
Server has startup warnings:
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten] ** WARNING: You are
running this process as the root user, which is not recommended.
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten]
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten]
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten] ** WARNING:
/sys/kernel/mm/transparent_hugepage/enabled is 'always'.
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten] **    We suggest
setting it to 'never'
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten]
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten] ** WARNING:
/sys/kernel/mm/transparent_hugepage/defrag is 'always'.
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten] **    We suggest
setting it to 'never'
2019-09-10T15:23:40.102+0800 I CONTROL [initandlisten]
> show dbs;
admin    0.000GB
articledb  0.000GB
config   0.000GB
local    0.000GB

对articledb数据库进行登录认证和相关操作：

[root@bobohost bin]# /usr/local/mongodb/bin/mongo --host 180.76.159.126 --port
27017 --authenticationDatabase articledb -u bobo -p 123456
MongoDB shell version v4.0.10
connecting to: mongodb://180.76.159.126:27017/?
authSource=articledb&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("e5d4148f-373b-45b8-9cff-a927ce617100")
}
MongoDB server version: 4.0.10
> use articledb
switched to db articledb
> db.comment.find()

提示：

• -u ：用户名
• -p ：密码
• --authenticationDatabase ：指定连接到哪个库。当登录是指定用户名密码时，必须指定对应的
  
  数据库！