上一篇博客主要聊了下mongodb的分片机制以及分片集群的搭建，回顾请参考https://www.cnblogs.com/qiuhom-1874/p/13958295.html；今天我们来了解下mongodb的访问控制；

　　什么是访问控制？

　　简单讲访问控制就是指，那些用户可以访问那些资源，对资源有哪些操作（权限）；在mongodb中我们把数据库、或者集合叫做资源；也就说访问控制是用来限制某些用户对数据库或集合的操作；我们在mysql数据库中，我们通过给账号授权的方式达到控制那些用户可以从那些主机访问数据库，对数据库有哪些操作；其中账号由用户名称和主机地址构成；在mongodb中采用的不是用户+主机地址的方式，而是通过给用户赋予一个或多个角色，这个角色或多个角色的所有权限就是这个用户拥有的权限；默认情况mongodb是没有启用访问控制的，所以只要能够连接上mongodb实例，我们就可以在其上做任何操作，在某种程度上，这是一种极为不安全的方式，为了杜绝这种不安全的访问方式，我们需要对mongodb进行访问控制；

　　mongodb中的角色权限说明

　　mongodb默认内置了一些角色，不同的角色拥有不同的权限，如下图

　　查看mongodb中某个数据库所有内置角色

  1. > db.runCommand({rolesInfo:1,showBuiltinRoles:true})
  2. {
  3.         "roles" : [
  4.                 {
  5.                         "role" : "dbAdmin",
  6.                         "db" : "test",
  7.                         "isBuiltin" : true,
  8.                         "roles" : [ ],
  9.                         "inheritedRoles" : [ ]
  10.                 },
  11.                 {
  12.                         "role" : "dbOwner",
  13.                         "db" : "test",
  14.                         "isBuiltin" : true,
  15.                         "roles" : [ ],
  16.                         "inheritedRoles" : [ ]
  17.                 },
  18.                 {
  19.                         "role" : "enableSharding",
  20.                         "db" : "test",
  21.                         "isBuiltin" : true,
  22.                         "roles" : [ ],
  23.                         "inheritedRoles" : [ ]
  24.                 },
  25.                 {
  26.                         "role" : "read",
  27.                         "db" : "test",
  28.                         "isBuiltin" : true,
  29.                         "roles" : [ ],
  30.                         "inheritedRoles" : [ ]
  31.                 },
  32.                 {
  33.                         "role" : "readWrite",
  34.                         "db" : "test",
  35.                         "isBuiltin" : true,
  36.                         "roles" : [ ],
  37.                         "inheritedRoles" : [ ]
  38.                 },
  39.                 {
  40.                         "role" : "userAdmin",
  41.                         "db" : "test",
  42.                         "isBuiltin" : true,
  43.                         "roles" : [ ],
  44.                         "inheritedRoles" : [ ]
  45.                 }
  46.         ],
  47.         "ok" : 1
  48. }
  49. >

　　提示：以上是mongodb中test库的默认角色；如果要查看其它库，我们需要切换到其他库，然后运行上述命令查看即可；

　　查询当前数据中的某个角色

  1. > db
  2. test
  3. > db.runCommand({rolesInfo:"userAdmin"})
  4. {
  5.         "roles" : [
  6.                 {
  7.                         "role" : "userAdmin",
  8.                         "db" : "test",
  9.                         "isBuiltin" : true,
  10.                         "roles" : [ ],
  11.                         "inheritedRoles" : [ ]
  12.                 }
  13.         ],
  14.         "ok" : 1
  15. }
  16. >

　　查询其他数据库中指定的角色权限

  1. > db.runCommand({rolesInfo:{role:"userAdmin",db:"config"}})
  2. {
  3.         "roles" : [
  4.                 {
  5.                         "role" : "userAdmin",
  6.                         "db" : "config",
  7.                         "isBuiltin" : true,
  8.                         "roles" : [ ],
  9.                         "inheritedRoles" : [ ]
  10.                 }
  11.         ],
  12.         "ok" : 1
  13. }
  14. > db.runCommand({rolesInfo:{role:"root",db:"config"}})
  15. { "roles" : [ ], "ok" : 1 }
  16. > db.runCommand({rolesInfo:{role:"root",db:"admin"}})
  17. {
  18.         "roles" : [
  19.                 {
  20.                         "role" : "root",
  21.                         "db" : "admin",
  22.                         "isBuiltin" : true,
  23.                         "roles" : [ ],
  24.                         "inheritedRoles" : [ ]
  25.                 }
  26.         ],
  27.         "ok" : 1
  28. }
  29. >

　　创建一个用户名为tom，其角色为超级管理员角色root

  1. > use admin
  2. switched to db admin
  3. > db.createUser({user:"tom",pwd:"admin123.com",roles:[{"role":"root","db":"admin"}]})
  4. Successfully added user: {
  5.         "user" : "tom",
  6.         "roles" : [
  7.                 {
  8.                         "role" : "root",
  9.                         "db" : "admin"
  10.                 }
  11.         ]
  12. }
  13. >

　　查看当前库用户列表

  1. > db
  2. admin
  3. > db.getUsers()
  4. [
  5.         {
  6.                 "_id" : "admin.tom",
  7.                 "userId" : UUID("67bf434a-49fc-4ed5-9e9b-23c443a2fc93"),
  8.                 "user" : "tom",
  9.                 "db" : "admin",
  10.                 "roles" : [
  11.                         {
  12.                                 "role" : "root",
  13.                                 "db" : "admin"
  14.                         }
  15.                 ],
  16.                 "mechanisms" : [
  17.                         "SCRAM-SHA-1",
  18.                         "SCRAM-SHA-256"
  19.                 ]
  20.         }
  21. ]
  22. >

　　创建数据库管理员用户

  1. > db.createUser({user:"jerry",pwd:"admin123.com",roles:["userAdminAnyDatabase"]})
  2. Successfully added user: { "user" : "jerry", "roles" : [ "userAdminAnyDatabase" ] }
  3. > db.getUsers()
  4. [
  5.         {
  6.                 "_id" : "admin.jerry",
  7.                 "userId" : UUID("5d0b77f2-b7f1-40cd-8149-f08b2e1e6a80"),
  8.                 "user" : "jerry",
  9.                 "db" : "admin",
  10.                 "roles" : [
  11.                         {
  12.                                 "role" : "userAdminAnyDatabase",
  13.                                 "db" : "admin"
  14.                         }
  15.                 ],
  16.                 "mechanisms" : [
  17.                         "SCRAM-SHA-1",
  18.                         "SCRAM-SHA-256"
  19.                 ]
  20.         },
  21.         {
  22.                 "_id" : "admin.tom",
  23.                 "userId" : UUID("67bf434a-49fc-4ed5-9e9b-23c443a2fc93"),
  24.                 "user" : "tom",
  25.                 "db" : "admin",
  26.                 "roles" : [
  27.                         {
  28.                                 "role" : "root",
  29.                                 "db" : "admin"
  30.                         }
  31.                 ],
  32.                 "mechanisms" : [
  33.                         "SCRAM-SHA-1",
  34.                         "SCRAM-SHA-256"
  35.                 ]
  36.         }
  37. ]
  38. >

　　提示：如果创建用户时，未指定db，则表示当前该用户对当前所在db生效；

　　删除用户

  1. > db.dropUser("jerry")
  2. true
  3. > db.getUsers()
  4. [
  5.         {
  6.                 "_id" : "admin.tom",
  7.                 "userId" : UUID("67bf434a-49fc-4ed5-9e9b-23c443a2fc93"),
  8.                 "user" : "tom",
  9.                 "db" : "admin",
  10.                 "roles" : [
  11.                         {
  12.                                 "role" : "root",
  13.                                 "db" : "admin"
  14.                         }
  15.                 ],
  16.                 "mechanisms" : [
  17.                         "SCRAM-SHA-1",
  18.                         "SCRAM-SHA-256"
  19.                 ]
  20.         }
  21. ]
  22. >

　　提示：删除用户，需切换到对应数据下，指定对应用户名称即可；在mongodb中用户是对应数据库的，一个用户可以对应一个或多个数据库，在指定数据库删除用户，就表示删除指定用户对指定数据库的访问权限；

　　修改指定用户的密码

  1. > db
  2. admin
  3. > db.changeUserPassword("tom","123456")
  4. >

　　提示：修改用户密码，第一个是指定用户的名称，第二个是指定新密码；

　　验证用户名和密码

　　给错误的密码

  1. > db
  2. admin
  3. > db.auth("tom","admin")
  4. Error: Authentication failed.
  5. 0
  6. >

　　给正确的密码

  1. > db
  2. admin
  3. > db.auth("tom","123456")
  4. 1
  5. >

　　创建一个普通用户

  1. > use testdb
  2. switched to db testdb
  3. > db.createUser({user:"test",pwd:"admin",roles:[{role:"readWrite",db:"testdb"}]})
  4. Successfully added user: {
  5.         "user" : "test",
  6.         "roles" : [
  7.                 {
  8.                         "role" : "readWrite",
  9.                         "db" : "testdb"
  10.                 }
  11.         ]
  12. }
  13. > db.getUsers()
  14. [
  15.         {
  16.                 "_id" : "testdb.test",
  17.                 "userId" : UUID("95ecb34c-46f4-44fa-8948-4f0875499d8e"),
  18.                 "user" : "test",
  19.                 "db" : "testdb",
  20.                 "roles" : [
  21.                         {
  22.                                 "role" : "readWrite",
  23.                                 "db" : "testdb"
  24.                         }
  25.                 ],
  26.                 "mechanisms" : [
  27.                         "SCRAM-SHA-1",
  28.                         "SCRAM-SHA-256"
  29.                 ]
  30.         }
  31. ]
  32. >

　　提示：以上就创建了一个名为test的用户，它可对testdb这个库下的所有collection做读写操作；

　　创建一个多角色的用户

  1. > db
  2. testdb
  3. > db.createUser(
  4. ... {
  5. ... user:"jerry1",
  6. ... pwd:"admin123.com",
  7. ... roles:[
  8. ... {role:"clusterAdmin",db:"admin"},
  9. ... {role:"readWrite",db:"testdb"},
  10. ... {role:"read",db:"testdb1"}
  11. ... ]
  12. ... })
  13. Successfully added user: {
  14.         "user" : "jerry1",
  15.         "roles" : [
  16.                 {
  17.                         "role" : "clusterAdmin",
  18.                         "db" : "admin"
  19.                 },
  20.                 {
  21.                         "role" : "readWrite",
  22.                         "db" : "testdb"
  23.                 },
  24.                 {
  25.                         "role" : "read",
  26.                         "db" : "testdb1"
  27.                 }
  28.         ]
  29. }
  30. > db.getUsers()
  31. [
  32.         {
  33.                 "_id" : "testdb.jerry1",
  34.                 "userId" : UUID("43d66bf8-1e3a-4c14-ad73-5961b5a7660f"),
  35.                 "user" : "jerry1",
  36.                 "db" : "testdb",
  37.                 "roles" : [
  38.                         {
  39.                                 "role" : "clusterAdmin",
  40.                                 "db" : "admin"
  41.                         },
  42.                         {
  43.                                 "role" : "readWrite",
  44.                                 "db" : "testdb"
  45.                         },
  46.                         {
  47.                                 "role" : "read",
  48.                                 "db" : "testdb1"
  49.                         }
  50.                 ],
  51.                 "mechanisms" : [
  52.                         "SCRAM-SHA-1",
  53.                         "SCRAM-SHA-256"
  54.                 ]
  55.         },
  56.         {
  57.                 "_id" : "testdb.test",
  58.                 "userId" : UUID("95ecb34c-46f4-44fa-8948-4f0875499d8e"),
  59.                 "user" : "test",
  60.                 "db" : "testdb",
  61.                 "roles" : [
  62.                         {
  63.                                 "role" : "readWrite",
  64.                                 "db" : "testdb"
  65.                         }
  66.                 ],
  67.                 "mechanisms" : [
  68.                         "SCRAM-SHA-1",
  69.                         "SCRAM-SHA-256"
  70.                 ]
  71.         }
  72. ]
  73. >

　　提示：在mongodb中一个用户可以授权拥有多个角色权限；

　　开启mongodb服务端访问控制配置

　　重启服务

  1. [root@node12 ~]# systemctl restart mongod.service
  2. [root@node12 ~]# ss -tnl
  3. State      Recv-Q Send-Q         Local Address:Port                        Peer Address:Port
  4. LISTEN     0      128                        *:22                                     *:*
  5. LISTEN     0      100                127.0.0.1:25                                     *:*
  6. LISTEN     0      128                        *:27017                                  *:*
  7. LISTEN     0      128                       :::22                                    :::*
  8. LISTEN     0      100                      ::1:25                                    :::*
  9. [root@node12 ~]#

　　测试：现在连接mongodb，看看会发生什么？

  1. [root@node12 ~]# mongo
  2. MongoDB shell version v4.4.1
  3. connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
  4. Implicit session: session { "id" : UUID("68fa2f83-64a4-42c2-8d64-9ee73a77e883") }
  5. MongoDB server version: 4.4.1
  6. > show dbs
  7. > db
  8. test
  9. > show tables
  10. Warning: unable to run listCollections, attempting to approximate collection names by parsing connectionStatus
  11. >

　　提示：现在我们直接连接mongodb是可以正常连接，但是我们没法查看数据列表以及collections了；这个时候我们就需要进行用户认证了；

　　认证用户

  1. > db
  2. test
  3. > db.auth("test","admin")
  4. Error: Authentication failed.
  5. 0
  6. > use testdb
  7. switched to db testdb
  8. > db.auth("test","admin")
  9. 1
  10. > show dbs
  11. > show collections
  12. >

　　提示：认证用户必须切换到对应的数据库下做认证；我这里test用户只能对testdb库下的所有collection进行读写，所以认证以后，我们在使用 show dbs命令就看不到系统admin和config库了；除了上述连接数据库以后使用db.auth()做用户认证，我们也可直接在连接数据库时指定用户名和密码，如下

  1. [root@node12 ~]# mongo -utest -padmin testdb
  2. MongoDB shell version v4.4.1
  3. connecting to: mongodb://127.0.0.1:27017/testdb?compressors=disabled&gssapiServiceName=mongodb
  4. Implicit session: session { "id" : UUID("60c43e94-04c6-46f4-be07-07ca8fa06b2f") }
  5. MongoDB server version: 4.4.1
  6. > show dbs
  7. > exit
  8. bye
  9. [root@node12 ~]# mongo -utest -padmin 192.168.0.52:27017/testdb
  10. MongoDB shell version v4.4.1
  11. connecting to: mongodb://192.168.0.52:27017/testdb?compressors=disabled&gssapiServiceName=mongodb
  12. Implicit session: session { "id" : UUID("a30dbd64-7b59-4a8e-b95d-02ff30e256f3") }
  13. MongoDB server version: 4.4.1
  14. > show dbs
  15. > show tables
  16. >

　　以上就是在mongodb中开启访问控制，创建用户，授权的操作；我们只需要在配置文件中指定开启认证功能，然后使用具有创建用户权限的用户登录数据库创建用户授权即可；

分布式文档存储数据库之MongoDB访问控制的更多相关文章

  1. 分布式文档存储数据库之MongoDB基础入门

    一.MongoDB简介 MongoDB是用c++语言开发的一款易扩展,易伸缩,高性能,开源的,schema free 的基于文档的nosql数据库:所谓nosql是指不仅仅是sql的意思,它拥有部分s ...

  2. 分布式文档存储数据库之MongoDB索引管理

    前文我们聊到了MongoDB的简介.安装和对collection的CRUD操作,回顾请参考https://www.cnblogs.com/qiuhom-1874/p/13941797.html:今天我 ...

  3. 分布式文档存储数据库之MongoDB副本集

    前文我们聊到了mongodb的索引的相关作用和介绍以及索引的管理,回顾请参考https://www.cnblogs.com/qiuhom-1874/p/13950287.html:今天我们来聊下mon ...

  4. 分布式文档存储数据库之MongoDB分片集群

    前文我们聊到了mongodb的副本集以及配置副本集,回顾请参考https://www.cnblogs.com/qiuhom-1874/p/13953598.html:今天我们来聊下mongodb的分片 ...

  5. 分布式文档存储数据库之MongoDB备份与恢复

    前文我们聊了下mongodb的访问控制以及用户创建和角色分配,回顾请参考https://www.cnblogs.com/qiuhom-1874/p/13974656.html:今天我们来了解下mong ...

  6. 分布式文档存储数据库 MongoDB

    MongoDB 详细介绍 MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的.他支持的数据结构非常松散,是类似json的bjson格式,因此可以 ...

  7. 分布式文档存储数据库(MongoDB)副本集配置

    副本集特征: N 个节点的集群 任何节点可作为主节点 所有写入操作都在主节点上 自动故障转移 自动恢复 相关文章: http://www.cnblogs.com/huangxincheng/archi ...

  8. ElasticSearch 学习记录之 分布式文档存储往ES中存数据和取数据的原理

    分布式文档存储 ES分布式特性 屏蔽了分布式系统的复杂性 集群内的原理 垂直扩容和水平扩容 真正的扩容能力是来自于水平扩容–为集群添加更多的节点,并且将负载压力和稳定性分散到这些节点中 ES集群特点 ...

  9. ElasticSearch 5学习(8)——分布式文档存储（wait_for_active_shards新参数分析）

    学完ES分布式集群的工作原理以及一些基本的将数据放入索引然后检索它们的所有方法,我们可以继续学习在分布式系统中,每个分片的文档是被如何索引和查询的. 路由 首先,我们需要明白,文档和分片之间是如何匹配 ...

随机推荐

  1. 搭建单机版的kafka

    搭建单机版的kafka  

  2. git 上传文件到 gitee 码云远程仓库(强制上传)

    1.先git init 会出现一个.git的文件夹,有些人可能是隐藏了,工具哪里打开就行了 2.将当前的数据上传到码云,看清楚奥,是当前.git add ./ 这是代表当前的意思 3.将上传的数据备注 ...

  3. docker-管理容器常用命令

    1. docker-管理容器常用命令 2. docker管理容器常用命令 1)  docker ps 显示当前正在运行的容器 [root@test-1 ~]# docker ps CONTAINER ...

  4. str常用操作方法

    1. 索引(即下标) s = 'ABCDEFGHIJKLMN' s1 = s[0] print('s[0] = ' + s1) #s[0] = A print('s[3] = '+ s[3]) #s[ ...

  5. java高级&资深&专家面试题-行走江湖必备-持续更新ing

    行走江湖必备一份面试题,这里给大家整理了一套.0面试官最喜欢问的问题或者出场率较高的面试题,助校招或者社招路上的你一臂之力! 首先我们需要明白一个事实,招聘的一个很关键的因素是在给自己找未来的同事,同 ...

  6. linux的bootmem内存管理

    内核刚开始启动的时候如果一步到位写一个很完善的内存管理系统是相当麻烦的.所以linux先建立了一个非常简单的临时内存管理系统bootmem,有了这个bootmem就可以做简单的内存分配/释放操作,在b ...

  7. day44 Pyhton 数据库Mysql

    内容回顾 什么是进程? 就是为了形容执行中的程序的一种称呼 它是操作系统中资源分配的最小单位 进程之间是数据隔离的,占用操作系统资源相对多 独立存在的 谈谈你对并发的理解 同时有多个任务需要执行,但是 ...

  8. 【C语言程序设计】—最近超火的小游戏—【数字炸弹】！

    ✍  准备工作和建议 一.程序的原理 在动手编程之前,得先跟大家说一下这个程序是干什么的. 我们可以称呼这个游戏为<数字炸弹>. 游戏的原理是这样: 每一轮电脑从 1 到 100 中随机抽 ...

  9. Mysql架构与内部模块-第三章

    前言 接上文,本篇文章专门简述Mysql存储引擎,内容繁多,如果你只需知道每种存储引擎的适用场景,可以直接查看本文最后列出的适用场景部分. 正文: Mysql存储引擎作为本系列文章中相对重要的一环,也 ...

  10. 【图论】HDU 5961 传递

    题目内容 题目链接 我们称一个有向图G是传递的当且仅当对任意三个不同的顶点a,若G中有 一条边从a到b且有一条边从b到c ,则G中同样有一条边从a到c. 我们称图G是一个竞赛图,当且仅当它是一个有向图 ...