MongoDB基础

1.MongoDB概述

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

MongoDB服务端可运行在Linux、Windows平台，支持32位和64位应用，默认端口为27017。推荐运行在64位平台，因为MongoDB在32位模式运行时支持的最大文件尺寸为2GB。

2.MongoDB 主要特点

2.1.文档

MongoDB中的记录是一个文档，它是由字段和值对组成的数据结构。多个键及其关联的值有序地放在一起就构成了文档。MongoDB文档类似于JSON对象。字段的值可以包括其他文档，数组和文档数组。

d92805724d3f40d7b3ed7fe720eb1165

{“greeting”:“hello,world”}这个文档只有一个键“greeting”，对应的值为“hello,world”。多数情况下，文档比这个更复杂，它包含多个键/值对。

例如：{“greeting”:“hello,world”,“foo”: 3} 文档中的键/值对是有序的，下面的文档与上面的文档是完全不同的两个文档。{“foo”: 3 ,“greeting”:“hello,world”} 文档中的值不仅可以是双引号中的字符串，也可以是其他的数据类型，例如，整型、布尔型等，也可以是另外一个文档，即文档可以嵌套。文档中的键类型只能是字符串。

使用文档的优点是：

文档（即对象）对应于许多编程语言中的本机数据类型
嵌入式文档和数组减少了对昂贵连接的需求
动态模式支持流畅的多态性

2.2.集合

集合就是一组文档，类似于关系数据库中的表。

集合是无模式的，集合中的文档可以是各式各样的。例如，{“hello,word”:“Mike”}和{“foo”: 3}，它们的键不同，值的类型也不同，但是它们可以存放在同一个集合中，也就是不同模式的文档都可以放在同一个集合中。

既然集合中可以存放任何类型的文档，那么为什么还需要使用多个集合？ 这是因为所有文档都放在同一个集合中，无论对于开发者还是管理员，都很难对集合进行管理，而且这种情形下，对集合的查询等操作效率都不高。所以在实际使用中，往往将文档分类存放在不同的集合中。例如，对于网站的日志记录，可以根据日志的级别进行存储，Info级别日志存放在Info 集合中，Debug 级别日志存放在Debug 集合中，这样既方便了管理，也提供了查询性能。但是需要注意的是，这种对文档进行划分来分别存储并不是MongoDB 的强制要求，用户可以灵活选择。

可以使用“.”按照命名空间将集合划分为子集合。例如，对于一个博客系统，可能包括blog.user 和blog.article 两个子集合，这样划分只是让组织结构更好一些，blog 集合和blog.user、blog.article 没有任何关系。虽然子集合没有任何特殊的地方，但是使用子集合组织数据结构清晰，这也是MongoDB 推荐的方法。

2.3.数据库

MongoDB 中多个文档组成集合，多个集合组成数据库。

一个MongoDB 实例可以承载多个数据库。它们之间可以看作相互独立，每个数据库都有独立的权限控制。在磁盘上，不同的数据库存放在不同的文件中。

MongoDB 中存在以下系统数据库。

Admin 数据库：一个权限数据库，如果创建用户的时候将该用户添加到admin 数据库中，那么该用户就自动继承了所有数据库的权限。
Local 数据库：这个数据库永远不会被复制，可以用来存储本地单台服务器的任意集合。
Config 数据库：当MongoDB 使用分片模式时，config 数据库在内部使用，用于保存分片的信息。

2.4.数据模型

一个MongoDB 实例可以包含一组数据库，一个DataBase 可以包含一组Collection（集合），一个集合可以包含一组Document（文档）。

一个Document包含一组field（字段），每一个字段都是一个key/value pair

key: 必须为字符串类型
value：可以包含如下类型
- 基本类型，例如，string，int，float，timestamp，binary 等类型
- 一个document
- 数组类型

3.Linux安装MongoDB

3.1.下载`MongoDB`

官方下载地址：https://www.mongodb.com/download-center/community

SHELL

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-4.2.1.tgz

3.2.解压安装

SHELL

tar -zxvf mongodb-linux-x86_64-rhel70-4.2.1.tgz

创建目录/usr/local/mongo，并将解压完的mongodb目录移动到/usr/local/mongo下

SHELL

mkdir -p /usr/local/mongo
mv mongodb-linux-x86_64-rhel70-4.2.1/* /usr/local/mongo/

切到/usr/local/mongo目录下，创建目录

SHELL

在conf目录，增加配置文件mongo.conf

SHELL

链接

SHELL

关闭服务

SHELL

[root@web-7 bin]# /usr/local/mongo/bin/mongod -f /usr/local/mongo/conf/mongo.conf --shutdown
killing process with pid: 8711

3.3.优化告警并使用systemctl管理

SHELL

4.MongoDB基本操作及增删改查

4.1.基本操作

登陆数据库

SHELL

mongo

查看数据库

SHELL

> show databases;
admin   0.000GB
config

选择数据库:use 数据库名

SHELL

> use admin
switched to db admin

如果切换到一个没有的数据库，例如use admin2，那么会隐式创建这个数据库。（后期当该数据库有数据时，系统自动创建）

SHELL

查看集合

SHELL

> show collections

创建集合

db.createCollection('集合名')

SHELL

删除集合

db.集合名.drop()

> db.c1.drop()
true
> show collections
c2

删除数据库 通过use语法选择数据通过db.dropDataBase()删除数据库

SHELL

4.2.增删改查

4.2.1.增加

db.集合名.insert(JSON数据)

如果集合存在，那么直接插入数据。如果集合不存在，那么会隐式创建。

示例：在test2数据库的c1集合中插入数据（姓名叫webopenfather年龄18岁）

SHELL

use test2 
db.c1.insert({uname:"webopenfather",age:18})

数据库和集合不存在都隐式创建
对象的键统一不加引号（方便看），但是查看集合数据时系统会自动加
mongodb会给每条数据增加一个全球唯一的_id键

SHELL

_id键的组成

0|1|2|3|4|5|6|7|8|9|10|11
时间戳  |机器  |PID|计数器

自己增加_id 可以，只需要给插入的JSON数据增加_id键即可覆盖（但实战强烈不推荐）

SHELL

db.c1.insert({_id:1, uname:"webopenfather", age:18})

一次性插入多条数据 传递数据，数组中写一个个JSON数据即可

SHELL

快速插入10条数据 由于mongodb底层使用JS引擎实现的，所以支持部分js语法。因此：可以写for循环

SHELL

查询文档

SHELL

db.集合名.find(条件[,查询的列])

条件	写法
查询所有的数据	{}或者不写
查询age=6的数据	{age:6}
既要age=6又要性别=男	{age:6,sex:‘男’}

查询的列（可选参数）	写法
查询全部列（字段）	不写
只显示age列（字段）	{age:1}
除了age列（字段）都显示	{age:0}

其他语法

SHELL

db.集合名.find({
            键:{运算符：值}
            })

运算符	作用
$gt	大于
$gte	大于等于
$lt	小于
$lte	小于等于
$ne	不等于
$in	in
$nin	not in

SHELL

系统的_id无论如何都会存在

查询age大于5的数据

SHELL

查询年龄是5岁、8岁、10岁的数据

SHELL

只看年龄列，或者年龄以外的列

SHELL

4.3.修改文档

db.集合名.update(条件,新数据[是否新增,是否修改多条,])

新数据此数据需要使用修改器，如果不使用，那么会将新数据替换原来的数据。1db.集合名.update(条件,{修改器:{键:值}}[是否新增,是否修改多条,]) 修改器作用inc递增rename重命名列set修改列值unset删除列
是否新增

指条件匹配不到数据则插入(true是插入，false否不插入默认)
SHELL
```
db.c3.update({uname:"zs30"},{$set:{age:30}},true)
```

实例练习 准备工作

SHELL

将{uname:"zs1"}改为{uname:"zs2"}

SHELL

给{uname:"zs10"}的年龄加2岁或减2岁

SHELL

递减只需要将2改为-2即可

4.4.删除文档

SHELL

db.集合名.remove(条件[,是否删除一条])

是否删除一条 true：是（删除的数据为第一条）

SHELL

false：否

SHELL

4.5.总结

高级开发攻城狮统称：所有数据库都需要增删改查CURD标识

MongoDB删除语法：remove

增Create

db.集合名.insert(JSON数据)

删Delete

db.集合名.remove(条件 [,是否删除一条true是false否默认])
 
也就是默认删除多条

改Update

db.集合名.update(条件， 新数据  [,是否新增,是否修改多条])
 
升级语法db.集合名.update(条件，{修改器：{键：值}})
123

查Read

db.集合名.find(条件 [,查询的列])

5.MongoDB存储数据类型

MongoDB中每条记录称作一个文档，这个文档和我们平时用的JSON有点像，但也不完全一样。JSON是一种轻量级的数据交换格式。简洁和清晰的层次结构使得JSON成为理想的数据交换语言，JSON易于阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率，但是JSON也有它的局限性，比如它只有null、布尔、数字、字符串、数组和对象这几种数据类型，没有日期类型，只有一种数字类型，无法区分浮点数和整数，也没法表示正则表达式或者函数。由于这些局限性，BSON闪亮登场啦，BSON是一种类JSON的二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型，MongoDB使用BSON做为文档数据存储和网络传输格式。

5.1.数字

shell默认使用64位浮点型数值，如下：

SHELL

db.sang_collec.insert({x:3.1415926})
db.sang_collec.insert({x:3})

对于整型值，我们可以使用NumberInt或者NumberLong表示，如下：

SHELL

db.sang_collec.insert({x:NumberInt(10)})
db.sang_collec.insert({x:NumberLong

5.2.字符串

字符串也可以直接存储，如下：

db.sang_collec.insert({x:"hello MongoDB!"})

5.3.正则表达式

正则表达式主要用在查询里边，查询时我们可以使用正则表达式，语法和JavaScript中正则表达式的语法相同，比如查询所有key为x，value以hello开始的文档且不区分大小写：

db.sang_collec.find({x:/^(hello)(.[a-zA-Z0-9])+/i})

5.4 数组

数组一样也是被支持的，如下：

db.sang_collec.insert({x:[1,2,3,4,new Date()]})

数组中的数据类型可以是多种多样的。

5.5.日期

MongoDB支持Date类型的数据，可以直接new一个Date对象，如下：

db.sang_collec.insert({x:new Date()})

5.6.内嵌文档

一个文档也可以作为另一个文档的value，这个其实很好理解，如下：

db.sang_collect.insert({name:"三国演义",author:{name:"罗贯中",age:99}});

6.MongoDB中的索引

6.1.索引创建

默认情况下，集合中的_id字段就是索引，我们可以通过getIndexes()方法来查看一个集合中的索引：

SHELL

db.sang_collect.getIndexes()

结果如下

JSON

我们看到这里只有一个索引，就是_id。

现在我的集合中有10000个文档，我想要查询x为1的文档，我的查询操作如下

db.sang_collect.find({x:1})

这种查询默认情况下会做全表扫描，我们可以用上篇文章介绍的explain()来查看一下查询计划，如下

db.sang_collect.find({x:1}).explain("executionStats")

结果如下

SHELL

结果比较长，我摘取了关键的一部分。我们可以看到查询方式是全表扫描，一共扫描了10000个文档才查出来我要的结果。实际上我要的文档就排第二个，但是系统不知道这个集合中一共有多少个x为1的文档，所以会把全表扫描完，这种方式当然很低效，但是如果我加上 limit，如下：

SHELL

db.sang_collect.find({x:1}).limit(1)

此时再看查询计划发现只扫描了两个文档就有结果了，但是如果我要查询x为9999的记录，那还是得把全表扫描一遍，此时，我们就可以给该字段建立索引，索引建立方式如下：

db.sang_collect.ensureIndex({x:1})

1表示升序，-1表示降序。当我们给x字段建立索引之后，再根据x字段去查询，速度就非常快了，我们看下面这个查询操作的执行计划：

db.sang_collect.find({x:9999}).explain("executionStats")

这个查询计划过长我就不贴出来了，我们可以重点关注查询要耗费的时间大幅度下降。

此时调用getIndexes()方法可以看到我们刚刚创建的索引，如下

JSON

我们看到每个索引都有一个名字，默认的索引名字为字段名_排序值，当然我们也可以在创建索引时自定义索引名字，如下：

db.sang_collect.ensureIndex({x:1},{name:"myfirstindex"})

此时创建好的索引如下

JSON

当然索引在创建的过程中还有许多其他可选参数，如下

SHELL

db.sang_collect.ensureIndex({x:1},{name:"myfirstindex",dropDups:true,background:true,unique:true,sparse:true,v:1,weights:99999})

关于这里的参数

此时创建好的索引如下

JSON

6.2.查看索引

getIndexes()可以用来查看索引，我们还可以通过totalIndexSize()来查看索引的大小，如下：

db.sang_collect.totalIndexSize()

6.3.删除索引

我们可以按名称删除索引，如下：

db.sang_collect.dropIndex("xIndex")
1

表示删除一个名为xIndex的索引，当然我们也可以删除所有索引，如下：

db.sang_collect.dropIndexes()

6.4.总结

索引是个好东西，可以有效的提高查询速度，但是索引会降低插入、更新和删除的速度，因为这些操作不仅要更新文档，还要更新索引，MongoDB 限制每个集合上最多有64个索引，我们在创建索引时要仔细斟酌索引的字段。

7.`MongoDB`之副本集配置

7.1.`MongoDB`主从复制

主从复制是MongoDB最早使用的复制方式，该复制方式易于配置，并且可以支持任意数量的从节点服务器，与使用单节点模式相比有如下优点：

在从服务器上存储数据副本，提高了数据的可用性，并可以保证数据的安全性。

可配置读写分离，主节点负责写操作，从节点负责读操作，将读写压力分开，提高系统的稳定性。

MongoDB 的主从复制至少需要两个服务器或者节点。其中一个是主节点，负责处理客户端请求，其它的都是从节点，负责同步主节点的数据。

主节点记录在其上执行的所有写操作，从节点定期轮询主节点获取这些操作，然后再对自己的数据副本执行这些操作。由于和主节点执行了相同的操作，从节点就能保持与主节点的数据同步。

主节点的操作记录称为oplog(operation log)，它被存储在 MongoDB 的 local 数据库中。oplog 中的每个文档都代表主节点上执行的一个操作。需要重点强调的是oplog只记录改变数据库状态的操作。比如，查询操作就不会被存储在oplog中。这是因为oplog只是作为从节点与主节点保持数据同步的机制。

然而，主从复制并非生产环境下推荐的复制方式，主要原因如下两点：

1、灾备都是完全人工的如果主节点发生故障失败，管理员必须关闭一个从服务器，然后作为主节点重新启动它。然后应用程序必须重新配置连接新的主节点。 2、数据恢复困难因为oplog只在主节点存在，故障失败需要在新的服务器上创建新的oplog，这意味着任意存在的节点需要重新从新的主节点同步oplog。

因此，在新版本的MongoDB中已经不再支持使用主从复制这种复制方式了，取而代之的是使用副本集复制方式。 7.2.MongoDB副本集

MongoDB副本集（Replica Set）其实就是具有自动故障恢复功能的主从集群，和主从复制最大的区别就是在副本集中没有固定的“主节点；整个副本集会选出一个节点作为“主节点”，当其挂掉后，再在剩下的从节点中选举一个节点成为新的“主节点”，在副本集中总有一个主节点(primary)和一个或多个备份节点(secondary)。

除了primary和secondary之外，副本集中的节点还可以是以下角色：

	成为primary	对客户端可见	参与投票	延迟同步	复制数据
Default	√	√	√	∕	√
Secondary-Only	∕	√	√	∕	√
Hidden	∕	∕	√	∕	√
Delayed∕	√	√	√	√
Arbiters	∕	∕	√	∕	∕
Non-Voting	√	√	∕	∕	√

官方推荐的副本集最小配置需要有三个节点：一个主节点接收和处理所有的写操作，两个备份节点通过复制主节点的操作来对主节点的数据进行同步备份。

7.2.安装MongDB

配置文件

YAML

7.3.副本集初始化

通过Shell连接到任意一个MongoDB实例，执行rs.initiate()方法对副本集进行初始化。

JSON

如果在执行rs.initiate()方法时不传入任何参数，MongoDB 将以默认的配置文档对副本集进行初始化，后续可以再通过rs.add()方法来向副本集中添加成员。

7.4.副本集更新

SHELL

例如，强制让一个节点成为Primary，可以将该节点的优先级设置成最高。

SHELL

7.5.副本集监控

SHELL

7.6.副本集测试

在Primary 上插入一万条客户数据

SHELL

在Secondary上查看客户数据是否已经同步

SHELL

rs0:SECONDARY> rs.slaveOk()
rs0:SECONDARY> db.customer.count()

7.7.故障转移测试

查看Primary节点关闭之前的状态

JSON

在任意其他节点上查看Primary节点关闭之后的状态

JSON

再次启动10.0.0.7:27017节点，节点启动后再次查看副本集状态

SHELL

7.8.开启安全认证

创建用户 登录 PRIMARY节点创建用户，在此我们对 test 库开启安全认证。

JSON

创建keyFile文件 先停掉所有SECONDARY节点的MongoDB服务，然后再停掉PRIMARY节点的MongoDB服务，并在节点所在服务器上创建文件。

SHELL

[root@web-8 mongo]# openssl rand -base64 666 > /usr/local/mongo/keyfile
[root@web-8 mongo]# chmod 600 /usr/local/mongo/keyfile

将生成的keyFile文件拷贝到其他节点服务器上，并修改文件的操作权限为 600

SHELL

[root@web-9 mongo]# chmod 600 /usr/local/mongo/keyfile

更新启动配置文件修改PRIMARY节点的 mongodb.conf 文件，增加如下内容

SHELL

修改SECONDARY节点的 mongodb.conf 文件，增加如下内容

SHELL

# Add below Config
oplogSize=100
keyFile=/usr/local/mongo/keyfile

启动副本集

先启动PRIMARY节点再启动SECONDARY节点

登录测试

admin用户只能看到test库

8.备份恢复

在Mongodb中我们使用mongodump命令来备份MongoDB数据。该命令可以导出所有数据 (数据和数据结构) 或指定数据（集合、部分集合内容）到指定目录中

SHELL

mongorestore数据恢复

SHELL

MongoDB数据导入与导出

导出工具：mongoexport

SHELL

数据导入：mongoimport

SHELL

cd /usr/local/mongo
mkdir -p data/db        #数据库目录
mkdir -p logs           #日志目录
mkdir -p conf           #配置文件目录
mkdir -p pids           #进程描述文件目录
 
[root@web-7 mongo]# ll
total 312
drwxr-xr-x 2 root root    231 Feb 26 11:12 bin
drwxr-xr-x 2 root root      6 Feb 26 11:12 conf
drwxr-xr-x 3 root root     16 Feb 26 11:12 data
-rw-r--r-- 1 root root  30608 Oct 16  2019 LICENSE-Community.txt
drwxr-xr-x 2 root root      6 Feb 26 11:12 logs
-rw-r--r-- 1 root root  16726 Oct 16  2019 MPL-2
drwxr-xr-x 2 root root      6 Feb 26 11:12 pids
-rw-r--r-- 1 root root   2617 Oct 16  2019 README
-rw-r--r-- 1 root root  75405 Oct 16  2019 THIRD-PARTY-NOTICES
-rw-r--r-- 1 root root 183512 Oct 16  2019 THIRD-PARTY-NOTICES.gotools

cat >/usr/local/mongo/conf/mongo.conf<<EOF
systemLog:
  destination: file    #Mongodb 日志输出的目的地，指定一个 file 或者 syslog，如果指定 file，必须指定systemlog.path
  logAppend: true   #当实例重启时，不创建新的日志文件，在老的日志文件末尾继续添加
  path: /usr/local/mongo/logs/mongo.log  # 日志路径
 
storage:
  journal:
    enabled: true # 回滚日志
  dbPath: /usr/local/mongo/data/db/  # 数据存储目录
  directoryPerDB: true 
  wiredTiger:
    engineConfig:
      cacheSizeGB: 0.5  # 缓存大小
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
 
processManagement: # 守护进程控制器
  fork: true
  pidFilePath: /usr/local/mongo/pids/mongo.pid
 
net:
  port: 27017 # 监听端口
  bindIp: 0.0.0.0 # 绑定地址
EOF

[root@web-7 bin]# /usr/local/mongo/bin/mongo
MongoDB shell version v4.2.1
connecting to: mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("05672aa0-729f-48de-a774-6615d5cb26c3") }
MongoDB server version: 4.2.1

groupadd mongo -g 777
useradd mongo -g 777 -u 777 -M -s /sbin/nologin
id mongo
 
cat >/usr/lib/systemd/system/mongod.service<<EOF
[Unit]
Description=www.yuchaoit.cn mongodb
Documentation=https://docs.mongodb.org/manual
After=network.target
 
[Service]
User=mongo
Group=mongo
ExecStart=/usr/local/mongo/bin/mongod -f /usr/local/mongo/conf/mongo.conf
ExecStartPre=/usr/bin/chown -R mongo:mongo /usr/local/mongo/
 
PermissionsStartOnly=true
PIDFile=/usr/local/mongo/pids/mongo.pid
Type=forking
# file size
LimitFSIZE=infinity
# cpu time
LimitCPU=infinity
# virtual memory size
LimitAS=infinity
# open files
LimitNOFILE=64000
# processes/threads
LimitNPROC=64000
# locked memory
LimitMEMLOCK=infinity
# total threads (user+kernel)
TasksMax=infinity
TasksAccounting=false
# Recommended limits for for mongod as specified in
# http://docs.mongodb.org/manual/reference/ulimit/#recommended-settings
 
[Install]
WantedBy=multi-user.target
EOF
 
systemctl daemon-reload 
systemctl start mongod.service
systemctl status mongod.service
 
echo 'export PATH=/usr/local/mongo/bin:$PATH' >> /etc/profile
source /etc/profile
 
测试登录
mongo

> use admin2
switched to db admin2
> show databases;
admin   0.000GB
config  0.000GB
local   0.000GB

> db.createCollection('c1')
{ "ok" : 1 }
> db.createCollection('c2')
{ "ok" : 1 }
> show collections
c1
c2

> use admin2
switched to db admin2
> db.dropDatabase()
{ "dropped" : "admin2", "ok" : 1 }

> use test2
switched to db test2
> db.c1.insert({uname:"webopenfather",age:18})
WriteResult({ "nInserted" : 1 })
> db.c1.find()
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "uname" : "webopenfather", "age" : 18 }
> show databases;
admin   0.000GB
config  0.000GB
local   0.000GB
test2   0.000GB

db.c1.insert([     {uname:"z3", age:3},     {uname:"z4", age:4},     {uname:"w5", age:5} ])
> db.c1.find()
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "uname" : "webopenfather", "age" : 18 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad61"), "uname" : "z3", "age" : 3 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad62"), "uname" : "z4", "age" : 4 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad63"), "uname" : "w5", "age" : 5 }

for (var i=1; i<=10; i++) {     db.c2.insert({uanme: "a"+i, age: i}) }
> db.c2.find()
{ "_id" : ObjectId("65dc341ac6cc97cb780cad64"), "uanme" : "a1", "age" : 1 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad65"), "uanme" : "a2", "age" : 2 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad66"), "uanme" : "a3", "age" : 3 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad67"), "uanme" : "a4", "age" : 4 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad68"), "uanme" : "a5", "age" : 5 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad69"), "uanme" : "a6", "age" : 6 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6a"), "uanme" : "a7", "age" : 7 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6b"), "uanme" : "a8", "age" : 8 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6c"), "uanme" : "a9", "age" : 9 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6d"), "uanme" : "a10", "age" : 10 }

> show databases;
admin   0.000GB
config  0.000GB
local   0.000GB
test2   0.000GB
> use test2
switched to db test2
> show collections
c1
c2
> 
> db.c1.find()   #查询全部数据
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "uname" : "webopenfather", "age" : 18 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad61"), "uname" : "z3", "age" : 3 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad62"), "uname" : "z4", "age" : 4 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad63"), "uname" : "w5", "age" : 5 }
> db.c1.find({},{uname:1})  #只看uanme列
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "uname" : "webopenfather" }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad61"), "uname" : "z3" }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad62"), "uname" : "z4" }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad63"), "uname" : "w5" }
> db.c1.find({},{uname:0})  #除了uname列都看
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "age" : 18 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad61"), "age" : 3 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad62"), "age" : 4 }
{ "_id" : ObjectId("65dc33cec6cc97cb780cad63"), "age" : 5 }

> db.c1.find({age:{$gt:5}})
{ "_id" : ObjectId("65dc1f8cc6cc97cb780cad60"), "uname" : "webopenfather", "age" : 18 }

> db.c2.find({age:{$in:[5,8,10]}})
{ "_id" : ObjectId("65dc341ac6cc97cb780cad68"), "uanme" : "a5", "age" : 5 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6b"), "uanme" : "a8", "age" : 8 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6d"), "uanme" : "a10", "age" : 10 }

> db.c2.find({},{age:1})
{ "_id" : ObjectId("65dc341ac6cc97cb780cad64"), "age" : 1 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad65"), "age" : 2 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad66"), "age" : 3 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad67"), "age" : 4 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad68"), "age" : 5 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad69"), "age" : 6 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6a"), "age" : 7 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6b"), "age" : 8 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6c"), "age" : 9 }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6d"), "age" : 10 }
> db.c2.find({},{age:0})
{ "_id" : ObjectId("65dc341ac6cc97cb780cad64"), "uanme" : "a1" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad65"), "uanme" : "a2" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad66"), "uanme" : "a3" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad67"), "uanme" : "a4" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad68"), "uanme" : "a5" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad69"), "uanme" : "a6" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6a"), "uanme" : "a7" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6b"), "uanme" : "a8" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6c"), "uanme" : "a9" }
{ "_id" : ObjectId("65dc341ac6cc97cb780cad6d"), "uanme" : "a10" }

> db.c3.update({uname:"zs30"},{$set:{age:30}},true)
WriteResult({
	"nMatched" : 0,
	"nUpserted" : 1,
	"nModified" : 0,
	"_id" : ObjectId("65dc3de96005319b39d999f2")
})
> db.c3.find()
{ "_id" : ObjectId("65dc3de96005319b39d999f2"), "uname" : "zs30", "age" : 30 }
> db.c3.update({uname:"zs30"},{$set:{age:50}},true)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.c3.find()
{ "_id" :

use test2;
for(var i = 1; i<= 10; i++){
	db.c3.insert( {"uname":"zs"+i,"age":i} );
}
 
> db.c3.find()
{ "_id" : ObjectId("65dc3de96005319b39d999f2"), "uname" : "zs30", "age" : 50 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs1", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 10 }

db.c3.update({uname:"zs1"},{$set:{uname:"zs2"}})
> db.c3.find()
{ "_id" : ObjectId("65dc3de96005319b39d999f2"), "uname" : "zs30", "age" : 50 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 10 }

db.c3.update({uname:"zs10"},{$inc:{age:2}})
> db.c3.find()
{ "_id" : ObjectId("65dc3de96005319b39d999f2"), "uname" : "zs30", "age" : 50 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 12 }

> db.c3.find()
{ "_id" : ObjectId("65dc3de96005319b39d999f2"), "uname" : "zs30", "age" : 50 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 12 }
> db.c3.re
db.c3.reIndex(           db.c3.remove(            db.c3.renameCollection(  db.c3.replaceOne(
> db.c3.remove({},true)
WriteResult({ "nRemoved" : 1 })
> db.c3.find()
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 12 }

db.c3.remove({uname:"zs3"})
> db.c3.find()
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad70"), "uname" : "zs3", "age" : 3 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 12 }
> db.c3.remove({uname:"zs3"})
WriteResult({ "nRemoved" : 1 })
> db.c3.find()
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6e"), "uname" : "zs2", "age" : 1 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad6f"), "uname" : "zs2", "age" : 2 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad71"), "uname" : "zs4", "age" : 4 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad72"), "uname" : "zs5", "age" : 5 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad73"), "uname" : "zs6", "age" : 6 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad74"), "uname" : "zs7", "age" : 7 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad75"), "uname" : "zs8", "age" : 8 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad76"), "uname" : "zs9", "age" : 9 }
{ "_id" : ObjectId("65dc3e66c6cc97cb780cad77"), "uname" : "zs10", "age" : 12 }

[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "sang.sang_collect"
    }
]

{
    "queryPlanner" : {
    },
    "executionStats" : {
        "executionSuccess" : true,
        "nReturned" : 1,
        "executionTimeMillis" : 15,
        "totalKeysExamined" : 0,
        "totalDocsExamined" : 10000,
        "executionStages" : {
            "stage" : "COLLSCAN",
            "filter" : {
                "x" : {
                    "$eq" : 1.0
                }
            },
            "nReturned" : 1,
            "executionTimeMillisEstimate" : 29,
            "works" : 10002,
            "advanced" : 1,
            "needTime" : 10000,
            "needYield" : 0,
            "saveState" : 78,
            "restoreState" : 78,
            "isEOF" : 1,
            "invalidates" : 0,
            "direction" : "forward",
            "docsExamined" : 10000
        }
    },
    "serverInfo" : {
    },
    "ok" : 1.0
}

[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "sang.sang_collect"
    },
    {
        "v" : 2,
        "key" : {
            "x" : 1.0
        },
        "name" : "x_1",
        "ns" : "sang.sang_collect"
    }
]

{
    "v" : 2,
    "key" : {
        "x" : 1.0
    },
    "name" : "myfirstindex",
    "ns" : "sang.sang_collect"
}

{
    "v" : 1,
    "unique" : true,
    "key" : {
        "x" : 1.0
    },
    "name" : "myfirstindex",
    "ns" : "sang.sang_collect",
    "background" : true,
    "sparse" : true,
    "weights" : 99999.0
}

[root@web-7 conf]# cat mongo.conf 
systemLog:
  destination: file    #Mongodb 日志输出的目的地，指定一个 file 或者 syslog，如果指定 file，必须指定systemlog.path
  logAppend: true   #当实例重启时，不创建新的日志文件，在老的日志文件末尾继续添加
  path: /usr/local/mongo/logs/mongo.log  # 日志路径
 
storage:
  journal:
    enabled: true # 回滚日志
  dbPath: /usr/local/mongo/data/db/  # 数据存储目录
  directoryPerDB: true 
  wiredTiger:
    engineConfig:
      cacheSizeGB: 0.5  # 缓存大小
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
 
processManagement: # 守护进程控制器
  fork: true
  pidFilePath: /usr/local/mongo/pids/mongo.pid
 
net:
  port: 27017 # 监听端口
  bindIp: 0.0.0.0 # 绑定地址
replication:
  replSetName: "myReplicaSet"  # 设置副本集的名称

[root@hadoop34 mongodb-4.0.2]# mongo 10.0.0.7:27017
> conf=
    {
    "_id" : "myReplicaSet",
    "members" : [
        { "_id" : 0, "host" : "10.0.0.7:27017" },
        { "_id" : 1, "host" : "10.0.0.8:27017" },
        { "_id" : 2, "host" : "10.0.0.9:27017" }
        ]
    }
> rs.initiate(conf)
 
> conf=
...     {
...     "_id" : "myReplicaSet",
...     "members" : [
...         { "_id" : 0, "host" : "10.0.0.7:27017" },
...         { "_id" : 1, "host" : "10.0.0.8:27017" },
...         { "_id" : 2, "host" : "10.0.0.9:27017" }
...         ]
...     }
{
	"_id" : "myReplicaSet",
	"members" : [
		{
			"_id" : 0,
			"host" : "10.0.0.7:27017"
		},
		{
			"_id" : 1,
			"host" : "10.0.0.8:27017"
		},
		{
			"_id" : 2,
			"host" : "10.0.0.9:27017"
		}
	]
}
> rs.initiate(conf)
{
	"ok" : 1,
	"$clusterTime" : {
		"clusterTime" : Timestamp(1708997271, 1),
		"signature" : {
			"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
			"keyId" : NumberLong(0)
		}
	},
	"operationTime" : Timestamp(1708997271, 1)
}

# 向副本集中添加成员
rs.add("10.0.0.7:27017")
 
# 从副本集中删除成员
rs.remove("10.0.0.7:27017")
 
# 向副本集中添加仲裁
rs.addArb("10.0.0.7:27017")
 
# 向副本集中添加备份节点
rs.add({"_id":3,"host":"10.0.0.7:27017","priority":0,"hidden":true})
 
# 更改副本集配置
rs0:PRIMARY> var conf=rs.conf()
rs0:PRIMARY> conf.members[1].priority = 5
 
# PRIMARY节点上执行如下命令
rs0:PRIMARY> rs.reconfig(conf)
{
    "ok" : 1,
    "operationTime" : Timestamp(1542248518, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1542248518, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}
 
# SECONDARY节点上执行如下命令，需增加 force 参数
rs0:SECONDARY> rs.reconfig(conf,{force:true})
{
    "ok" : 1,
    "operationTime" : Timestamp(1542248726, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1542248726, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

cfg = rs.conf()
cfg.members[0].priority = 5
cfg.members[1].priority = 1
cfg.members[2].priority = 1
rs.reconfig(cfg)

myReplicaSet:PRIMARY> rs.conf()
{
	"_id" : "myReplicaSet",
	"version" : 1,
	"protocolVersion" : NumberLong(1),
	"writeConcernMajorityJournalDefault" : true,
	"members" : [
		{
			"_id" : 0,
			"host" : "10.0.0.7:27017",
			"arbiterOnly" : false,
			"buildIndexes" : true,
			"hidden" : false,
			"priority" : 1,
			"tags" : {
				
			},
			"slaveDelay" :

rs0:PRIMARY> for(var i=0;i<10000;i++){db.customer.insert({"name":"user"+i})}
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.customer.count()
10000

myReplicaSet:PRIMARY> rs.status()
{
	"set" : "myReplicaSet",
	"date" : ISODate("2024-02-27T01:43:18.182Z"),
	"myState" : 1,
	"term" : NumberLong(1),
	"syncingTo" : "",
	"syncSourceHost" : "",
	"syncSourceId" : -1,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"majorityVoteCount" : 2,
	"writeMajorityCount" : 2,
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1708998192

myReplicaSet:SECONDARY> rs.status()
{
	"set" : "myReplicaSet",
	"date" : ISODate("2024-02-27T01:44:27.578Z"),
	"myState" : 1,
	"term" : NumberLong(2),
	"syncingTo" : "",
	"syncSourceHost" : "",
	"syncSourceId" : -1,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"majorityVoteCount" : 2,
	"writeMajorityCount" : 2,
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" : Timestamp(1708998264

myReplicaSet:SECONDARY> rs.status()
{
	"set" : "myReplicaSet",
	"date" : ISODate("2024-02-27T01:47:27.080Z"),
	"myState" : 2,
	"term" : NumberLong(2),
	"syncingTo" : "10.0.0.9:27017",
	"syncSourceHost" : "10.0.0.9:27017",
	"syncSourceId" : 2,
	"heartbeatIntervalMillis" : NumberLong(2000),
	"majorityVoteCount" : 2,
	"writeMajorityCount" : 2,
	"optimes" : {
		"lastCommittedOpTime" : {
			"ts" :

myReplicaSet:PRIMARY> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB
myReplicaSet:PRIMARY> 
myReplicaSet:PRIMARY> use admin
switched to db admin
myReplicaSet:PRIMARY> db.createUser({user:"root",pwd:"123456",roles:[{role:"userAdminAnyDatabase",db:"admin"}]})
Successfully added user: {
	"user" : "root",
	"roles" : [
		{
			"role" : "userAdminAnyDatabase",
			"db" : "admin"
		}
	]
}
myReplicaSet:PRIMARY> use test
switched to db test
myReplicaSet:PRIMARY> db.createUser({user:"admin",pwd:"admin",roles:[{role:"readWrite",db:"test"}]})
Successfully added user: {
	"user" : "admin",
	"roles" : [
		{
			"role" : "readWrite",
			"db" : "test"
		}
	]
}

写法一：# Add below Config
auth=true
oplogSize=100
keyFile=/usr/local/mongo/keyfile
写法二：
replication:
  replSetName: "myReplicaSet"
  oplogSizeMB: 100  # 设置oplog大小为100MB
security:
  authorization: enabled  # 启用身份验证
  keyFile: /usr/local/mongo/keyfile  # 设置keyFile路径

[root@web-8 mongo]# mongo -uadmin -padmin 10.0.0.8:27017
MongoDB shell version v4.2.1
connecting to: mongodb://10.0.0.8:27017/test?compressors=disabled&gssapiServiceName=mongodb
Implicit session: session { "id" : UUID("6c43ca9d-8674-43eb-b206-bc372604b208") }
MongoDB server version: 4.2.1
myReplicaSet:PRIMARY> show dbs;
test  0.000GB

语法：
mongodump -h dbhost -d dbname -o dbdirectory
参数
-p，–port：端口
-h，–host：IP地址
-d，–db：数据库
-c，–collection：备份的集合名称
-q，–query：备份数据的条件表达式
-o，–out：备份文件的存放位置
-u，–username：用户名 （可选）
-p，–password：密码 （可选）
–authenticationDataBase：认证数据库（若数据库开启了认证该参数必须传！）
 
#备份所有数据库 
	#非认证数据库
	mongodump --port=27017 -h 127.0.0.1 -o /data/mongodb_backup  
	#认证数据库
	mongodump -h 127.0.0.1:27017 -o /data/mongodb_backup  -u root -p 123456 --	authenticationDataBase：admin
	#--port可以不传，直接写在ip后即可
	
#具体根据实际数据库是否是开启了认证选择，下面都以认证过的为例，没认证只是少传几个参数
	
#备份指定数据库db1 
	mongodump -d db1 -h 127.0.0.1:27017 -o /data/mongodb_backup  -u root -p 123456 --authenticationDatabase admin
#备份db1数据库中的test集合中的name="张三"的记录
	mongodump -d db1 -c test -q '{name:{$eq:"张三"}}' -h 127.0.0.1：27017 -o /data/mongodb_backup  -u root -p 123456 --authenticationDatabase admin
 
[root@web-8 mongo]# mongodump -h 127.0.0.1:27017 -o /data/mongodb_backup -u root -p 123456 --authenticationDatabase=admin
2024-02-27T11:17:28.835+0800	writing admin.system.users to 
2024-02-27T11:17:28.835+0800	done dumping admin.system.users (2 documents)
2024-02-27T11:17:28.835+0800	writing admin.system.version to 
2024-02-27T11:17:28.836+0800	done dumping admin.system.version (2 documents)
2024-02-27T11:17:28.836+0800	writing test.customer to 
2024-02-27T11:17:28.848+0800	done dumping test.customer (10000 documents)

语法：
mongorestore -h dbhost -d dbname --dir dbdirectory
参数
-p，–port
-h，–host
-d，–db 需要恢复的数据库实例，例如：test，当然这个名称也可以和备份时候的不一样，比如test2
-c，–collection
–dir：恢复文件存放的位置，如果指定了数据库文件夹或者集合文件，则只恢复当前数据库或者当前集合，如果没有指定，则恢复当前目录下所有备份数据。
–drop：恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！
-u，–user
-p，–password
–authenticationDatabase
#恢复所有数据库
 mongorestore -h 127.0.0.1:27017 --dir /data/mongodb_backup
#恢复制定数据库
 mongorestore -h 127.0.0.1:27017 -d bd1 --dir /data/mongodb_backup

概念：
mongoDB中的mongoexport工具可以把一个collection导出成JSON格式或CSV格式的文件。可以通过参数指定导出的数据项，也可以根据指定的条件导出数据。
语法：
mongoexport -d dbname -c collectionname -o file --type json/csv -f field
参数说明：
-d ：数据库名
-c ：collection名
-o ：输出的文件名
–type ： 输出的格式，默认为json
-f ：输出的字段，如果-type为csv，则需要加上-f “字段名”
#备份db1库下的test集合 (备份文件的名字可以自定义，默认导出了JSON格式的数据)
 
    mongoexport -h 127.0.0.1:27017 -u root -p 123456 --authenticationDatabase admin -d db1 -c test -o /home/mongod/backup/test.dat
    
#导出CSV格式的数据
 
    mongoexport -h 127.0.0.1:27017 -u root -p 123456 --authenticationDatabase admin -d db1 -c test --type=csv -f "id,name" -o /home/mongod/backup/test_csv.dat

语法：
mongoimport -d dbname -c collectionname --file filename --headerline --type json/csv -f field
参数说明：
-d ：数据库名
-c ：collection名
-type ：导入的格式默认json
-f ：导入的字段名
–drop 插入之前先删除原有的
–headerline ：如果导入的格式是csv，则可以使用第一行的标题作为导入的字段
–file ：要导入的文件
#将之前恢复的数据导入
mongoimport -h 127.0.0.1:27017 -u root -p 123456 --authenticationDatabase admin -d db1 -c test --file /home/mongod/backup/test.dat
 
#将之前恢复的CSV格式数据导入
mongoimport -h 127.0.0.1:27017 -u root -p 123456 --authenticationDatabase admin -d db1 -c test --type=csv --headerline --file /home/mongod/backup/test_csv.dat

1.MongoDB概述

2.MongoDB 主要特点

2.1.文档

2.2.集合

2.3.数据库

2.4.数据模型

3.Linux安装MongoDB

3.1.下载MongoDB

3.2.解压安装

3.3.优化告警并使用systemctl管理

4.MongoDB基本操作及增删改查

4.1.基本操作

4.2.增删改查

4.2.1.增加

4.3.修改文档

4.4.删除文档

4.5.总结

5.MongoDB存储数据类型

5.1.数字

5.2.字符串

5.3.正则表达式

5.4 数组

5.5.日期

5.6.内嵌文档

6.MongoDB中的索引

6.1.索引创建

6.2.查看索引

6.3.删除索引

6.4.总结

7.MongoDB之副本集配置

7.1.MongoDB主从复制

7.2.安装MongDB

7.3.副本集初始化

7.4.副本集更新

7.5.副本集监控

7.6.副本集测试

7.7.故障转移测试

7.8.开启安全认证

8.备份恢复

3.1.下载`MongoDB`

7.`MongoDB`之副本集配置

7.1.`MongoDB`主从复制