MongoDB 部署 & 基础命令

MongoDB 官方文档

MongoDB 介绍

Mongodb 由 C++ 语言编写的，是一个基于分布式文件存储的开源数据库系统。
是专为可扩展性，高性能和高可用性而设计的数据库， 
是非关系型数据库中功能最丰富，最像关系型数据库的，它支持的数据结构非常散，
类似 json 的 bson 格式，因此可以存储比较复杂的数据类型。

MongoDB 的（来自于英文单词“Humongous”，中文含义为“庞大”）是可以应用于各种规模的企业，
各个行业以及各类应用程序的开源数据库。作为一个适用于敏捷开发的数据库，
MongoDB的的数据模式可以随着应用程序的发展而灵活地更新。

MongoDB 以一种叫做 BSON （二进制 JSON） 的存储形式将数据作为文档存储，
具有相似结构的文档通常被整理成集合，可以把这些集合看成类似于关系数据库中的表；
文档和行相似， 字段和列相似

json格式：{key:value,key:value}
bson格式：{key:value,key:value}
# 区别在于：对于数据 { id : 1 }，在 JSON 的存储上 1 只使用了一个字节，而如果用 BSON，那就是至少4个字节

NoSQL 介绍

NoSQL（NoSQL = Not Only SQL )，意即"不仅仅是 SQL"，指的是非关系型的数据库，是对不同于传统的关系型数据库的数据库管理系统的统称。

这些数据有很大一部分是由关系数据库管理系统（RDMBS）来处理，也有一部分使用非系型数据库处理

对 NoSQL 最普遍的解释是 "非关联型的"，强调 Key-Value Stores 和文档数据库的优点，而不是单纯的反对RDBMS

NoSQL 用于超大规模数据的存储，这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展

MongoDB 与 MySQL 对比

下表将帮助您更容易理解 Mongo 中的一些概念：

SQL术语/概念	MongoDB术语/概念	解释/说明
database	database	数据库
table	collection	数据库表 / 集合
row	document	数据记录行 / 文档
column	field	数据字段 / 域
index	index	索引
table joins		表连接，MongoDB 不支持
primary key	primary key	主键，MongoDB 自动将 "_id" 字段设置为主键

通过下图实例，我们也可以更直观的了解 Mongo 中的一些概念：

数据结构不同

MySQL 添加不存在字段的数据时报错

MongoDB 可以添加不存在的字段的数据

MongoDB 不需要提前创建好库和表，创建数据直接会帮助我们创建好

MongoDB 特点

1.高性能：
    Mongodb 提供高性能的数据持久性，索引支持更快的查询

2.丰富的语言查询：
    Mongodb 支持丰富的查询语言来支持读写操作（CRUD）以及数据汇总

3.高可用性： 
    Mongodb 的复制工具，成为副本集，提供自动故障转移和数据冗余， 

4.水平可扩展性：
    Mongodb 提供了可扩展性，作为其核心功能的一部分，分片是将数据分在一组计算机上。

5.支持多种存储引擎： 
    WiredTiger 存储引擎  MMAPv1存储引擎  InMemory 存储引擎
    
6.强大的索引支持：
    地理位置索引可用于构建 各种 O2O 应用、文本索引解决搜索的需求、TTL索引解决历史数据自动过期的需求

MongoDB 应用场景

1.游戏场景：
	使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新

2.物流场景：
	使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。

3.社交场景：
	使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能
    将送快递骑手、快递商家的信息（包含位置信息）存储在 MongoDB，然后通过 MongoDB 的地理位置查询，这样很方便的实现了查找附近的商家、骑手等功能，使得快递骑手能就近接单
    地图软件、打车软件、外卖软件，MongoDB强大的地理位置索引功能使其最佳选择

4.物联网场景：
	使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析

5.视频直播：
	使用 MongoDB 存储用户信息、礼物信息等

6.电商场景：
	上衣有胸围，裤子有腰围，如果用数据库需要分成两个库，如果使用 MongoDB 都可以存在一起

MongoDB 安装部署

安装依赖

[root@redis01 ~]# yum install -y libcurl openssl

下载 MongoDB

# 下载地址：https://www.mongodb.com/download-center/community
[root@redis01 ~]# rz mongodb-linux-x86_64-3.6.13.tgz 

解压 MongoDB

[root@redis01 ~]# tar xf mongodb-linux-x86_64-3.6.13.tgz -C /usr/local/
[root@redis01 ~]# ln -s /usr/local/mongodb-linux-x86_64-3.6.13 /usr/local/mongodb

配置 MongoDB

# 创建目录
[root@redis01 ~]# mkdir /server/mongo_27017/{conf,logs,pid,data} -p

# 配置
[root@redis01 ~]# vim /server/mongo_27017/conf/mongodb.conf
systemLog:
  destination: file   
  logAppend: true  
  path: /server/mongo_27017/logs/mongodb.log

storage:
  journal:
    enabled: true
  dbPath: /server/mongo_27017/data
  directoryPerDB: true
  wiredTiger:
     engineConfig:
        cacheSizeGB: 1
        directoryForIndexes: true
     collectionConfig:
        blockCompressor: zlib
     indexConfig:
        prefixCompression: true

processManagement:
  fork: true
  pidFilePath: /server/mongo_27017/pid/mongod.pid

net:
  port: 27017
  bindIp: 127.0.0.1,10.0.0.91
  
  
#配置详解
# 日志相关
systemLog:
  # 以文件格式存储
  destination: file
  # 每次重启，不生成新文件，每次都追加到文件
  logAppend: true
  # 指定文件路径
  path: /server/mongo_27017/logs/mongodb.log

# 数据部分
storage:
  # 数据回滚，类似于 MySQL 的 undolog
  journal:
    enabled: true
  # 数据目录
  dbPath: /server/mongo_27017/data
  # 默认 false，不适用 inmemory engine
  directoryPerDB: true
  # 存储引擎
  wiredTiger:
     # 存储引擎设置
     engineConfig:
        # 想把数据存到缓存，缓存的大小
        cacheSizeGB: 1
        # 设置一个库就是一个目录，关闭就全放到一个目录下，很乱
        directoryForIndexes: true
     # 压缩相关
     collectionConfig:
        blockCompressor: zlib
     # 索引压缩（与压缩一起使用）
     indexConfig:
        prefixCompression: true
# 守护进程的模式
processManagement:
  fork: true
  # 指定pid文件
  pidFilePath: /server/mongo_27017/pid/mongod.pid
# 指定端口和监听地址
net:
  port: 27017
  bindIp: 127.0.0.1,10.0.0.91

启动 MongoDB

[root@redis01 ~]# /usr/local/mongodb/bin/mongod -f /server/mongo_27017/conf/mongodb.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 11547
child process started successfully, parent exiting

# 验证启动
[root@redis01 ~]# ps -ef | grep mongo
root      11547      1  6 08:48 ?        00:00:00 /usr/local/mongodb/bin/mongod -f /server/mongo_27017/conf/mongodb.conf

配置环境变量

[root@redis01 ~]# vim /etc/profile.d/mongo.sh
export PATH="/usr/local/mongodb/bin:$PATH"

[root@redis01 ~]# source /etc/profile

MongoDB 登录警告处理

警告一处理

# 访问设置没有被允许
WARNING: Access control is not enabled for the database.

# 创建一个用户
[mongo@db01 ~]$ mongo
> use admin
> db.createUser({user: "admin",pwd: "123456",roles:[ { role: "root", db:"admin"}]})

# 解决方式：开启安全认证（要先创建用户，再配置该选项）
[root@redis01 ~]# vim /server/mongo_27017/conf/mongodb.conf 
security:
  authorization: enabled

警告二处理

# 以root用户运行了
WARNING: You are running this process as the root user, which is not recommended.

# 解决方式：使用普通用户启动
1.先关闭mongodb
[root@redis01 ~]# mongod -f /server/mongo_27017/conf/mongodb.conf --shutdown
2.创建mongo用户
[root@redis01 ~]# useradd mongo
[root@redis01 ~]# echo '123456'|passwd --stdin mongo
Changing password for user mongo.
passwd: all authentication tokens updated successfully.
3.授权目录
[root@redis01 ~]# chown -R mongo.mongo /usr/local/mongodb/
[root@redis01 ~]# chown -R mongo.mongo /server/mongo_27017/
4.重新启动
[root@redis01 ~]# su - mongo
Last login: Wed May 27 09:07:51 CST 2020 on pts/1
[mongo@redis01 ~]$ mongod -f /server/mongo_27017/conf/mongodb.conf

警告三处理（两条）

# 你使用的是透明大页，可能导致mongo延迟和内存使用问题。
WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.
       We suggest setting it to 'never'
WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.
       We suggest setting it to 'never'

# 解决方法：执行 echo never > /sys/kernel/mm/transparent_hugepage/enabled 修复该问题
#         执行 echo never > /sys/kernel/mm/transparent_hugepage/defrag 修复该问题

#配置之后重启
[root@redis01 ~]# su - mongo
[mongo@redis01 ~]$ mongod -f /server/mongo_27017/conf/mongodb.conf --shutdown
[mongo@redis01 ~]$ mongod -f /server/mongo_27017/conf/mongodb.conf

# 这样设置是临时的，我们要把他加到 rc.local，在授个权

警告四处理

#rlimits太低，MongoDB的软件进程被限制了，MongoDB希望自己是最少rlimits 32767.5
WARNING: soft rlimits too low. rlimits set to 7837 processes, 65535 files. Number of processes should be at least 32767.5 : 0.5 times number of files.

# 解决方法：
[root@redis01 ~]# vim /etc/profile
ulimit -f unlimited
ulimit -t unlimited
ulimit -v unlimited
ulimit -n 65535
ulimit -m unlimited
ulimit -u 65535

[root@redis01 ~]# vim /etc/security/limits.d/20-nproc.conf
*          soft    nproc     65535
root       soft    nproc     unlimited

[root@redis01 ~]# source /etc/profile

MongoDB 命令

MongoDB 支持 CRUD 操作，但不支持 SQL 语言，有自己的查询语言

在MongoDB中，存储在集合中的每个文档都需要一个唯一的 _id 字段，作为主键。如果插入的文档省略了该 _id字段，则MongoDB驱动程序将自动为该字段生成一个 ObjectId_id。也用于通过更新操作插入的文档 upsert: true.如果文档包含一个 _id字段，该_id值在集合中必须是唯一的，以避免重复键错误。

在MongoDB中，插入操作是针对单个集合的，MongoDB 中的所有写操作都是在单个文档的级别上进行的

基础命令

show databases/show dbs             # 查看库列表
show tables/show collections        # 查看所有的集合
use admin                           # 切换库（没有的库也可以进行切换，没有数据是看不到）
db                                  # 查看当前库
show users                          # 打印当前数据库的用户列表

# test 库 : 登录时默认存在的库
# admin 库 : 系统预留库，MongoDB 系统管理库
# local 库 : 本地预留库，存储关键日志
# config 库 : MongoDB 配置信息库

插入数据

单条数据插入

> db
test
> use runoob
switched to db runoob
> db
runoob
> db.runoob.insert({"name":"wqh"})
WriteResult({ "nInserted" : 1 })

多条数据插入

> db.runoob.insert([
... {"name":"wqh","age":18,gender:"man","figure":{"height":111,"weight":222},"hobby":"nothing"},
... {"name":"zzz","age":28,gender:"woman","figure":{"height":333,"weight":444},"hobby":"play"}])
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 2,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})

查询数据

查询所有数据

# 查询所有数据
> db.runoob.find()
{ "_id" : ObjectId("5f3ce461e525b35dd93019b6"), "name" : "wqh" }
{ "_id" : ObjectId("5f3ce4d2e525b35dd93019b7"), "name" : "wqh", "age" : 18, "gender" : "man" }
{ "_id" : ObjectId("5f3ce4d2e525b35dd93019b8"), "name" : "zzz", "age" : 23, "gender" : "woman" }
{ "_id" : ObjectId("5f3ce4fae525b35dd93019b9"), "name" : "wqh", "age" : 18, "gender" : "man", "figure" : {  } }
{ "_id" : ObjectId("5f3ce4fae525b35dd93019ba"), "name" : "zzz", "age" : 23, "gender" : "woman" }
{ "_id" : ObjectId("5f3ce5f2e525b35dd93019bb"), "name" : "wqh", "age" : 18, "gender" : "man", "figure" : { "height" : 111, "weight" : 222 }, "hobby" : "nothing" }
{ "_id" : ObjectId("5f3ce5f2e525b35dd93019bc"), "name" : "zzz", "age" : 28, "gender" : "woman", "figure" : { "height" : 333, "weight" : 444 }, "hobby" : "play" }

查询一条数据

# 查询第一条数据
> db.runoob.findOne()
{ "_id" : ObjectId("5f3ce461e525b35dd93019b6"), "name" : "wqh" }

按条件查询数据

# 如果查询条件为数字，不需要加引号
# 查询符合条件的所有数据
> db.runoob.find({"name":"zzz"})
{ "_id" : ObjectId("5f3ce4d2e525b35dd93019b8"), "name" : "zzz", "age" : 23, "gender" : "woman" }
{ "_id" : ObjectId("5f3ce4fae525b35dd93019ba"), "name" : "zzz", "age" : 23, "gender" : "woman" }
{ "_id" : ObjectId("5f3ce5f2e525b35dd93019bc"), "name" : "zzz", "age" : 28, "gender" : "woman", "figure" : { "height" : 333, "weight" : 444 }, "hobby" : "play" }


# 查询符合条件的第一条数据
> db.runoob.findOne({"name":"zzz"})
{
        "_id" : ObjectId("5f3ce4d2e525b35dd93019b8"),
        "name" : "zzz",
        "age" : 23,
        "gender" : "woman"
}

多条件查询数据

# AND 连接多个条件
> db.runoob.find({"name":"zzz","age":23})


> db.runoob.find(
 {"name":"zzz",
 "age":23} 
 )

# OR 连接多个条件
> db.runoob.find({$or:[{"figure.h":120},{"size":"big"}]})

>   db.runoob.find(
       {
         $or:[
             {"figure.height":111},
             {"age":23}
        	    ]
       }
   )

条件加范围的查询

> db.runoob.find({$or:[{"figure.height":{$lt:130}},{"gender":"man"}]})

> db.runoob.find(
    {
        $or:[
            {"figure.height":{$lt:130}},
            {"gender":"man"}
        ]
    }
)

修改数据

修改单个数据

> db.runoob.updateOne({"name":"zzz"},{$set:{"figure.height":130}})

> db.runoob.updateOne(
    # 条件
    {"name":"zzz"},
    {
        $set:
            # 修改的值
            {"figure.height":130}
    }
)

修改多条数据

> db.runoob.updateMany({"name":"zzz"},{$set:{"figure.height":130}})
{ "acknowledged" : true, "matchedCount" : 4, "modifiedCount" : 3 }

删除数据

删除单条数据

> db.runoob.deleteOne({"name":"zzz"})
{ "acknowledged" : true, "deletedCount" : 1 }

删除多条数据

> db.runoob.deleteMany({"name":"zzz"})

删除索引

> db.test.dropIndex({ age: 1 })
{
    "ok" : 0,
    "errmsg" : "ns not found",
    "code" : 26,
    "codeName" : "NamespaceNotFound"
}

删除集合

# 先确认自己在哪个库
> db
runoob

# 确认集合，下面两种写法都可以
> show collections;
> show tables;
runoob

# 删除集合
> db.runoob.drop()
true

删除库

# 先确认自己在哪个库
> db
runoob

# 删除库
> db.dropDatabase()

MongoDB 索引

查看执行计划（全表扫描）

> db.inventory.find().explain()
{	# 查询计划
    "queryPlanner" : {
    	# 计划版本
        "plannerVersion" : 1,
        # 被查询的库和集合
        "namespace" : "runoob.runoob",
        # 查询索引设置
        "indexFilterSet" : false,
        # 查询条件
        "parsedQuery" : {
            
        },
        # 成功的执行计划
        "winningPlan" : {
            # 全表扫描
            "stage" : "COLLSCAN",
            # 查询方向
            "direction" : "forward"
        },
        # 拒绝的计划
        "rejectedPlans" : [ ]
    },
    # 服务器信息
    "serverInfo" : {
        "host" : "redis01",
        "port" : 27017,
        "version" : "3.6.13",
        "gitVersion" : "db3c76679b7a3d9b443a0e1b3e45ed02b88c539f"
    },
    "ok" : 1
}


# ========= Stage ========== #
# COLLSCAN 全表扫描
# IXSCAN 索引扫描

创建索引

> db.runoob.createIndex({"age":1},{background:true})
{
    "createdCollectionAutomatically" : true,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}

# 添加索引
createIndex({索引的名称:1}) ：1 表示正序，-1 表示倒序

# 创建方式
1.前台方式 
缺省情况下，当为一个集合创建索引时，这个操作将阻塞其他的所有操作。即该集合上的无法正常读写，直到索引创建完毕
任意基于所有数据库申请读或写锁都将等待直到前台完成索引创建操作
 
2.后台方式
将索引创建置于到后台，适用于那些需要长时间创建索引的情形
这样子在创建索引期间，MongoDB 依旧可以正常的为提供读写操作服务
等同于关系型数据库在创建索引的时候指定 online，而 MongoDB 则是指定 background
其目的都是相同的，即在索引创建期间，尽可能的以一种占用较少的资源占用方式来实现，同时又可以提供读写服务
后台创建方式的代价：索引创建时间变长

# 规范
1.如果要查询的内容都是最近的，那建立索引就用倒序，如果要通盘查询那就用正序。
2.比如说一个数据集合查询占的比较多就用索引，如果查询少而是插入数据比较多就不用建立索引。因为：当没有索引的时候，插入数据的时候MongoDB会在内存中分配出一块空间，用来存放数据。当有索引的时候在插入数据之后还会给自动添加一个索引，浪费了时间。
3.不是所有数据都要建立索引，要在恰当并且需要的地方建立才是最好的。
4.大数量的排序工作时可以考虑创建索引。

查看索引

> db.runoob.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test2.test2"
    },
    {
        "v" : 2,
        "key" : {
            "age" : 1
        },
        "name" : "name_1",
        "ns" : "test2.test2",
        "background" : true
    }
]

查看执行计划（索引扫描）

> db.runoob.find({"age":{$lt:40}}).explain()
        "winningPlan" : {
            "stage" : "FETCH",
            "inputStage" : {
                # 可以走索引
                "stage" : "IXSCAN",
                ........

Mongo工具

mongo               # 登录命令
mongodump           # 备份导出，全备（数据时压缩过的）
mongorestore        # 恢复数据
mongostat           # 查看运行状态的
mongod              # 启动命令
mongoexport         # 备份，导出json格式
mongoimport         # 恢复数据
mongos              # 集群分片命令
mongotop            # 查看运行状态

mongostat 命令

#不加任何参数时，每秒访问一次
[mongo@redis01 ~]$ mongostat
insert query update delete getmore command dirty used flushes vsize   res qrw arw net_in net_out conn                time
    *0    *0     *0     *0       0     2|0  0.0% 0.0%       0  972M 56.0M 0|0 1|0   158b   60.9k    1 May 27 11:23:08.248

insert      # 每秒插入数据的数量
query       # 每秒查询操作的数量
update      # 每秒更新数据的数量
delete      # 没面删除操作的数量
getmore     # 每秒查询游标时的操作数
command     # 每秒执行的命令数
dirty       # 脏数据占缓存的多少
used        # 使用中的缓存
flushes 
            # 在 wiredtiger 引擎，表示轮询间隔
            # 在 MMapv1 引擎，表示每秒写入磁盘次数
vsize       # 虚拟内存使用量
res         # 物理内存使用量
qrw         # 客户端等待读数据的队列长度
arw         # 客户端等待写入数据的队列长度
net_in      # 网络进流量
net_out     # 网络出流量
conn        # 连接总数
time        # 时间

# 一般该命令搭配  mongotop 命令使用，可以显示每个集合的响应速度

MongoDB 用户授权认证

授权命令

用户管理界面
要添加用户， MongoDB提供了该 db.createUser() 方法。添加用户时，您可以为用户分配色以授予权限
注意：
在数据库中创建的第一个用户应该是具有管理其他用户的权限的用户管理员。
您还可以更新现有用户，例如更改密码并授予或撤销角色。

db.auth() 将用户验证到数据库。
db.changeUserPassword() 更改现有用户的密码。
db.createUser() 创建一个新用户。
db.dropUser() 删除单个用户。
db.dropAllUsers() 删除与数据库关联的所有用户。
db.getUser() 返回有关指定用户的信息。
db.getUsers() 返回有关与数据库关联的所有用户的信息。
db.grantRolesToUser() 授予用户角色及其特权。
db.removeUser() 已过时。从数据库中删除用户。
db.revokeRolesFromUser() 从用户中删除角色。
db.updateUser() 更新用户数据。

创建用户和角色

[mongo@db01 ~]$ mongo
> use admin
> db.createUser({user: "admin",pwd: "123456",roles:[ { role: "root", db:"admin"}]})
Successfully added user: {
        "user" : "admin",
        "roles" : [
                {
                        "role" : "root",
                        "db" : "admin"
                }
        ]
}

# 用户角色：
1.可以使用的数据库管理员角色如下:
dbAdmin——授予执行管理任务的特权
userAdmin——允许您在当前数据库上创建和修改用户和角色
dbOwner——此角色结合了以下内容:
readWrite
dbAdmin
userAdmin

2.集群管理员角色
用于管理整个系统的管理数据库中的角色。
clusterMonitor——提供对监视工具的只读访问
clusterManager——用于管理和监视集群上的操作
hostManager——监视和管理服务器
clusterAdmin——结合了其他三个角色和dropDatabase操作

3.备份和恢复角色
这个角色属于管理数据库。
backup——提供备份数据所需的特权
restore——提供从备份中还原数据所需的特权

4.所有数据库角色
这些角色位于管理数据库上，并提供适用于所有数据库的特权。
readAnyDatabase——与“read”角色相同，但适用于所有数据库
readWriteAnyDatabase——与“readWrite”角色相同，但适用于所有数据库
userAdminAnyDatabase——与‘userAdmin’角色相同，但适用于所有数据库
dbAdminAnyDatabase——与“dbAdmin”角色相同，但适用于所有数据库

5.超级用户角色
以下角色不是直接的超级用户角色，但是能够为任何用户分配任何数据库上的任何特权，也包括他们自己。
userAdmin
dbOwner
userAdminAnyDatabase
root角色提供对所有资源的完全特权:
root

查看用户

> db.getUsers()
[
    {
        "_id" : "test.admin",
        "userId" : UUID("b840b96c-3442-492e-a45f-6ca7dff907fd"),
        "user" : "admin",
        "db" : "test",
        "roles" : [
            {
                "role" : "root",
                "db" : "admin"
            }
        ]
    }
]

配置开启认证

[root@redis01 ~]# vim /server/mongo_27017/conf/mongodb.conf 
security:
  authorization: enabled
  
#重启
[mongo@redis01 ~]$ mongod -f /server/mongo_27017/conf/mongodb.conf --shutdown
[mongo@redis01 ~]$ mongod -f /server/mongo_27017/conf/mongodb.conf

使用账号密码连接

[mongo@redis01 ~]$ mongo -uadmin -p --authenticationDatabase admin
MongoDB shell version v3.6.13
Enter password: 

> show databases;
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
test2   0.000GB

创建普通用户

> use test
> db.createUser(
  {
    user: "test",
    pwd: "123456",
    roles: [ { role: "readWrite", db: "write" },
             { role: "read", db: "read" } ]
  }
)

创建测试数据

use write
db.write.insert({"name":"wqh","age":17,"address":"China"})
db.write.insert({"name":"zzz","age":23,"address":"China"})

use read
db.write.insert({"name":"wqh","age":17,"address":"China"})
db.write.insert({"name":"zzz","age":23,"address":"China"})

验证用户权限

mongo -utest -p --authenticationDatabase test
use write
db.write.find()
db.write.insert({"name":"zzzwqh","age":17,"address":"黑龙江"})

use read
db.read.find()
db.write.insert({"name":"zzzwqh","age":23,"address":"黑龙江"})

修改用户密码

# 修改用户信息
db.updateUser("test",{pwd:"123"})

# 修改密码
db.changeUserPassword("admin","123")