mongodb 查看当前是主还是从

MongoDB 用户与访问权限控制简介

在安装 MongoDB 3.0 之后，需要先创建一个帐号，该账号需要有 grant 权限，即：账号管理的授权权限。注意一点，帐号是跟着库走的，所以在指定库里授权，必须也在指定库里认证 ( auth ) 。

> use admin
switched to db admin
> db.createUser(
...   {
...     user: "owen",
...     pwd: "123456",
...     roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
...   }
... )
Successfully added user: {
    "user" : "owen",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}

user：用户名
pwd：密码
role：指定用户的角色，可以用一个空数组给新用户设定空角色；在 role 字段,可以指定内置角色和用户定义的角色。role 里的角色可以选：

Built-In Roles（内置角色）：
    1. 数据库用户角色：read、readWrite;
    2. 数据库管理角色：dbAdmin、dbOwner、userAdmin；
    3. 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
    4. 备份恢复角色：backup、restore；
    5. 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
    6. 超级用户角色：root  
    // 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
    7. 内部角色：__system

具体角色：

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

刚建立了 userAdminAnyDatabase 角色，用来管理用户，可以通过这个角色来创建、删除用户。验证：需要开启 auth 参数。

> show dbs;    ####没有验证，导致没权限。
2015-06-29T10:02:16.634-0400 E QUERY    Error: listDatabases failed:{
    "ok" : 0,
    "errmsg" : "not authorized on admin to execute command { listDatabases: 1.0 }",
    "code" : 13
}
> use admin        #验证，因为在admin下面添加的帐号，所以要到admin下面验证。
switched to db admin
> db.auth('owen','123456')
1
> show dbs;
admin  0.098GB
local  0.098GB
> use test        #在test库里创建帐号
switched to db test
> db.createUser(
...     {
...       user: "asdf",
...       pwd: "asdf",
...       roles: [
...          { role: "read", db: "test" }    #只读帐号
...       ]
...     }
... )
Successfully added user: {
    "user" : "asdf",
    "roles" : [
        {
            "role" : "read",
            "db" : "test"
        }
    ]
}
> db.createUser(
...     {
...       user: "qwer",
...       pwd: "qwer",
...       roles: [
...          { role: "readWrite", db: "test" }   #读写帐号
...       ]
...     }
... )
Successfully added user: {
    "user" : "qwer",
    "roles" : [
        {
            "role" : "readWrite",                #读写账号
            "db" : "test"
        }
    ]
}
> show users;                                    #查看当前库下的用户
{
    "_id" : "test.asdf",
    "user" : "asdf",
    "db" : "test",
    "roles" : [
        {
            "role" : "read",
            "db" : "test"
        }
    ]
}
{
    "_id" : "test.qwer",
    "user" : "qwer",
    "db" : "test",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        }
    ]
}

有没有一个超级权限？不仅可以授权，而且也可以对集合进行任意操作？答案是肯定的，只是不建议使用。那就是 roles 角色设置成 root 。

> db.createUser(
...  {
...    user: "liujiaxing",
...    pwd: "liujiaxing",
...    roles: [
...       { role: "root", db: "admin" }      #超级root帐号
...    ]
...  }
... )
Successfully added user: {
    "user" : "liujiaxing",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
> 
> show users;              #查看当前库下的用户
{
    "_id" : "admin.owen",
    "user" : "owen",
    "db" : "admin",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.liujiaxing",
    "user" : "liujiaxing",
    "db" : "admin",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
> use admin
switched to db admin
> db.auth('liujiaxing','liujiaxing')
1
> use test
switched to db test
> db.table.insert({"a":666,"b":666})
WriteResult({ "nInserted" : 1 })
> db.table.insert({"a":777,"b":777})          #权限都有
WriteResult({ "nInserted" : 1 })
> db.table.find()
{ "_id" : ObjectId("59fdfd1a6cf6b14468fbcf2b"), "a" : 666, "b" : 666 }
{ "_id" : ObjectId("59fdfd1a6cf6b14468fbcf2c"), "a" : 777, "b" : 777 }
> db.table.remove({})
WriteResult({ "nRemoved" : 2 })

因为帐号都是在当前需要授权的数据库下授权的，那要是不在当前数据库下会怎么样？

> use admin
switched to db admin
> db.createUser(
...  {
...    user: "zxcv",
...    pwd: "zxcv",
...    roles: [
...       { role: "readWrite", db: "test" },     #在当前库下创建其他库的帐号，在 admin 库下创建test 库的帐号      
...    ]
...  }
... )
Successfully added user: {
    "user" : "zxcv",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        }
    ]
}
> 
> show users;
{
    "_id" : "admin.owen",
    "user" : "owen",
    "db" : "admin",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.liujizxing",
    "user" : "liujizxing",
    "db" : "admin",
    "roles" : [
        {
            "role" : "root",
            "db" : "admin"
        }
    ]
}
{
    "_id" : "admin.zxcv",
    "user" : "zxcv",
    "db" : "admin",
    "roles" : [
        {
            "role" : "readWrite",
            "db" : "test"
        }
    ]
}
> use test
switched to db test
> db.auth('zxcv','zxcv')          #在 admin 下创建的帐号，不能直接在其他库验证
Error: 18 Authentication failed.
0
> use admin
switched to db admin            #只能在帐号创建库下认证，再去其他库进行操作。
> db.auth('zxcv','zxcv')

> use test
switched to db test
> db.table.insert({"a":1111,"b":2222})
WriteResult({ "nInserted" : 1 })

上面更加进一步说明数据库帐号是跟随数据库的，哪里创建就在哪里认证。