MongoDB 3.0+ 安全权限访问控制

官方文档：

https://docs.mongodb.com/manual/security/

没有安全认证时，进行用户权限管理

如何mongod实例运行没有访问控制之前，增加用户管理员？？

1. 启动没有访问控制 MongoDB服务

例如，以下启动mongod实例没有访问控制。

  1. sudo service mongod start

2. 连接到实例

  1. mongo --port 27017

指定额外的命令行选项来连接Mongo shell到部署Mongodb服务器, 如—host

3. 创建的用户管理员

添加一个userAdminAnyDatabase角色的用户。例如，下面的myuseradmin创建用户myUserAdmin 在admin数据库：

  1. use admin
  2. db.createUser(
  3.   {
  4.     user: "myUserAdmin",
  5.     pwd: "abc123",
  6.     roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  7.   }
  8. )

4. 重新启动MongoDB实例,并启用访问控制。

重新启动mongod实例，如果使用配置文件的设置，security.authorization

  1. sudo vi /etc/mongod.conf

修改内容：

  1. security:
  2.   authorization: enabled

注意：keys and values之间一定要加空格, 否则解析会报错

重启服务

  1. sudo service mongod start

5. 用户管理员身份验证

  • 创建连接mongo shell 时进行授权，指定-u <username>, -p <password>, and the —authenticationDatabase <database>
  1. mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"
  • 或者 mongo shell连接时不认证，使用db.auth()授权
  1. use admin
  2. db.auth("myUserAdmin", "abc123" )

服务器已开启认证后，如何创建用户管理员

首先进行访问控制，然后使用localhost exception添加用户管理员

1. 启动MongoDB实例的访问控制

启动mongod实例 AUTH命令行选项，如果使用配置文件的设置，security.authorization。

  1. sudo service mongod start

2. 通过localhost exception连接MongoDB实例

添加第一个用户, 使用Localhost Exception，连接一个mongod实例。运行Mongo shell和mongod实例必须来自同一主机

Localhost Exception 允许启用访问控制并创建第一个用户在系统中

3.同上创建用户方式相同，不再赘述

普通用户安全访问权限

1. 启动MongoDB:

  1. service mongod start

2. 再次打开 mongo shell：

  1. mongo --port 27017 -u "myUserAdmin" -p "abc123" --authenticationDatabase "admin"

或者

  1. mongo
  2. use admin
  3. db.auth("myUserAdmin", "abc123" )

此时

  1. show collections

报错

  1. 2015-03-17T10:15:56.011+0800 EQUERYError: listCollections failed: {  
  2. "ok" : 0,  
  3. "errmsg" : "not authorized on admin to execute command { listCollections: 1.0 }",  
  4. "code" : 13  
  5. }  
  6.   at Error (<anonymous>)  
  7.   at DB._getCollectionInfosCommand (src/mongo/shell/db.js:643:15)  
  8.   at DB.getCollectionInfos (src/mongo/shell/db.js:655:20)  
  9.   at DB.getCollectionNames (src/mongo/shell/db.js:666:17)  
  10.   at shellHelper.show (src/mongo/shell/utils.js:625:12)  
  11.   at shellHelper (src/mongo/shell/utils.js:524:36)  
  12.   at (shellhelp2):1:1 at src/mongo/shell/db.js:643

因为，用户myUserAdmin只有用户管理的权限。

3. 创建用户，用户都跟着数据库走

  1. use test
  2. db.createUser(  
  3.  {  
  4.     user: "test1",  
  5.     pwd: "test1",  
  6.        roles: [  
  7.           { role: "readWrite", db: "test" }
  8.    ]
  9.  }
  10. )

4. 查看刚刚创建的用户

  1. show users

结果

  1. {  
  2. "_id" : "test.test1",  
  3. "user" : "test1",  
  4. "db" : "test",  
  5. "roles" : [  
  6.     {  
  7.         "role" : "readWrite",  
  8.         "db" : "test"  
  9.     }  
  10.   ]  
  11. }

5. 查看整个mongoDB全部的用户

  1. use admin  
  2. db.system.users.find()  
  3. > db.system.users.find().pretty()
  4. {
  5.     "_id" : "admin.myUserAdmin",
  6.     "user" : "myUserAdmin",
  7.     "db" : "admin",
  8.     "credentials" : {
  9.         "SCRAM-SHA-1" : {
  10.             "iterationCount" : 10000,
  11.             "salt" : "4DvAj1iKzHkAocxvLSHIiw==",
  12.             "storedKey" : "UIyGAiDpVtedBo2COQu77auhLic=",
  13.             "serverKey" : "Nyeq9uCtmEEF5bUxXw3Rf7ZKMvw="
  14.         }
  15.     },
  16.     "roles" : [
  17.         {
  18.             "role" : "userAdminAnyDatabase",
  19.             "db" : "admin"
  20.         }
  21.     ]
  22. }
  23. {
  24.     "_id" : "test.test1",
  25.     "user" : "test1",
  26.     "db" : "test",
  27.     "credentials" : {
  28.         "SCRAM-SHA-1" : {
  29.             "iterationCount" : 10000,
  30.             "salt" : "d9KsgiwkupQS3R4GULhtoQ==",
  31.             "storedKey" : "q0kNcliYpON03zNv9BeeQ1Z9BrE=",
  32.             "serverKey" : "Hw1CypmMNaJI53bbelJtQIACgkA="
  33.         }
  34.     },
  35.     "roles" : [
  36.         {
  37.             "role" : "readWrite",
  38.             "db" : "test"
  39.         }
  40.     ]
  41. }
  42. >

6. 创建完毕，验证一下：

  1. > use test
  2. > db.auth('test1','test1')
  3. 1
  4. > show collections
  5. ypmlist

修改权限

使用updateuser()方法语法以下：

  1. db.updateUser(
  2.    "<username>",
  3.    {
  4.      customData : { <any information> },
  5.      roles : [
  6.                { role: "<role>", db: "<database>" } | "<role>",
  7.                ...
  8.              ],
  9.      pwd: "<cleartext password>"
  10.     },
  11.     writeConcern: { <write concern> }
  12. )
ParameterTypeDescription
usernamestring要更新用户名
updatedocument替换用户数据的文档。此数据完全取代了用户的相应数据。
writeConcerndocument可选，写操作级别

指定要更新的字段和它们的新值。在更新文档中的所有字段都是可选的，但必须至少包含一个字段。更新文档具有以下字段：

FieldTypeDescription
customDatadocument可选。任意信息。
rolesarray可选。授予用户的角色。对角色数组覆盖以前的数组的值更新
pwdstring可选。用户密码

修改权限操作

> use adminswitched to db admin> db.auth("myUserAdmin", "abc123" ) #需要使用管理员权限修改用户信息1use testdb.updateUser( "test1", { pwd: "itcast", customData: { title: "Senior Manager" }, "roles" : [ { "role" : "readWrite", "db" : "test" }, { "role" : "readWrite", "db" : "example" } ] })</div>then

  1. > use admin
  2. switched to db admin    
  3. > db.auth("myUserAdmin", "abc123" )
  4. 1
  5. > db.system.users.find().pretty()
  6. {
  7.     "_id" : "admin.myUserAdmin",
  8.     "user" : "myUserAdmin",
  9.     "db" : "admin",
  10.     "credentials" : {
  11.         "SCRAM-SHA-1" : {
  12.             "iterationCount" : 10000,
  13.             "salt" : "4DvAj1iKzHkAocxvLSHIiw==",
  14.             "storedKey" : "UIyGAiDpVtedBo2COQu77auhLic=",
  15.             "serverKey" : "Nyeq9uCtmEEF5bUxXw3Rf7ZKMvw="
  16.         }
  17.     },
  18.     "roles" : [
  19.         {
  20.             "role" : "userAdminAnyDatabase",
  21.             "db" : "admin"
  22.         }
  23.     ]
  24. }
  25. {
  26.     "_id" : "test.test1",
  27.     "user" : "test1",
  28.     "db" : "test",
  29.     "credentials" : {
  30.         "SCRAM-SHA-1" : {
  31.             "iterationCount" : 10000,
  32.             "salt" : "yTq8U8G5VjGa02iBj4LqhQ==",
  33.             "storedKey" : "wGK5QGAsYrSGaGcVW4rFQlLrbvk=",
  34.             "serverKey" : "j/oSYGCF2+oG3SmoiHweF5xYzyw="
  35.         }
  36.     },
  37.     "roles" : [
  38.         {
  39.             "role" : "readWrite",
  40.             "db" : "test"
  41.         },
  42.         {
  43.             "role" : "readWrite",
  44.             "db" : "example"
  45.         }
  46.     ],
  47.     "customData" : {
  48.         "title" : "Senior Manager"
  49.     }
  50. }
  51. >

验证结果：

  1. > use admin
  2. switched to db admin
  3. > db.auth('test1','itcast')
  4. Error: Authentication failed.
  5. 0
  6. > use test
  7. switched to db test
  8. > db.auth('test1','itcast')
  9. 1
  10. > use example
  11. switched to db example
  12. > show collections
  13. col
  14. itcast
  15. mycol

总结：用户信息存放在 第一次保存认证数据库users表里面

比如说：test1用户能够访问example、test数据库；但是用户信息存放在test的数据库

超级用户

  1. use admin
  2. db.createUser(
  3.     {
  4.         user: "itcast",
  5.         pwd: "itcast",
  6.         roles: [ { role: "root", db: "admin" } ]
  7.     }
  8. )

以下是系统默认角色

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