MongoDB概述与部署

最新推荐文章于 2023-07-22 10:39:37 发布
最新推荐文章于 2023-07-22 10:39:37 发布
阅读量544 收藏 3
点赞数 5
分类专栏： 运维系列 数据库系列 文章标签： mongodb 数据库 nosql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rzy1248873545/article/details/122100281
版权

文章目录

一、MongoDB概述

（1）MongoDB简介

  • 概述：MongoDB是由C++语言编写的，是一个基于分布式文件存储的非关系型数据库。MongoDB又被称为最像关系型数据库的非关系性数据库

  • 优势：MongoDB的优势在于可以存放海量数据，具备强大的查询功能，是一个独立的、面向集合文档形式的数据库

  • Mysql和MongoDB数据存储格式的对比：

Mysql数据库—数据表—数据—行—列—表联合—主键
MongoDB数据库—集合—文档—字段—嵌入文档—主键（MongDB的主键为_id）
  • MongoDB官网：https://www.mongodb.com/try/download/community

在这里插入图片描述

（2）MongoDB特点

  • 存储性：
  1. 面向集合（Collection-Oriented）： 数据被分组存储在数据集中，这个数据集被称为一个集合（Collection）。每个集合在数据库中都有一个唯一的标识名，并且可以包含多个的文档。集合的的概念就类似于关系型数据中的表，不同的是集合不需要定义任何模式
  2. 面向文档： 存储在集合中的文档，被存储为key-values键对值的形式。键用于唯一标识一个文档，为字符串类型，而值可以是各种的文件类型。这种存储形式又被称为BSON（Binary Serialized Document Format）
  3. 高效二进制数据存储： 包括大型对象，例如视频，MongoDB使用二进制格式存储数据，可以保存任何类型的数据对象
  • 操作性：
  1. 完全索引： 可以在任意属性上建立索引，包含内部对象，建立索引后可以提高用户查询速度
  2. 强大的聚合工具： MongoDB除了提供丰富的查询功能外，还提供强大的聚合工具，比如count、group等，支持使用MapReduce完成复杂的聚合任务
  3. 支持Perl、PHP、Java、Python等现在主流开发语言的驱动程序： MongoDB提供了当前所有主流开发语言的数据库驱动包，开发人员使用任何一种主流开发语言都可以轻松编程，实现访问MongoDB数据库
  • 可用性：
  1. 支持复制和数据恢复： MongoDB支持主从复制机制，可以实现数据备份、故障恢复、读扩展等功能，而基于副本集的复制机制提供了自动故障恢复的功能，确保了集群数据不会丢失，和Mysql的主从复制一样，但不同的是MongoDB数据库的主从复制主挂了从会代替主
  2. 自动处理分片： MongoDB支持集群自动切分数据，也就是分布式，对数据进行分片可以使集群存储更多的数据，实现更大的负载，也可以保证存储的负载均衡

（3）MongoDB的适用场景

  1. 网站数据： MongoDB非常适合实时的插入、更新、查询，并且具备了网站实时数据存储的要求，例如数据复制以及高度伸缩性
  2. 缓存： 由于性能很高，MongoDB也适合作为信息基础设施的缓存层，在系统重启之后，由MongoDB搭建的持久化缓存可以避免下层的数据源过载，MongoDB会尽可能的把数据放到内存中，虽然磁盘中也有数据，但还是会全部读取到内存中
  3. 密度高、价值低的数据： 使用传统的关系型数据库在存储一些数据时可能会比较贵，在此之前很多程序员往往会选择传统的文件进行存储
  4. 高伸缩性的场景： MongoDB非常适合由数十或数百台服务器组成的数据库，也就是支持横向扩展
  5. 用于对象以及JSON数据的存储： MongoDB的BSON数据格式非常适合文档格式的存储以及查询

（4）MongoDB的非适用场景

  1. 高度事务性的系统： 例如银行或者会计系统，MongoDB是不支持事务的
  2. 传统的商业智能应用： 针对特定问题的数据库会产生高度优化的查询方式，对于此类应用，数据仓库可能才是更适合的选择
  3. 需要SQL的场景： MongoDB是非关系数据库，不支持SQL

（5）MongoDB的存储结构

  • 逻辑结构：

数据库（database）： 数据库是由多个集合组成的，MongoDB默认有四个数据库，分别是config、local、admin、test。一般来说会把多个逻辑相近的集合都放在一个数据库，但是处于性能或者数据量的关系，也可能进行拆分

集合（collection）： 集合是由多个文档组成的，相当于Mysql中的表，但是不同于Mysql的表，集合是没有固定结构的

文档（document）： 文档是MongoDB的核心概念，也是逻辑存储的最小单元，相当于Mysql中的数据，有点类似于Python中字典的格式，键:值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pGohbGFo-1640224445909)(F:\个人文档\markdown图片\image-20210611094154247.png)]

集合名称={key1:value1,key2:value2…} {}里面的就是文档

  • 物理结构：
  1. 命令空间（后缀为.WT的文件）： 每个表或者索引都对应一个命名空间后缀名为.WT，命名空间存储了分配和正在使用的磁盘空间，在mongodb 3.0版本以前，命令空间是.ns的文件，但是在3.0版本之后，默认的存储引擎已经改变，成为WT（wiredTiger）存储引擎，没有以前的.ns文件，都变成了.WT文件
  2. 数据文件： 存放数据的实体，并且使用预分配空间机制，数据文件是以（0，1，2，3…）结尾的，并且后面的文件的大小是前一个文件的两倍

————————————————注释————————————————

预分配空间机制： MongoDB在当前数据文件的基础上，会预分配文件，用0进行填充，数据文件每次新生成的文件的大小都会是上一个文件的两倍，这样可以保证数据文件既不浪费由保证了可用性

——————————————————————————————————

  1. 日志文件： 日志文件分为系统日志文件、journal日志文件、oplog复制操作日志文件、慢查询日志

————————————————注释—————————————————

journal日志文件： 用于MongoDB崩溃恢复的保障

oplog复制操作日志文件： 相当于Mysql中的binary log二进制文件

**慢查询日志：**记录着查询操作超过超时时间的命令

WiredTiger引擎： 也就是WT引擎，是MongoDB3.0版本之后新增的引擎，官方宣称在read、insert和复杂的update下有更高的性能。可以支撑更好的读写负载和并发量，因为对于production（生产）环境，更多的CPU可以有效提升WT引擎的性能，因为WT引擎的IO读写是多线程的。WT不像MMAPV1引擎那样会尽可能的耗尽内存，WT可以通过主配置文件中的cacheSizeGB参数来指定WT引擎使用的内存量

journal日志： journal是一个预写事务日志，是用来确保数据的持久性的，WT引擎每隔60秒（默认的）或者在写入的数据达到2G时，mongoDB将对journal文件提交一个checkpoint检测点，提交检测点后，MongoDB会将内存中的数据变更flush（刷新）到磁盘中的数据文件中，并且做一个标记点，表示标记点之前的数据已经持久存储在了磁盘中，此后的数据变更存在于内存和journal日志中。而对于write操作，会首先被持久写入juornal，然后在内存中保存变更数据，条件满足后会提交一个新的检测点，即检测点之前的数据只是在journal中持久存储，但是并没有在mongodb的数据文件中持久化。延迟持久化可以提升磁盘效率，为了确保数据的安全性，mongodb将所有的变更操作写入journal并间歇性的持久到磁盘上，对于实际数据文件将延迟写入，和WT一样journal也可以用于数据恢复

———————————————————————————————————

（6）内存映射存储引擎MMAP

  1. MongoDB会把数据文件映射到内存中，如果是读操作，内存中的数据起到缓存的作用，如果是写操作，内存还可以把随机的写操作转换成顺序的写操作，总之可以大幅度提升性能
  2. MongoDB并不干涉内存管理工作，而是把这些工作留给操作系统的虚拟内存管理器去处理，这样做的好处是简化的MongoDB的工作，但坏处是用户无法控制MongoDB占用多大的内存，一般来说虚拟内存管理器会把除了系统使用的内存之外的内存全部划给MongoDB使用
  3. MongoDB的内存使用机制（也就是持久化）让它在缓存重建方面更有优势，简单来说，重启进程，缓存依然有效

（7）MongoDB数据类型

字符串这是用于存储数据的最常用的数据类型。MongoDB中的字符串必须为UTF-8
整型此类型用于存储数值。整数可以是32位或64位，具体取决于服务器
布尔类型此类型用于存储布尔值true/false值
双精度浮点数此类型用于存储浮点值
最小键/最大键此类型用于将值与最小和最大的BSON元素进行比较
数组此类型用于将数组或列表或多个值存储到一个键中
时间戳ctimestamp，当文档被修改或添加时，可以方便地进行录制
对象此数据类型用于嵌入式文档
NULL此类型用于存储Null值
符号该数据类型与字符串相同;但是，通常保留用于使用特定符号类型的语言
日期此数据类型用于以UNIX时间格式存储当前日期或时间。您可以通过创建日期对象并将日，月，年的日期进行指定自己需要的日期时间。
对象ID此数据类型用于存储文档的ID
二进制数据此数据类型用于存储二进制数据
代码此数据类型用于将JavaScript代码存储到文档中
正则表达式此数据类型用于存储正则表达式

（8）MongoDB中自带的四个数据库

MongoDB中默认有四个数据库，分别是config、admin、local、test

config： 集群中使用的，分片数据库

admin： 保存用户信息、权限的数据库

local： local的数据只存在于本地数据，不会被同步到其他数据库

test： test为MongoDB默认登录的数据库，只要不知道数据库登录，那么登录的就是test

二、部署MongoDB

（1）实验环境

系统ip主机名MongoDB版本
Centos7.4192.168.100.202mongodbmongodb-linux-x86_64-rhel70-4.4.5.tgz mongodb-database-tools-rhel70-x86_64-100.3.1.tgz

（2）实验步骤

******（1）先做基础配置
[root@Centos7 ~]# hostnamectl set-hostname mongodb
[root@Centos7 ~]# su
[root@mongodb ~]# systemctl stop firewalld
[root@mongodb ~]# setenforce 0
setenforce: SELinux is disabled
[root@mongodb ~]# mount /dev/cdrom /mnt/
mount: /dev/sr0 写保护，将以只读方式挂载
mount: /dev/sr0 已经挂载或 /mnt 忙
       /dev/sr0 已经挂载到 /mnt 上
       
******（2）上传源码包，MongoDB 4版本以上的/bin目录中的工具进行了分离，只有一些基础工具可以使用，需要安装插件才能使用/bin下的其他工具
[root@mongodb ~]# ll
总用量 133084
-rw-------. 1 root root     1264 1月  12 18:27 anaconda-ks.cfg
-rw-r--r--  1 root root 64213416 6月  11 18:28 mongodb-database-tools-rhel70-x86_64-100.3.1.tgz  #这个就是工具包
-rw-r--r--  1 root root 72053873 6月  11 18:15 mongodb-linux-x86_64-rhel70-4.4.5.tgz
[root@mongodb ~]# ulimit -n 25000  #同一时间最多开启的文件数
[root@mongodb ~]# ulimit -u 25000  #用户最多开启的程序数目
[root@mongodb ~]# echo 0 > /proc/sys/vm/zone_reclaim_mode  #设置内核参数，表示当某个节点内存不足时，可以借用其他节点的内存 
[root@mongodb ~]# sysctl -w vm.zone_reclaim_mode=0
vm.zone_reclaim_mode = 0
[root@mongodb ~]# echo never >/sys/kernel/mm/transparent_hugepage/enabled
[root@mongodb ~]# echo never >/sys/kernel/mm/transparent_hugepage/defrag
[root@mongodb ~]# tar xf mongodb-linux-x86_64-rhel70-4.4.5.tgz 
[root@mongodb ~]# mkdir /usr/local/mongodb
[root@mongodb ~]# mv  mongodb-linux-x86_64-rhel70-4.4.5 /usr/local/mongodb/
[root@mongodb ~]# echo "export PATH=/usr/local/mongodb/bin:\$PATH" >>/etc/profile  #修改环境变量优化MongoDB命令执行路径
[root@mongodb ~]# source /etc/profile
[root@mongodb ~]# tar xf mongodb-database-tools-rhel70-x86_64-100.3.1.tgz 
[root@mongodb ~]# mkdir /usr/local/mongodb/bin
[root@mongodb ~]# mv mongodb-database-tools-rhel70-x86_64-100.3.1/bin/* /usr/local/mongodb/bin/
[root@mongodb ~]# ln -s /usr/local/mongodb/mongodb-linux-x86_64-rhel70-4.4.5/bin/* /usr/local/mongodb/bin/

******（3）创建mongodb的存储目录以及配置文件
[root@mongodb ~]# mkdir /usr/local/mongodb/data
[root@mongodb ~]# mkdir /usr/local/mongodb/logs
[root@mongodb ~]# mkdir /usr/local/mongodb/conf
[root@mongodb ~]# touch /usr/local/mongodb/logs/mongodb.log
[root@mongodb ~]# chmod 777 /usr/local/mongodb/logs/mongodb.log 
[root@mongodb ~]# vim /usr/local/mongodb/conf/mongodb.conf
bind_ip=192.168.100.202  #指定ip
port=27017   #指定端口
dbpath=/usr/local/mongodb/data/ #指定数据存储路径
logpath=/usr/local/mongodb/logs/mongodb.log  #指定日志存储路径
logappend=true   #mongodb日志以追加的方式写入
fork=true    #启动的时候，将mongodb放后台启动
maxConns=5000    #mongodb最大的连接数

******（4）编写服务启动脚本
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf  #启动mongodb
about to fork child process, waiting until server is ready for connections.
forked process: 1181
child process started successfully, parent exiting
[root@mongodb ~]# netstat -anpt | grep mongo  #查看是否成功启动
tcp        0      0 192.168.100.202:27017   0.0.0.0:*               LISTEN      1181/mongod  
[root@mongodb ~]# mongo --port 27017 --host 192.168.100.202  #登录mongodb
MongoDB shell version v4.4.5
connecting to: mongodb://192.168.100.202:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("884dbe0a-4ef6-4118-9599-fc3c2118170c") }
MongoDB server version: 4.4.5
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see
	https://docs.mongodb.com/
Questions? Try the MongoDB Developer Community Forums
	https://community.mongodb.com
---
The server generated these startup warnings when booting: 
        2021-06-11T18:32:24.504+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
        2021-06-11T18:32:24.504+08:00: You are running this process as the root user, which is not recommended
        2021-06-11T18:32:24.504+08:00: Soft rlimits too low
        2021-06-11T18:32:24.504+08:00:         currentValue: 25000
        2021-06-11T18:32:24.504+08:00:         recommendedMinimum: 64000
---
---
        Enable MongoDB's free cloud-based monitoring service, which will then receive and display
        metrics about your deployment (disk utilization, CPU, operation statistics, etc).

        The monitoring data will be available on a MongoDB website with a unique URL accessible to you
        and anyone you share the URL with. MongoDB may use this information to make product
        improvements and to suggest MongoDB products and deployment options to you.

        To enable free monitoring, run the following command: db.enableFreeMonitoring()
        To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
> exit
bye
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf --shutdown #关闭mongodb
killing process with pid: 1181
[root@mongodb ~]# netstat -anpt | grep mongo
[root@mongodb ~]# echo /usr/local/mongodb/bin/mongod -f /usr/local/mongodb/conf/mongodb.conf>>/etc/rc.local   #添加mongodb开机自启
[root@mongodb ~]# vim /etc/init.d/mongodb
#!/bin/bash
case "$1" in
'start')
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/conf/mongodb.conf;;
'stop')
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/conf/mongodb.conf --shutdown;;
'restart')
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/conf/mongodb.conf --shutdown
/usr/local/mongodb/bin/mongod -f /usr/local/mongodb/conf/bin/mongodb.conf;;
esac
#保存退出
[root@mongodb ~]# chmod +x /etc/init.d/mongodb  #添加可执行权限
[root@mongodb ~]# /etc/init.d/mongodb start   #启动
about to fork child process, waiting until server is ready for connections.
forked process: 1234
child process started successfully, parent exiting
[root@mongodb ~]# netstat -anpt | grep mongo
tcp        0      0 192.168.100.202:27017   0.0.0.0:*               LISTEN      1234/mongod         
[root@mongodb ~]# /etc/init.d/mongodb stop   #关闭
killing process with pid: 1234
[root@mongodb ~]# netstat -anpt | grep mongo

******（5）测试访问mongodb数据库
[root@mongodb ~]# /etc/init.d/mongodb start 
about to fork child process, waiting until server is ready for connections.
forked process: 1291
child process started successfully, parent exiting
[root@mongodb ~]# mongo --port 27017 --host 192.168.100.202  #或者mongo 192.168.100.202:27017也可以
MongoDB shell version v4.4.5
connecting to: mongodb://192.168.100.202:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("a872ecf6-4081-47b6-9559-dccb674f144a") }
MongoDB server version: 4.4.5
---
The server generated these startup warnings when booting: 
        2021-06-11T18:38:54.222+08:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
        2021-06-11T18:38:54.222+08:00: You are running this process as the root user, which is not recommended
        2021-06-11T18:38:54.222+08:00: Soft rlimits too low
        2021-06-11T18:38:54.222+08:00:         currentValue: 25000
        2021-06-11T18:38:54.222+08:00:         recommendedMinimum: 64000
---
---
        Enable MongoDB's free cloud-based monitoring service, which will then receive and display
        metrics about your deployment (disk utilization, CPU, operation statistics, etc).

        The monitoring data will be available on a MongoDB website with a unique URL accessible to you
        and anyone you share the URL with. MongoDB may use this information to make product
        improvements and to suggest MongoDB products and deployment options to you.

        To enable free monitoring, run the following command: db.enableFreeMonitoring()
        To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
---
> show databases;  #查看所有数据库，但是只有三个数据库
admin   0.000GB
config  0.000GB
local   0.000GB
> show dbs         #查看所有数据库
admin   0.000GB
config  0.000GB
local   0.000GB
> db.getName()     #查看当前数据库，可以看到是test。test就是第四个库，也是mongodb默认登录的库
test

（3）MongoDB的操作

MongoDB中的命令是可以补齐的

-服务器相关操作

[root@mongodb ~]# mongo 192.168.100.202:27017  #先登录mongodb数据库
> db.help    #查看帮助信息
> help   #查看帮助信息
> db.version()  #查看版本
4.4.5

-数据库相关操作

> show databases  #查看所有数据库
admin   0.000GB
config  0.000GB
local   0.000GB
> show dbs   #查看所有数据库
admin   0.000GB
config  0.000GB
local   0.000GB
> use local  #进入local库
switched to db local
> db.getName() #查看当前在那个库中
local
> use aaa  #mongodb是不用创建库的，只需要进入之后创建集合，库就会自动生成
switched to db aaa
> db.getName()
aaa
> db.dropDatabase()  #删除当前库
{ "dropped" : "hehe", "ok" : 1 }
> show tables   #只要删除库，其库下的所有集合都会被删除
> show dbs  #查看所有库发现删除成功
admin   0.000GB
config  0.000GB
local   0.000GB

-集合相关操作

> use hehe       #进入hehe库
switched to db hehe
> db.getName()  
hehe
> db.aaa.insert({"id":1,"name":"zhangsan"})         #在当前库下创建集合aaa
WriteResult({ "nInserted" : 1 })       #这个1就表示创建成功
> show dbs      #创建完成后，发现多了一个库
admin   0.000GB
config  0.000GB
hehe    0.000GB
local   0.000GB
> show tables  #查看当前库中所有的表
aaa
> db.aaa.find()      #查看aaa集合中的所有表格
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "zhangsan" }      #_id相当于主键，不指定的话，_id值是随机生成的
> db.aaa.insert({"id":2,"name":"lisi","favorite":["apple","banana","game"]}) #再次插入数据，值可以是列表
WriteResult({ "nInserted" : 1 })
> db.aaa.find()         #查看aaa集合中的所有表格
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "zhangsan" }
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
> db.aaa.find({"id":2})       #筛选aaa集合中id键等于2的表格
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
> db.aaa.findOne({"id":1})  #使用findOne查看，输出信息更为简洁一点
{
	"_id" : ObjectId("60c370730e8947c79273ddfc"),
	"id" : 1,
	"name" : "zhangsan"
}
> db.aaa.findOne({"id":2})
{
	"_id" : ObjectId("60c370ff0e8947c79273ddfd"),
	"id" : 2,
	"name" : "lisi",
	"favorite" : [
		"apple",
		"banana",
		"game"
	]
}
> a = db.aaa.findOne({"id":2})      #MongoDB中可以赋予变量名和变量值
{
	"_id" : ObjectId("60c370ff0e8947c79273ddfd"),
	"id" : 2,
	"name" : "lisi",
	"favorite" : [
		"apple",
		"banana",
		"game"
	]
}
> a.id  #读取a中id键的值
2
> a.name  #读取a中name键的值
lisi
> db.aaa.findOne({"id":2}).id  #这两个和上面相同
2
> db.aaa.findOne({"id":2}).name
lisi
> db.aaa.insert({"id":3,"id":4,"name":"heheh","name":"bbbb"})   #插入多个相同键的值，查看效果
WriteResult({ "nInserted" : 1 })
> db.aaa.find()
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "zhangsan" }
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
{ "_id" : ObjectId("60c372e30e8947c79273ddfe"), "id" : 4, "name" : "bbbb" }   #发现最后一个配置的键值会生效
> db.aaa.insert({"":22})    #键名可以为空，但是一般不会用
WriteResult({ "nInserted" : 1 })
> db.aaa.find()
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "zhangsan" }
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
{ "_id" : ObjectId("60c372e30e8947c79273ddfe"), "id" : 4, "name" : "bbbb" }
{ "_id" : ObjectId("60c3733b0e8947c79273ddff"), "" : 22 }
> db.aaa.insert({"$id":4})  #键名不能以$开头
WriteResult({
	"nInserted" : 0,
	"writeError" : {
		"code" : 2,
		"errmsg" : "Document can't have $ prefixed field names: $id"
	}
})
> db.aaa.insert({"aaa$id":4})   #不能以$开头，但是可以包含$这种特殊字符
WriteResult({ "nInserted" : 1 })
> db.aaa.find()
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "zhangsan" }
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
{ "_id" : ObjectId("60c372e30e8947c79273ddfe"), "id" : 4, "name" : "bbbb" }
{ "_id" : ObjectId("60c3733b0e8947c79273ddff"), "" : 22 }
{ "_id" : ObjectId("60c373970e8947c79273de01"), "aaa$id" : 4 }
> db.aaa.update({"id":1},{$set:{"name":"abc"}})  #修改aaa集合中，id键的值等于1的表格的name键改为abc
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.aaa.find()
{ "_id" : ObjectId("60c370730e8947c79273ddfc"), "id" : 1, "name" : "abc" }   #成功修改
{ "_id" : ObjectId("60c370ff0e8947c79273ddfd"), "id" : 2, "name" : "lisi", "favorite" : [ "apple", "banana", "game" ] }
{ "_id" : ObjectId("60c372e30e8947c79273ddfe"), "id" : 4, "name" : "bbbb" }
{ "_id" : ObjectId("60c3733b0e8947c79273ddff"), "" : 22 }
{ "_id" : ObjectId("60c373970e8947c79273de01"), "aaa$id" : 4 }
> for(i=1;i<=1000;i++){db.abc.insert({"id":i,"name":"hehe"})}  #mongodb的数据库可以使用循环语句，利用for循环创建集合
WriteResult({ "nInserted" : 1 })
> show tables  #查看当前库中所有的表
aaa
abc
> db.abc.find()   #查看发现一页只能显示20行，出入it可以翻页
{ "_id" : ObjectId("60c374b20e8947c79273de02"), "id" : 1, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de03"), "id" : 2, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de04"), "id" : 3, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de05"), "id" : 4, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de06"), "id" : 5, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de07"), "id" : 6, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de08"), "id" : 7, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de09"), "id" : 8, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0a"), "id" : 9, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0b"), "id" : 10, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0c"), "id" : 11, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0d"), "id" : 12, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0e"), "id" : 13, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0f"), "id" : 14, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de10"), "id" : 15, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de11"), "id" : 16, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de12"), "id" : 17, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de13"), "id" : 18, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de14"), "id" : 19, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de15"), "id" : 20, "name" : "hehe" }
Type "it" for more
> it    #输入it翻页
{ "_id" : ObjectId("60c374b20e8947c79273de16"), "id" : 21, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de17"), "id" : 22, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de18"), "id" : 23, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de19"), "id" : 24, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1a"), "id" : 25, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1b"), "id" : 26, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1c"), "id" : 27, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1d"), "id" : 28, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1e"), "id" : 29, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de1f"), "id" : 30, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de20"), "id" : 31, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de21"), "id" : 32, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de22"), "id" : 33, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de23"), "id" : 34, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de24"), "id" : 35, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de25"), "id" : 36, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de26"), "id" : 37, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de27"), "id" : 38, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de28"), "id" : 39, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de29"), "id" : 40, "name" : "hehe" }
Type "it" for more
> db.abc.remove({"id":1})  #删除集合中id键的值等于1的表格
WriteResult({ "nRemoved" : 1 })
> db.abc.find()
{ "_id" : ObjectId("60c374b20e8947c79273de03"), "id" : 2, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de04"), "id" : 3, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de05"), "id" : 4, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de06"), "id" : 5, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de07"), "id" : 6, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de08"), "id" : 7, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de09"), "id" : 8, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0a"), "id" : 9, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0b"), "id" : 10, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0c"), "id" : 11, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0d"), "id" : 12, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0e"), "id" : 13, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de0f"), "id" : 14, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de10"), "id" : 15, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de11"), "id" : 16, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de12"), "id" : 17, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de13"), "id" : 18, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de14"), "id" : 19, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de15"), "id" : 20, "name" : "hehe" }
{ "_id" : ObjectId("60c374b20e8947c79273de16"), "id" : 21, "name" : "hehe" }
Type "it" for more
> db.abc.drop()   #删除当前库下的abc集合
true      #true表示删除成功
> show tables  #查看所有集合发现删除成功
aaa

-MongoDB数据库的用户角色权限管理

角色类型权限级别
普通用户角色read.readWwrite 读和读写
数据库管理员角色dbAdmin、dbOwner、userAdmin
集群管理员角色clusterAdmin.clusterManager.clusterMonitor、hostManager
数据库备份与恢复角色backup、restore
所有数据库角色readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
超级用户角色root
核心角色__system

普通用户角色：

read： 提供了读取所有非系统集合的权限，以及系统集合中的system.indexes, system.js, system.namespaces

readWrite: 包含了所有read权限，以及修改所有非系统集合的和系统集合中的system.js的权限

数据库管理员角色：

dbOwner：该数据库的所有者，具有该数据库的全部权限

dbAdmin：一些数据库对象的管理操作，但是没有数据库的读写权限。

userAdmin：为当前用户创建、修改用户和角色。拥有userAdmin权限的用户可以将该数据库的任意权限赋予任意的用户。

集群管理员角色：

clusterAdmin：提供了最大的集群管理功能。相当于clusterManager, clusterMonitor, and hostManager和dropDatabase的权限组合。

clusterManager：提供了集群和复制集管理和监控操作。拥有该权限的用户可以操作config和local数据库（即分片和复制功能）

clusterMonitor：仅仅监控集群和复制集。

hostManager：提供了监控和管理服务器的权限，包括shutdown节点，logrotate, repairDatabase等。

数据库备份与恢复角色：

admin数据库中包含了备份恢复数据的角色。包括backup、restore等等

所有数据库角色：

admin数据库提供了一个mongod实例中所有数据库的权限角色

readAnyDatabase： 具有read每一个数据库权限。但是不包括应用到集群中的数据库。和read相似，但它是全局。的。

readWriteAnyDatabase： 具有readWrite每一个数据库权限。但是不包括应用到集群中的数据库。

userAdminAnyDatabase： 具有userAdmin每一个数据库权限，但是不包括应用到集群中的数据库。

dbAdminAnyDatabase： 提供了dbAdmin每一个数据库权限，但是不包括应用到集群中的数据库。

超级管理员权限：

**root: ** dbadmin到admin数据库、useradmin到admin数据库以及UserAdminAnyDatabase。但它不具有备份恢复、直接操作system.*集合的权限，但是拥有root权限的超级用户可以自己给自己赋予这些权限。

注意：！！！！！！！！！！！！！！

  1. 创建用户时，需要在默认test数据库中，不use到任何数据库

  2. 查看扫描用户时，需要在admin数据库中，执行use admin切换进去

  3. 撤销修改时，需要在用户所属的db数据库中进行

[root@mongodb ~]# mongo 192.168.100.202:27017
> db.getName()  #确认当前数据库是test
test 
> db.getUsers() #查看所有用户，默认是没有的
[ ] 
> db.createUser({user:"Boss",pwd:"123123",roles:[{role:"root",db:"admin"}]})  #创建用户，用户名Boss，密码123123，权限为root，管理的库为当前库和admin库
Successfully added user: {
	"user" : "Boss",
	"roles" : [
		{
			"role" : "root",
			"db" : "admin"
		}
	]
}
> db.getUsers()
[
	{
		"_id" : "test.Boss",
		"userId" : UUID("52252c8b-d569-40c9-9d0d-ec3906bff198"),
		"user" : "Boss",
		"db" : "test",
		"roles" : [
			{
				"role" : "root",
				"db" : "admin"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	}
]
> exit
bye
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf --shutdown  #先关闭mongodb
killing process with pid: 1030
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf --auth  #临时开启用户认证，永久开启需要在主配置文件中加auth=yes即可
about to fork child process, waiting until server is ready for connections.
forked process: 15837
child process started successfully, parent exiting
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf --shutdown
killing process with pid: 15837
[root@mongodb ~]# echo "auth=yes" >> /usr/local/mongodb/conf/mongodb.conf   #写入配置文件
[root@mongodb ~]# mongod -f /usr/local/mongodb/conf/mongodb.conf 
about to fork child process, waiting until server is ready for connections.
forked process: 15878
child process started successfully, parent exiting
[root@mongodb ~]# netstat -anpt | grep mongo
tcp        0      0 192.168.100.202:27017   0.0.0.0:*               LISTEN      15878/mongod   
[root@mongodb ~]# mongo 192.168.100.202:27017  #这个时候直接登录数据库查看效果
MongoDB shell version v4.4.5
connecting to: mongodb://192.168.100.202:27017/test?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("57cd0af4-17c9-44ab-9523-5e58130709d0") }
MongoDB server version: 4.4.5
> show dbs  #发现查看不了任何东西
> show databases
> use aaa
switched to db aaa
> show tables
Warning: unable to run listCollections, attempting to approximate collection names by parsing connectionStatus
> exit
bye
> db.auth("Boss","123123")   #登录刚才授权的用户
1   #1为登录成功
> show dbs  #现在就可以查看了
admin   0.000GB
cat     0.000GB
config  0.000GB
local   0.000GB
> use aaa
switched to db aaa
> db.hehe.insert({"id":1,"name":"chengzhuang"})  #并且可以创建集合和库
WriteResult({ "nInserted" : 1 })
> db.hehe.find()
{ "_id" : ObjectId("60c38ee966fde8910d41f09f"), "id" : 1, "name" : "chengzhuang" }
> db.createUser({user:"hehe",pwd:"123123",roles:[{role:"read",db:"aaa"},{role:"readWrite",db:"cat"}]})  #创建用户hehe密码123123，对aaa库有读的权限，对cat有读写的权限
Successfully added user: {
	"user" : "hehe",
	"roles" : [
		{
			"role" : "read",
			"db" : "aaa"
		},
		{
			"role" : "readWrite",
			"db" : "cat"
		}
	]
}
> db.getUsers() #查看所有用户
[
	{
		"_id" : "test.Boss",
		"userId" : UUID("52252c8b-d569-40c9-9d0d-ec3906bff198"),
		"user" : "Boss",
		"db" : "test",
		"roles" : [
			{
				"role" : "root",
				"db" : "admin"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	},
	{
		"_id" : "test.hehe",
		"userId" : UUID("59cd2d85-47b2-48cf-9c48-067ddba41470"),
		"user" : "hehe",
		"db" : "test",
		"roles" : [
			{
				"role" : "read",
				"db" : "aaa"
			},
			{
				"role" : "readWrite",
				"db" : "cat"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	}
]
> db.auth("hehe","123123")  #登录hehe用户
1
> use aaa
switched to db aaa
> show tables  #进入aaa库查看集合
hehe
> db.hehe.find()  #查看hehe集合的数据
{ "_id" : ObjectId("60c38ee966fde8910d41f09f"), "id" : 1, "name" : "chengzhuang" }
> db.hehe.insert({"id":2,"name":aaaa})  #发现无法写入集合，因为hehe用户对aaa库只有读的权限
uncaught exception: ReferenceError: aaaa is not defined :
@(shell):1:24
> use cat
switched to db cat
> show tables
> db.haha.insert({"id":1,"name":"sssss"})  #创建haha集合并写入数据
WriteResult({ "nInserted" : 1 })
> show tables
haha
> db.haha.find()   #对cat库有读写的权限
{ "_id" : ObjectId("60c392aab8318bbee3646402"), "id" : 1, "name" : "sssss" }
> exit
bye
[root@mongodb ~]# mongo 192.168.100.202:27017  #重新进r数据库
MongoDB shell version v4.4.5
connecting to: mongodb://192.168.100.202:27017/test?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("205c9a68-65f1-4049-ba72-51c5eca16fd6") }
MongoDB server version: 4.4.5
> db.auth("Boss","123123")  #登录boss用户
1
> db.grantRolesToUser("hehe",[{role:"readWrite",db:"aaa"}])  #为hehe用户添加aaa库的读写权限
> db.getUsers()   #查看权限
[
	{
		"_id" : "test.Boss",
		"userId" : UUID("52252c8b-d569-40c9-9d0d-ec3906bff198"),
		"user" : "Boss",
		"db" : "test",
		"roles" : [
			{
				"role" : "root",
				"db" : "admin"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	},
	{
		"_id" : "test.hehe",
		"userId" : UUID("59cd2d85-47b2-48cf-9c48-067ddba41470"),
		"user" : "hehe",
		"db" : "test",
		"roles" : [
			{
				"role" : "readWrite",  
				"db" : "cat"
			},
			{
				"role" : "readWrite",  #发现多了一个对aaa库的读写权限
				"db" : "aaa"
			},
			{
				"role" : "read",
				"db" : "aaa"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	}
]
> db.system.users.find()    #扫描所有用户以及权限
> db.revokeRolesFromUser("hehe",[{role:"readWrite",db:"aaa"}])   #移除用户hehe对aaa库的读写权限
> db.getUsers()  #查看所有用户的权限
[
	{
		"_id" : "test.Boss",
		"userId" : UUID("52252c8b-d569-40c9-9d0d-ec3906bff198"),
		"user" : "Boss",
		"db" : "test",
		"roles" : [
			{
				"role" : "root",
				"db" : "admin"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	},
	{
		"_id" : "test.hehe",
		"userId" : UUID("59cd2d85-47b2-48cf-9c48-067ddba41470"),
		"user" : "hehe",
		"db" : "test",
		"roles" : [
			{
				"role" : "read",   #发现少了对aaa库的读写权限
				"db" : "aaa"
			},
			{
				"role" : "readWrite",
				"db" : "cat"
			}
		],
		"mechanisms" : [
			"SCRAM-SHA-1",
			"SCRAM-SHA-256"
		]
	}
]
> db.system.users.remove({user:"hehe"})   #删除用户hehe
WriteResult({ "nRemoved" : 1 })    #删除成功
> exit
bye
[root@mongodb ~]# mongo --host 192.168.100.202 --port 27017 -u Boss -p 123123 --authenticationDatabase test
#-u指定用户名，-p指定用户的密码，--authenticationDatabase创建用户时所在库
> db.getName()
test

[root@mongodb ~]# mongo 192.168.100.202:27017/test -u Boss -p 123123  #两种登录方式
>

-复制数据库

语法： db.copyDatabase(fromdb, todb, fromhost, username, password)

fromdb: 字符串类型，输入用户源数据库的名称，前提是用户必须能对指定数据库进行鉴权

todb: 字符串类型，复制到的目的数据库的名称，名称可以和之前的不一样

fromhost: 字符串类型，可选项，输入目标ip加端口号，如果是本机则可以忽略

username: 字符串类型，可选项，源主机用户名

password: 字符串类型，可选项，源主机用户的密码

复制数据库： db.copyDatabase(“source_db”,“des_db”,“192.168.100.102”)

克隆集合： db.runCommand({cloneCollection:“accp.t1”,from:“192.168.100.102:27017”})

三版本的可以这样复制，四版本的这样复制不了

（4）MongoDB的备份、恢复

MongoDB数据库可以将mysql数据库的数据导入到自己的库中

Mongoimport 能够还原json文件的数据

[root@mongodb ~]# yum -y install mysql mariadb-server
。。。。。。
完毕！
[root@mongodb ~]# systemctl start mariadb
[root@mongodb ~]# mysql 
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 2
Server version: 5.5.56-MariaDB MariaDB Server

Copyright (c) 2000, 2017, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> create database  aaa;
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]> use aaa
Database changed
MariaDB [aaa]> create table aaa(id int,name char(12));
Query OK, 0 rows affected (0.39 sec)

MariaDB [aaa]> insert into aaa values(1,"zhangsan");
Query OK, 1 row affected (0.00 sec)

MariaDB [aaa]> insert into aaa values(2,"lisi");
Query OK, 1 row affected (0.00 sec)

MariaDB [aaa]> select * from aaa;
+------+----------+
| id   | name     |
+------+----------+
|    1 | zhangsan |
|    2 | lisi     |
+------+----------+
2 rows in set (0.00 sec)
MariaDB [aaa]> select * from  aaa.aaa into outfile '/tmp/aaa-aaa_mysql.csv' fields terminated by ",";  
#查看aaa库下的aaa表中的所有数据并且保存到/tmp/aaa-aaa_mysql.csv路径下，并且以“,”分割开来
Query OK, 2 rows affected (0.00 sec)

MariaDB [aaa]> exit
Bye
[root@mongodb tmp]# cd systemd-private-8911216114974ba6910ebdb73bb6fc02-mariadb.service-31jtXY/ #mariadb是保存在这个路径下的
[root@mongodb systemd-private-8911216114974ba6910ebdb73bb6fc02-mariadb.service-31jtXY]# ll
总用量 0
drwxrwxrwt 2 root root 31 6月  11 22:50 tmp
[root@mongodb systemd-private-8911216114974ba6910ebdb73bb6fc02-mariadb.service-31jtXY]# cd tmp/
[root@mongodb tmp]# ll   #发现有刚才保存的文件
总用量 4
-rw-rw-rw- 1 mysql mysql 18 6月  11 22:50 aaa-aaa_mysql.csv  
[root@mongodb tmp]# cat aaa-aaa_mysql.csv   #查看此文件
1,zhangsan
2,lisi
[root@mongodb tmp]# cd
[root@mongodb ~]# mongoimport --port 27017 --host 192.168.100.202 -d cat  -c dog -f id,name --file /tmp/systemd-private-8911216114974ba6910ebdb73bb6fc02-mariadb.service-31jtXY/tmp/aaa-aaa_mysql.csv --type csv  #mongoimport是mongodb的导入命令-d指定导入的数据库，-c指定导入的集合，-f指定导入文档的键，--file指定文件路径--type指定导入文件类型
2021-06-11T22:58:00.628+0800	connected to: mongodb://192.168.100.202:27017/
2021-06-11T22:58:00.633+0800	2 document(s) imported successfully. 0 document(s) failed to import.
[root@mongodb ~]# mongo 192.168.100.202:27017 #进入数据库
。。。。。。
> show dbs  #查看所有库，发现多了cat库
admin   0.000GB
cat     0.000GB
config  0.000GB
local   0.000GB
> use cat
switched to db cat
> show tables  #进入cat库查看当下库的所有集合，发现有一个dog集合
dog
> db.dog.find()  #查看dog集合，发现数据成功导入
{ "_id" : ObjectId("60c379f80647130a766fc833"), "id" : 1, "name" : "zhangsan" }
{ "_id" : ObjectId("60c379f80647130a766fc834"), "id" : 2, "name" : "lisi" }

> for(var i=1;i<=10000;i++)db.dog.insert({"id":i,"name":"name"+i})  #使用for循环写集合
WriteResult({ "nInserted" : 1 })
> db.dog.find({"id":{"$gt":5000}}).limit(3)  #查看id大于5000的，并且只显示三行
{ "_id" : ObjectId("60c37b7dd9f823fa7cd0b5bf"), "id" : 5001, "name" : "name5001" }
{ "_id" : ObjectId("60c37b7dd9f823fa7cd0b5c0"), "id" : 5002, "name" : "name5002" }
{ "_id" : ObjectId("60c37b7dd9f823fa7cd0b5c1"), "id" : 5003, "name" : "name5003" }
> db.dog.find({"id":{"$gt":5000}}).count() #查看id大于5000的并统计
5000
> db.dog.insert({"id":111111,"name":"name"}) #再插入一行文档
WriteResult({ "nInserted" : 1 })
> db.dog.find({"id":{"$gt":5000}}).count()  #统计
5001
> exit
[root@mongodb ~]# mongoexport --host 192.168.100.202 --port 27017 -d cat -c dog -q '{"id":{"$lt":5000}}' -o /root/cat.json   #mongoexport是mongodb用于导出数据的命令，-q可以指定条件否则会把所有的都导出来，-o指定路径
2021-06-11T23:09:54.234+0800	connected to: mongodb://192.168.100.202:27017/
2021-06-11T23:09:54.422+0800	exported 5001 records
[root@mongodb ~]# head -3 cat.json 
{"_id":{"$oid":"60c379f80647130a766fc833"},"id":1,"name":"zhangsan"}
{"_id":{"$oid":"60c379f80647130a766fc834"},"id":2,"name":"lisi"}
{"_id":{"$oid":"60c37b7cd9f823fa7cd0a237"},"id":1.0,"name":"name1"}
[root@mongodb ~]# cat cat.json | wc -l
5001
[root@mongodb ~]# mongo 192.168.100.202:27017
> use cat
switched to db cat
> show tables
dog
> db.dog.drop()
true
> show tables
> exit
bye
[root@mongodb ~]# mongoimport --port 27017 --host 192.168.100.202  -d cat -c dog --file /root/cat.json #再次导入，json类型的文件是不需要指定类型的 
2021-06-11T23:14:02.428+0800	connected to: mongodb://192.168.100.202:27017/
2021-06-11T23:14:02.490+0800	5001 document(s) imported successfully. 0 document(s) failed to import.
[root@mongodb ~]# mongo 192.168.100.202:27017
> use cat 
switched to db cat
> show tables
dog
> db.dog.find().count() #进行统计，发现恢复成功
5001

Mongorestore 能够还原bson文件的数据

[root@mongodb ~]# mkdir backup
[root@mongodb ~]# mongodump --host 192.168.100.202 --port 27017 -d cat -o backup/
2021-06-11T23:17:59.645+0800	writing cat.dog to backup/cat/dog.bson
2021-06-11T23:17:59.649+0800	done dumping cat.dog (5001 documents)
[root@mongodb ~]# ll backup/
总用量 0
drwxr-xr-x 2 root root 47 6月  11 23:17 cat
[root@mongodb ~]# ll backup/cat/
总用量 264
-rw-r--r-- 1 root root 263934 6月  11 23:17 dog.bson
-rw-r--r-- 1 root root    150 6月  11 23:17 dog.metadata.json
[root@mongodb ~]# mongo 192.168.100.202:27017/cat  #在后面可以指定进入的数据库，不知道默认进入test库
> db.getName()
cat
> show tables
dog
> db.dog.drop()
true
> show tables
> exit
bye
[root@mongodb ~]# mongorestore --host 192.168.100.202 --port 27017 -d cat --dir=backup/cat/   #--dir指定路径
2021-06-11T23:22:42.748+0800	The --db and --collection flags are deprecated for this use-case; please use --nsInclude instead, i.e. with --nsInclude=${DATABASE}.${COLLECTION}
2021-06-11T23:22:42.749+0800	building a list of collections to restore from backup/cat dir
2021-06-11T23:22:42.749+0800	reading metadata for cat.dog from backup/cat/dog.metadata.json
2021-06-11T23:22:42.755+0800	restoring cat.dog from backup/cat/dog.bson
2021-06-11T23:22:42.858+0800	no indexes to restore
2021-06-11T23:22:42.858+0800	finished restoring cat.dog (5001 documents, 0 failures)
2021-06-11T23:22:42.858+0800	5001 document(s) restored successfully. 0 document(s) failed to restore.
[root@mongodb ~]# mongo 192.168.100.202:27017/cat
> show tables  #发现成功
dog
礁之
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
MongoDB4.0搭建分布式集群
kevinmcy的专栏
09-15 1万+
搭建之前先了解一下MongoDB分片群集主要有如下三个组件： Shard：分片服务器，用于存储实际的数据块，实际生产环境中一个shard server 角色可以由几台服务器组成一个Peplica Set 承担，防止主机单点故障。 Config Server：配置服务器，存储了整个分片群集的配置信息，其中包括chunk信息。 Routers：前端路由，客户端由此接入，且让整个群集看上去像单一数...
MongoDB参考手册-新
01-03
11. **云服务**：MongoDB也提供了云服务MongoDB Atlas，用户可以在AWS、Azure或Google Cloud上快速部署和管理MongoDB实例。 这份"MongoDB参考手册-新"应覆盖了上述知识点的详细信息，对于初学者和进阶用户都是宝贵...
MongoDB分布式搭建执行文件（直接可运行）搭建MongoDB分布式集群
12-10
（1） 分片集使用PSA架构 （2） 配置集使用单节点副本集 （3） 请在报告中使用文字和截图详细描述MongoDB分片集群搭建及配置的主要步骤： - 搭建配置集服务器（Mongod） - 搭建分片集服务器（Mongod） - 搭建路由节点服务器（Mongos） - 添加分片集到集群 - 创建数据库cqust - 在数据库cqust中创建students集合 - 自行选择片键，在cqust.students集合上创建片键索引。 - 开启数据库（db）分片功能 - 对集合（Collection）执行分片 - 运行populate_cqust_students.js添加50000条学生数据到cqust.students集合
MongoDB概述！
qq_42807370的博客
02-14 188
1.数据库的存储形式 以往的传统式数据库 关系型数据库都是以:表为单位，以行和列的行书存储数据，以复杂的SQL 查询数据库获取相应数据; 那么非关系型数据库呢是以:块的形式存储数据在本地磁盘 MongoDB 以文档存储数据 Rdeis 以键值对（Key -Value）的形式存储数据 Neo4j 以图片存储形式 2.数据库的结构 像以往的关系型数据库必须要先创建表结构，类型等…强结构性更有利于表...
Mongodb概述
RunTimeExcepti0n的博客
09-15 137
什么是Mongodb? Mongodb是一款基于分布式文件存储的NoSQL数据库，具有高可扩展性、高性能和高可用性。可以从单服务器部署到扩展到大型的复杂的分布式多数据中心架构。Mongodb提供了四种使用方式： 本地单机部署： ...
MongoDB概述
眼泪笑了~
05-11 360
公司从传统的关系型数据迁移至NoSQL的产品，最近一段时间在使用MongoDB，觉得很有必要将MongoDB的知识点和工作过程中遇到的坑记录下来。 1.什么是NoSQL产品数据库 在搞清楚什么是MongoDB的数据之前，先来了解下什么是NoSQL产品数据库 NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，泛指不提供SQL功能的非关系型数据库。 不遵循，SQL标准、ACID特性、表结构。这个概念很早就有人提出，当时做Not SQL解释，逐渐发展 到今天的Not..
MongoDB Books
03-02
本篇文章将针对标题"MongoDB Books"中的三本书籍进行详细的知识点概述。 首先，"MongoDB实战"这本书通常会涵盖MongoDB的基础知识，包括安装与配置、数据模型设计、查询语言、索引创建、聚合框架以及备份与恢复策略...
腾讯云-MongoDB云数据库平台概述.pdf
10-10
* 部署方式：MongoDB云数据库平台提供了云计算平台的部署方式，自建MongoDB数据库管理系统需要自己部署和维护。 * 成本：MongoDB云数据库平台提供了按需付费的计费方式，自建MongoDB数据库管理系统需要自己购买和...
3.2.1_非关系型数据库mongodb及其搭建1
08-08
【MongoDB概述】 MongoDB是一种流行的非关系型数据库（NoSQL），它采用了文档存储的方式，以JSON对象（BSON格式）作为数据模型。MongoDB强调高性能、高可用性和可扩展性，尤其适合处理大规模的数据存储需求。由于其...
SpringBoot+MongoDB+Vue前后分离
06-16
SpringBoot2.x+MongoDB4.x+Vue均选用能进行生产环境部署的稳定版本【开发模式】前后端分离开发，即当前端又当后端，分角色开发【课程受益】一次上手，即学即会，提供全套源代码，直接可以运行【技术介绍】MongoDB...
mongodb分布式安装部署
03-30
NULL 博文链接：https://zhaoshijie.iteye.com/blog/1314158
详解MongoDB4.0构建分布式分片群集
09-09
主要介绍了详解MongoDB4.0构建分布式分片群集，详细的介绍了什么是MongoDB分片和具体使用，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
MongoDB系列一：MongoDB概述
w1lgy的博客
12-26 297
一、MongoDB概述 MongoDB是nosql的一种，现在nosql越来越火，应用越来越广，基本上大型项目都会用到nosql，大部分是采用nosql和关系型数据库一起用的架构。 1、NoSQL NoSQL：Not Only SQL ,本质也是一种数据库的技术，相对于传统数据库技术，它不会遵循一些约束，比如：sql标准、ACID属性，表结构等。下面介绍一下nosql的优缺点和分类。 优点： 满...
非关系型数据库——MongoDB概述
m0_62593597的博客
02-19 990
MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。
MongoDB概述以及安装
daimeijin的博客
01-17 885
文章目录前言MongoDB 基本概念详解MongoDB都有哪些特点？为什么要引入 MongoDB？MongoDB和关系型数据库的差异？MongoDB安装获取安装包进行解压添加到系统执行路径下面( ~/.bashrc)创建数据目录启动MongoDB服务客户端使用( mongo shell, 用来操作MongoDB的javascript客户端界面 )连接服务设置密码停服务exit 退出 mongo以授权模式启动授权方式连接连上之后就可以进行操作：安全说明通过命令访问 MongoDBUI客户端访问 前言 记录Mo
MongoDB简介
ntzzzsj的博客
06-02 486
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
MongoDB 分布式部署教程
weixin_33758863的博客
12-24 2158
本文将介绍如何使用 MongoDB 提供的 Replica Set 和 Shards 功能构建一个分布式 MongoDB 集群。 Replica Set 部署 我们先从部署一个三节点的 Replica Set 开始。 首先，我们要为每个 mongod 实例创建它自己的 dbpath： 123 mkdir 1mkdir 2mkdir 3 然后，我们便可以开始启动这三个 mong...
十一、mongodb分布式集群搭建
weixin_34355881的博客
03-11 127
2019独角兽企业重金招聘Python工程师标准>>> ...
MongoDB分布式部署方式
互联网知识分享
07-22 748
通过副本集和分片集群两种方式，MongoDB能够实现分布式部署，提供高可用性、备份和故障转移的能力。副本集适用于提供高可用性的场景，分片集群适用于处理大数据量和提高读写性能的场景。使用MongoDB的分布式部署方式，可以根据业务需求来选择合适的部署方案。
mongodb分片集群部署
最新发布
08-19
1. 部署配置服务器（config server）：配置服务器用于存储分片集群的元数据，可以独立部署或与其他组件共享服务器。您可以选择部署多个配置服务器以增加可用性。 2. 启动分片服务器（shard server）：分片服务器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值