MongoDB高可用部署

2023-11-11 来源：花图问答

技术分享

1、准备基础环境

在网上下载mongodb-linux-x86_64-rhel62-3.4.2.gz放到各个服务器上，解压后放在对应的目录下，然后在根目录下新建data文件夹统一用于存放数据和配置信息。

2、搭建配置集群243-244-245

在mongo的根目录下新建start脚本，内容如下

bin/./mongod --dbpath data/ --logpath data/mongo.log  --configsvr --fork --port 20243 --replSet config

其中 configsvr表示配置服务，fork表示后台启动，replSet表示集群，config表示集群名字

同样在其他配置服务上也建立对应的start启动文件，记得修改端口哦。

启动-3台都启动

./start

随便进入一台机器，进入mongo，运行如下命令

>config = { _id:"config", configsvr:true, members:[ {_id:0,host:‘172.16.13.243:20243‘}, {_id:1,host:‘172.16.13.244:20244‘}, {_id:2,host:‘172.16.13.245:20245‘} ] }{"_id" : "config","configsvr" : true,"members" : [{"_id" : 0,"host" : "172.16.13.243:20243"},{"_id" : 1,"host" : "172.16.13.244:20244"},{"_id" : 2,"host" : "172.16.13.245:20245"}]}> rs.initiate(config){ "ok" : 1 }

查看集群状态

config:PRIMARY> rs.status();{"set" : "config","date" : ISODate("2017-04-12T09:29:51.889Z"),"myState" : 1,"term" : NumberLong(1),"configsvr" : true,"heartbeatIntervalMillis" : NumberLong(2000),"optimes" : {"lastCommittedOpTime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"readConcernMajorityOpTime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"appliedOpTime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"durableOpTime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)}},"members" : [{"_id" : 0,"name" : "172.16.13.243:20243","health" : 1,"state" : 1,"stateStr" : "PRIMARY","uptime" : 621,"optime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"optimeDate" : ISODate("2017-04-12T09:29:42Z"),"infoMessage" : "could not find member to sync from","electionTime" : Timestamp(1491989360, 1),"electionDate" : ISODate("2017-04-12T09:29:20Z"),"configVersion" : 1,"self" : true},{"_id" : 1,"name" : "172.16.13.244:20244","health" : 1,"state" : 2,"stateStr" : "SECONDARY","uptime" : 42,"optime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"optimeDurable" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"optimeDate" : ISODate("2017-04-12T09:29:42Z"),"optimeDurableDate" : ISODate("2017-04-12T09:29:42Z"),"lastHeartbeat" : ISODate("2017-04-12T09:29:50.238Z"),"lastHeartbeatRecv" : ISODate("2017-04-12T09:29:51.467Z"),"pingMs" : NumberLong(0),"syncingTo" : "172.16.13.243:20243","configVersion" : 1},{"_id" : 2,"name" : "172.16.13.245:20245","health" : 1,"state" : 2,"stateStr" : "SECONDARY","uptime" : 42,"optime" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"optimeDurable" : {"ts" : Timestamp(1491989382, 1),"t" : NumberLong(1)},"optimeDate" : ISODate("2017-04-12T09:29:42Z"),"optimeDurableDate" : ISODate("2017-04-12T09:29:42Z"),"lastHeartbeat" : ISODate("2017-04-12T09:29:50.237Z"),"lastHeartbeatRecv" : ISODate("2017-04-12T09:29:51.537Z"),"pingMs" : NumberLong(0),"syncingTo" : "172.16.13.243:20243","configVersion" : 1}],"ok" : 1}

3、搭建分片集群246-247

在246机器的mongo的根目录下新建start脚本，内容如下

[root@localhost mongodb-32246]# cat start bin/./mongod --dbpath data/ --logpath data/mongo.log --fork --port 32246 --replSet 246  --shardsvr

replSet代表集群，shardsvr代表分片，246代表集群的名字，在246的其他mongo目录下也建立对应的start脚本，记得修改端口，启动脚本。

运行如下命令

config = {... _id:‘246‘,... members:[... {_id:0,host:‘172.16.13.246:30246‘},... {_id:1,host:‘172.16.13.246:31246‘},... {_id:2,host:‘172.16.13.246:32246‘}... ]... }{"_id" : "246","members" : [{"_id" : 0,"host" : "172.16.13.246:30246"},{"_id" : 1,"host" : "172.16.13.246:31246"},{"_id" : 2,"host" : "172.16.13.246:32246"}]}>    rs.initiate(config){ "ok" : 1 }

查看集群状态

这里不在列出，同样的操作在247上执行一次，记得修改集群名字

4、搭建mongos

在241的mongos根目录下建立start脚本

[root@localhost mongodb-3.4.2]# cat start bin/./mongos --logpath data/mongo.log --fork  --configdb config/172.16.13.243:20243,172.16.13.244:20244,172.16.13.245:20245

进入mongos的命令界面，

添加分片

mongos> sh.addShard("246/172.16.13.246:30246,172.16.13.246:31246,172.16.13.246:32246"){ "shardAdded" : "246", "ok" : 1 }mongos> sh.addShard("247/172.16.13.247:30247,172.16.13.247:31247,172.16.13.247:32247"){ "shardAdded" : "247", "ok" : 1 }

在242上也运行上述命令。

设置test.aj表根据_id字段按照hash方式分配数据

mongos> sh.enableSharding("test"){ "ok" : 1 }mongos> sh.shardCollection("test.aj", { _id: ‘hashed‘}){ "collectionsharded" : "test.aj", "ok" : 1 }

5、插入数据

for (var id = 1; id <= 10000; id++) db.aj.save({  "_class" : "java.util.HashMap",  "CAh" : "123",  "CCbrXm" : "wangchy",  "valid" : 0,  "fydm" : "2400",  "CAjmc" : "ptest",  "CCbr" : "ptest",  "WCreateTime" : ISODate("2015-10-13T18:29:06.649Z")});

6、验证结果

246主节点验证数据量

246:PRIMARY> db.aj.count();5082

246子节点验证数据量

246:SECONDARY> use testswitched to db test246:SECONDARY> db.getMongo().setSlaveOk();246:SECONDARY> db.aj.count();5082

247重复上述操作

247:PRIMARY> db.aj.count();4918247:SECONDARY> use test;switched to db test247:SECONDARY> db.getMongo().setSlaveOk();247:SECONDARY> db.aj.count();4918

本文出自 “www.wangerbao.com” 博客，请务必保留此出处http://wangerbao.blog.51cto.com/4363165/1915341

MongoDB高可用部署

标签：mongo 分片集群高可用

小编还为您整理了以下内容，可能对您也有帮助：

【mongoDB】mongoDB的高可用、一致性

高可用是MongoDB最核心的功能之一，相信很多同学也是因为这一特性才想深入了解它的。

那么本节就来说下MongoDB通过哪些方式来实现它的高可用，然后给予这些特性我们可以实现什么程度的高可用。

相信一旦提到高可用，浮现在大家脑海里会有如下几个问题：

那么，带着这些问题，我们继续看下去，看完大家应该会对这些问题有所了解了。

MongoDB高可用的基础是复制集群，复制集群本质来说就是一份数据存多份，保证一台机器挂掉了数据不会丢失。

一个副本集至少有3个节点组成：

从上面的节点类型可以看出，一个三节点的复制集群可能是PSS或者PSA结构。

PSA结构优点是节约成本，但是缺点是Primary挂掉之后，一些依赖 majority（多数）特性的写功能出问题，因此一般不建议使用。

复制集群确保数据一致性的核心设计是：

从上面4点我们可以得出 MongoDB 高可用的如下结论：

MongoDB宕机重启之后可以通过checkpoint快速恢复上一个60s之前的数据。

MongoDB最后一个checkpoint到宕机期间的数据可以通过Journal日志回放恢复。

Journal日志因为是100ms刷盘一次，因此至多会丢失100ms的数据

（这个可以通过WriteConcern的参数控制不丢失，只是性能会受影响，适合可靠性要求非常严格的场景）

如果在写数据开启了多数写，那么就算Primary宕机了也是至多丢失100ms数据（可避免，同上）。

分布式系统必须要面对的一个问题就是数据的一致性和高可用，针对这个问题有一个非常著名的理论就是CAP理论。

CAP理论的核心结论是：一个分布式系统最多只能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）这三项中的两项。

关于CAP理论在网上有非常多的论述，这里也不赘述。

CAP理论提出了分布式系统必须面临的问题，但是我们也不可能因为这个问题就不用分布式系统。

因此，BASE（Basically Available基本可用、Soft state软状态、Eventually consistent最终一致性）理论被提出来了。

BASE理论是在一致性和可用性上的平衡，现在大部分分布式系统都是基于 BASE理论设计的，当然MongoDB也是遵循此理论的。

MongoDB为了保证可用性和分区容错性，采用的是副本集的方式，这种模式就必须要解决的一个问题就是怎样快速在系统启动和Primary发生异常时选取一个合适的主节点。

这里潜在着多个问题：

MongoDB的选举算法是基于Raft协议的改进，Raft协议将分布式集群里面的节点有3种状态：

leader：就是Primary节点，负责整个集群的写操作。

candidate：候选者，在Primary节点挂掉之后，参与竞选的节点。只有选举期间才会存在，是个临时状态。

follower：就是Secondary节点，被动的从Primary节点拉取更新数据。

节点的状态变化是：正常情况下只有一个leader和多个flower，当leader挂掉了，那么flower里面就会有部分节点成为candidate参与竞选。

当某个candidate竞选成功之后就成为新的leader，而其他candidate回到flower状态。

具体状态机如下：

Raft协议中有两个核心RPC协议分别应用在选举阶段和正常阶段：

请求投票：选举阶段，candidate向其他节点发起请求，请求对方给自己投票。

追加条目：正常阶段，leader节点向follower节点发起请求，告诉对方有数据更新，同时作为心跳机制来向所有follower宣示自己的地位。

如果follower在一定时间内没有收到该请求就会启动新一轮的选举投票。

Raft协议规定了在选举阶段的投票规则：

一个节点，在一个选举周期（Term）内只能给一个candidate节点投赞成票，且先到先得。

只有在candidate节点的oplog领先或和自己相同时才投赞成票。

一轮完整的选举过程包含如下内容：

以上就是目前掌握的MongoDB的选举机制，其中有个问题暂时还未得到解答，就是最后一个，怎样确保选出的Primary是最合适的那一个?

因为，从前面的协议来看，存在一个逻辑bug：由于follower转换成candidate是随机并行的，再加上先到先得的投票机制会导致选出一个次优的节点成为Primary。

针对Raft协议的这个问题，下来查询了一些资料，结论是：

Raft协议确实不保证选举出来的Primary节点是最优的。

MongoDB通过在选举成功，到新Primary即位之前，新增了一个 catchup（追赶）操作来解决。

即在节点获取投票胜利之后，会先检查其它节点是否有比自己更新的oplog，如果没有就直接即位，如果有就先把数据同步过来再即位。

MongoDB的主从同步机制是确保数据一致性和可靠性的重要机制。其同步的基础是oplog，类似MySQL的binlog，但是也有一些差异，oplog虽然叫log但并不是一个文件，而是一个集合（Collection）。

同时由于 oplog 的并行写入，存在尾部乱序和空洞现象，具体来说就是oplog里面的数据顺序可能是和实际数据顺序不一致，并且存在时间的不连续问题。

为了解决这个问题，MongoDB采用的是混合逻辑时钟（HLC）来解决的，HLC不止解决乱序和空洞问题，同时也是用来解决分布式系统上事务一致性的方案。

主从同步的本质实际上就是，Primary节点接收客户端请求，将更新操作写到oplog，然后Secondary从同步源拉取oplog并本地回放，实现数据的同步。

同步源是指节点拉取oplog的源节点，这个节点不一定是Primary，链式复制模式下就可能是任何节点。

节点的同步源选取是一个非常复杂的过程，大致上来说是：

在同步源选取时有些特殊情况：

用户可以为节点指定同步源。

如果关闭链式复制，所有Secondary节点的同步源都是Primary节点。

如果从同步源拉取出错了，会被短期加入黑名单。

整个拉取和回放的逻辑非常复杂，这里根据自己的理解简化说明，如果想了解更多知识可以参考《MongoDB复制技术内幕》

节点有一个专门拉取oplog的线程，通过Exhausted cursor从同步源拉取 oplog。拉取下来之后，并不会执行回放执行，而是会将其丢到一个本地

的阻塞队列中。

然后有多个具体的执行线程，从阻塞队列中取出oplog并执行。

在取出过程中，同一个Collection的oplog一定会被同一个线程取出执行，线程会尽可能的合并连续的插入命令。

整个回放的执行过程，大致为先加锁，然后写本店oplog，然后将oplog刷盘（WAL机制），最后更新自己的最新opTime。

MongoDB全方位知识图谱

https://mp.weixin.qq.com/s/bhXPnLotUoQYJI61eORCfA

如何在 AWS EC2 上配置 MongoDB 高可用复制集

安装步骤
　　创建并启动主节点、次节点和仲裁节点的EC2实例，主节点、次节点和仲裁节点所需要的配置如上所述。
　　为主次两节点创建EBS卷，EBS卷的大小足以满足MongoDB存储数据
　　通过SSH连接主次两节点上的EC2实例
　　通过sudo mkfs -t ext4 /dev/<已创建的EBS卷> 在主次两个节点上创建Ext4文件系统
　　创建目录/data/db或者其他你选择的目录名，然后使用sudo mount -a /dev/<已创建的EBS卷> /data/db挂载到已连接的卷上
　　使用sudo echo '/dev/sdf /data/db auto noatime,noexec,nodiratime 0 0' >>/etc/fstab 编辑/etc/fstab，使得实例启动的时候能显示这个目录
　　在所有实例上下载并安装MongoDB
　　在MongoDB目录下使用mongod --rest -rep|set myHASet命令启动主节点（这儿myHASet是复制集的名字，你可以选择你喜欢的任何名字）
　　在MongoDB目录下进入MongoDB终端
　　在mongo终端上使用命令rs.initiate()初始化复制集
　　初始化完成后使用命令rs.status() 检查复制集的状态
　　如果初始化成功，你可以在输出里看到OK，类似下面
　　{
"set" : "sample",
"myState" : 1,
"members" : [
{
"name" : "<PRIMARY_HOSTNAME>:27017",
"self" : true
}
],
"ok" : 1
}
　　你也可以通过http://<主节点>:27017/_rep|set检查复制集状态
　　现在你的主节点可以使用了，你可以在这个节点上插入或者更新文档。
　　现在用主节点上的mongod --rest --rep|set myHASet相同的命令启动次节点
　　现在告知主节点在复制集中增加了次节点。进入主节点上的mongo控制台，使用rs.add("<次节点主机名>")增加次节点到复制集
　　如果增加成功的话，你将看到这样的响应{ "ok" : 1 }
　　一旦你的次节点与复制集连接成功，你可以通过http://<主节点>:27017/_rep|Set检查复制集状态
　　现在使用mongod --rest --rep|Set myset --oplogSize 8命令启动仲裁节点
　　使用命令rs.add({_id:2,host:"<仲裁节点主机名>",arbiterOnly:true})把仲裁节点增加到复制集
　　一旦仲裁节点增加成功的话，你就已经完成的整个配置，你的复制集可以使用了
　　进入http://<主节点>:27017/_rep|Set，你应当能够看到如下屏幕截图所示的每个节点的状态
　　要测试复制集，关闭主节点，看看次节点是否能够接管，然后变成主节点
　　你可以使用命令db.isMaster()检查状态，看看是否次节点已经成为主节点。
　　另外你可以用分片群集的水平分片来扩大应用的数据量。配置分片群集不在这篇文档的范围之内。

如何在 AWS EC2 上配置 MongoDB 高可用复制集

七、rancher搭建Mongodb集群化部署：

一．Mongodb在rancher上面部署：

命令如图：mongod --keyFile /data/key/keyfile --replSet rs --bind_ip localhost,prod

二．Mongodb在服务器上的配置keyfile

这个keyfile怎么生成的我也没试过，官网有一些解释但是没说具体怎么生成如图：

我们需要把这个文件放在：

这些添加好就可以互相添加服务了如图：

其实就是各个容器是不互相影响的，如何让他们在互通就需要互相添加你要用的服务

这个名称如果不配置就用默认的，看你要不要配置

Prod：

Master:

Slave:

三．Mongodb集群测试是否成功：

参考文献： https://www.yii.com/mongodb/mongodb_quick_guide.html

四．Mongodb管理界面mongo-express搭建

成功日志：

五．Mongodb整合对外端口搭建haproxy

mongodb高可用 configserver为什么要3个

要3个configserver的原因是：当主节点宕机后会在从节点中选取一个来作为主节点，选取是采用投票模式，只有当该节点的得票大于集群节点总数的一半的时候才会被选为主节点。假如只有2个configserver节点，当主节点宕机后，从节点选取得票只有1票，不大于节点数的1半，因此从节点不能提升为主节点，整个集群由于没有主节点就不能正常工作。

mongodb高可用 configserver为什么要3个

mongodb的特点

它的特点是高性能、易部署、易使用，存储数据非常方便。主要功能特性有：
*面向集合存储，易存储对象类型的数据。
*模式自由。
*支持动态查询。
*支持完全索引，包含内部对象。
*支持查询。
*支持复制和故障恢复。
*使用高效的二进制数据存储，包括大型对象（如视频等）。
*自动处理碎片，以支持云计算层次的扩展性。
*支持RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
*文件存储格式为BSON（一种JSON的扩展）。
*可通过网络访问。

mongodb的特点

部署vue项目、安装mongodb

一、node运行环境

1、npm install -g n

通过npm 全局安装node

2、 sudo n 8.16.0

设置node版本

Password:

install : node-v8.16.0

mkdir : /usr/local/n/versions/node/8.16.0

fetch : https://nodejs.org/dist/v8.16.0/node-v8.16.0-darwin-x64.tar.gz

######################################################################## 100.0%

installed : v8.16.0

3、node -v

v8.16.0

二、安装mongodb

1、brew tap mongodb/brew

2、brew install mongodb-community

=> Installing mongodb-community from mongodb/brew

==> Downloading https://fastdl.mongodb.org/osx/mongodb-macos-x86_64-4.2.5.tgz

######################################################################## 100.0%

==> Caveats

To have launchd start mongodb/brew/mongodb-community now and restart at login:

brew services start mongodb/brew/mongodb-community

Or, if you don't want/need a background service you can just run:

mongod --config /usr/local/etc/mongod.conf

==> Summary

🍺 /usr/local/Cellar/mongodb-community/4.2.5: 21 files, 305.9MB, built in 7 minutes 4 seconds

(base) mengfaniaodeMBP:homebrew-core mengfanxiao$ cat usr/local/etc/mongod.conf

cat: usr/local/etc/mongod.conf: No such file or directory

(base) mengfaniaodeMBP:homebrew-core mengfanxiao$ brew services start mongodb/brew/mongodb-community

==> Successfully started `mongodb-community` (label: homebrew.mxcl.mongodb-community)

3、启动/停止

brew services start mongodb-community

brew services stop mongodb-community

4、配置

配置文件：/usr/local/etc/mongod.conf

日志目录路径：/usr/local/var/log/mongodb

数据目录路径：/usr/local/var/mongodb

5、端口

三、问题梳理

1、环境问题

node -v

dyld: Library not loaded: /usr/local/opt/icu4c/lib/libicui18n.64.dylib

Referenced from: /usr/local/bin/node

Reason: image not found

Abort trap: 6

说明node相关库已被损坏需要重新安装

卸载node

brew uninstall --ignore-dependencies node icu4c

Uninstalling /usr/local/Cellar/node/13.5.0... (4,663 files, 59.1MB)

node 12.12.0 is still installed.

Run `brew uninstall --force node` to remove all versions.

安装node

brew install node

通过这种方式安装的是最新版本的node 但很容易出现版本不兼容问题所以不推荐这么安装建议安装node8 该版本比较稳定很少出现与其他软件不兼容情况

2、文件创建权限问题

==> Installing dependencies for node: icu4c

==> Installing node dependency: icu4c

==> Downloading https://mirrors.aliyun.com/homebrew/homebrew-bottles/bottles/icu4c-64.2.mojave.bottle.tar.gz

######################################################################## 100.0%

==> Pouring icu4c-64.2.mojave.bottle.tar.gz

Error: Failed to create /usr/local/opt/icu4c

Things that depend on icu4c will probably not build.

Could not symlink .

/usr/local/opt is not writable.

==> Caveats

a、创建文件夹

sudo mkdir /usr/local/opt

b、root用户赋予当前用户操作该文件夹权限

此时该文件夹权限属于root 给mengfanxiao账户赋予权限

chown -R mengfanxiao /usr/local/opt

3、插曲 springboot启动问题

dea启动spring-boot,报java.lang.NoClassDefFoundError: javax/servlet/ServletContext错误

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-tomcat</artifactId>

<scope>provided</scope>

</dependency>

把scope注释掉即可

maven中三种classpath

编译，测试，运行

1.compile：默认范围，编译测试运行都有效

2.provided：在编译和测试时有效

3.runtime：在测试和运行时有效

4.test:只在测试时有效

5.system:在编译和测试时有效，与本机系统关联，可移植性差

4、环境不匹配问题

Node Sass does not yet support your current environment: OS X 64-bit with Unsupported runtime (79)qi

卸载重装（最新版本的node-sass）即可：

npm uninstall node-sass -D

npm install node-sass -D

5、版本冲突问题 node和mongodb版本不兼容

mongodb-core@1.2.31 requires a peer of kerberos@~0.0

node -v v13.12.0

npm -v 6.14.4

gyp ERR! command "/usr/local/Cellar/node/13.12.0/bin/node" "/usr/local/lib/node_moles/npm/node_moles/node-gyp/bin/node-gyp.js" "rebuild" gyp ERR! cwd /Users/mengfanxiao/Documents/project/company/wechain/questionnaire/node_moles/leveldown

gyp ERR! node -v v13.12.0

gyp ERR! node-gyp -v v5.1.0

gyp ERR! not ok

npm WARN mongodb-core@1.2.31 requires a peer of kerberos@~0.0 but none is installed. You must install peer dependencies yourself.

这种情况需要安装node8

brew search node

==> Formulae

libbitcoin-node node node-sass node@12 nodebrew nodenv

llnode node-build node@10 node_exporter ✔ nodeenv

如果有node8

则 brew install node@8

然后brew link --overwrite --force node@8

没有node8

npm install -g n

sudo n 8.16.0

安装了node8版本

npm install

> leveldown@1.7.2 install /Users/mengfanxiao/Documents/project/company/wechain/new/questionnaire/node_moles/level/node_moles/leveldown

> prebuild-install || node-gyp rebuild

added 42 packages from 44 contributors in 20.79s

6、安装mongodb问题

brew install mongodb

Error: No available formula with the name 'mongodb'

MongoDB不再是开源的了，并且已经从Homebrew中移除 #43770

安装MongoDB社区服务器的最新可用生产版本（包括所有命令行工具）。这将安装MongoDB 4.2.x：

$ brew install mongodb-community

安装MongoDB社区服务器和命令行工具的最新4.2.x生产版本：

$ brew install mongodb-community@4.2

安装MongoDB社区服务器和命令行工具的最新4.0.x生产版本：

$ brew install mongodb-community@4.0

安装MongoDB社区服务器和命令行工具的最新3.6.x生产版本：

$ brew install mongodb-community@3.6

仅安装最新的mongoshell以连接到远程MongoDB实例：

$ brew install mongodb-community-shell

【Python基础】mongodb存储文件的优缺点?

MongoDB是一个开源的、基于分布式的、面向文档存储的非关系型数据库。是非关系型数据库当中功能最丰富、最像关系数据库的。MongoDB高性能、易部署、易使用，存储数据非常方便。
MongoDB优点:
1、高性能：弱一致性，访问速度较快
2、文档结构的存储方式，能够更便捷的获取数、存储数据方便，高效存储二进制大对象
3、支持复制集、主备、互为主备、自动分片等特性
4、全索引支持，查询语言功能非常强大

MongoDB缺点：
1、不支持事务，实际开发时得搞清楚哪些功能需要使用数据库提供的事务支持
2、MongoDB占用空间大（需要强大硬盘支持）
3、相对于MySQL那样成熟的维护工具，MongoDB维护工具不够完善、成熟

【Python基础】mongodb存储文件的优缺点?

对比MySQL,什么场景MongoDB更适用

MySQL
关系型数据库。
在不同的引擎上有不同的存储方式。
查询语句是使用传统的sql语句，拥有较为成熟的体系，成熟度很高。
开源数据库的份额在不断增加，mysql的份额页在持续增长。
缺点就是在海量数据处理的时候效率会显著变慢。
Mongodb
非关系型数据库(nosql ),属于文档型数据库。先解释一下文档的数据库，即可以存放xml、json、bson类型系那个的数据。这些数据具备自述性（self-describing），呈现分层的树状数据结构。数据结构由键值(key=>value)对组成。
存储方式：虚拟内存+持久化。
查询语句：是独特的Mongodb的查询方式。
适合场景：事件的记录，内容管理或者博客平台等等。
架构特点：可以通过副本集，以及分片来实现高可用。
数据处理：数据是存储在硬盘上的，只不过需要经常读取的数据会被加载到内存中，将数据存储在物理内存中，从而达到高速读写。
成熟度与广泛度：新兴数据库，成熟度较低，Nosql数据库中最为接近关系型数据库，比较完善的DB之一，适用人群不断在增长。
优势：
快速！在适量级的内存的Mongodb的性能是非常迅速的，它将热数据存储在物理内存中，使得热数据的读写变得十分快，
高扩展！
自身的Failover机制！
json的存储格式！
Mysql和Mongodb应用场景:
1.如果需要将mongodb作为后端db来代替mysql使用，即这里mysql与mongodb 属于平行级别，那么，这样的使用可能有以下几种情况的考量：
(1)mongodb所负责部分以文档形式存储，能够有较好的代码亲和性，json格式的直接写入方便。(如日志之类)
(2)从data models设计阶段就将原子性考虑于其中，无需事务之类的辅助。开发用如nodejs之类的语言来进行开发，对开发比较方便。
(3)mongodb本身的failover机制，无需使用如MHA之类的方式实现。
2.将mongodb作为类似redis ，memcache来做缓存db，为mysql提供服务，或是后端日志收集分析。考虑到mongodb属于nosql型数据库，sql语句与数据结构不如mysql那么亲和，也会有很多时候将mongodb做为辅助mysql而使用的类redis memcache 之类的缓存db来使用。亦或是仅作日志收集分析

对比MySQL,什么场景MongoDB更适用

什么是mongoDB数据库

作为一名程序员，我相信大家都要接触数据库，对于mysql和mongoDB也有相对的认识，对于mysql我们已经很了解了，现在我们就来简单说说mongoDB数据库。
MongoDB是一个基于分布式文件存储的数据库，由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
mongoDB数据库的特点：
高性能、易部署、易使用，存储数据非常方便。主要功能特性有:
*面向集合存储，易存储对象类型的数据。
所谓"面向集合"(Collection-Oriented)，意思是数据被分组存储在数据集中，被称为一个集合(Collection)。每个集合在数据库中都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库(RDBMS)里的表(table)，不同的是它不需要定义任何模式(schema)。Nytro MegaRAID技术中的闪存高速缓存算法，能够快速识别数据库内大数据集中的热数据，提供一致的性能改进。
*模式自由(schema-free)。
采用无模式结构存储，意味着对于存储在mongodb数据库中的文件，我们不需要知道它的任何结构定义。如果需要的话，你完全可以把不同结构的文件存储在同一个数据库里。采用无模式存储数据是集合区别于RDBMS 中的表的一个重要特征。
*支持动态查询。
*支持完全索引，包含内部对象。
可以在任意属性上建立索引，包含内部对象。MongoDB的索引和RDBMS 的索引基本一样，可以在指定属性、内部对象上创建索引以提高查询的速度。除此之外，MongoDB 还提供创建基于地理空间的索引的能力。
*支持查询。
MongoDB 支持丰富的查询操作，MongoDB 几乎支持SQL中的大部分查询。
*支持复制和故障恢复。
MongoDB 支持主从复制机制，可以实现数据备份、故障恢复、读扩展等功能。而基于副本集的复制机制提供了自动故障恢复的功能，确保了集群数据不会丢失。
*使用高效的二进制数据存储，包括大型对象(如视频等)。
使用二进制格式存储，可以保存任何类型的数据对象。
*自动处理碎片，以支持云计算层次的扩展性。
*支持RUBY，PYTHON，JAVA，C++，PHP，C#，Perl，JavaScript等多种语言。
MongoDB 提供了当前所有主流开发语言的数据库驱动包，开发人员使用任何一种主流开发语言都可以轻松编程，实现访问MongoDB 数据库。
*文件存储格式为BSON(一种JSON的扩展)。
BSON 是对二进制格式的JSON 的简称，BSON 支持文档和数组的嵌套。
*可通过网络访问。
可以通过网络远程访问MongoDB 数据库。
*强大的聚合工具
MongoDB 除了提供丰富的查询功能外，还提供强大的聚合工具，如count、group 等，支持使用MapRece 完成复杂的聚合任务。
MongoDB 除了提供丰富的查询功能外，还提供强大的聚合工具，如count、group 等，支持使用MapRece 完成复杂的聚合任务。
MongoDB 主要应用场景有:
（1）网站实时数据处理。它非常适合实时的插入、更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
（2）缓存。由于性能很高，它适合作为信息基础设施的缓存层。在系统重启之后，由它搭建的持久化缓存层可以避免下层的数据源过载。
（3）高伸缩性的场景。非常适合由数十或数百台服务器组成的数据库，它的路线图中已经包含对MapRece引擎的内置支持。
（4）大尺寸、低价值的数据，使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
不适用的场景如下:
（1）要求高度事务性的系统，例如，银行或会计系统。传统的关系型数据库目前还是更适用于需要大量原子性复杂事务的应用程序。
（2）传统的商业智能应用，例如针对特定问题的BI 数据库会产生高度优化的查询方式。对于此类应用，数据仓库可能是更合适的选择。
（3）复杂的跨文档(表)级联查询。

什么是mongoDB数据库

MongoDB是什么,怎么用?看完你就知道了

MongoDB是一款为web应用程序和互联网基础设施设计的数据库管理系统。没错MongoDB就是数据库，是NoSQL类型的数据库。

（1）MongoDB提出的是文档、集合的概念，使用BSON（类JSON）作为其数据模型结构，其结构是面向对象的而不是二维表，存储一个用户在MongoDB中是这样子的。

使用这样的数据模型，使得MongoDB能在生产环境中提供高读写的能力，吞吐量较于mysql等SQL数据库大大增强。

（2）易伸缩，自动故障转移。易伸缩指的是提供了分片能力，能对数据集进行分片，数据的存储压力分摊给多台服务器。自动故障转移是副本集的概念，MongoDB能检测主节点是否存活，当失活时能自动提升从节点为主节点，达到故障转移。

（3）数据模型因为是面向对象的，所以可以表示丰富的、有层级的数据结构，比如博客系统中能把“评论”直接怼到“文章“的文档中，而不必像myqsl一样创建三张表来描述这样的关系。

（1）文档数据类型

SQL类型的数据库是正规化的，可以通过主键或者外键的约束保证数据的完整性与唯一性，所以SQL类型的数据库常用于对数据完整性较高的系统。MongoDB在这一方面是不如SQL类型的数据库，且MongoDB没有固定的Schema，正因为MongoDB少了一些这样的约束条件，可以让数据的存储数据结构更灵活，存储速度更加快。

（2）即时查询能力

MongoDB保留了关系型数据库即时查询的能力，保留了索引（底层是基于B tree）的能力。这一点汲取了关系型数据库的优点，相比于同类型的NoSQL redis 并没有上述的能力。

（3）复制能力

MongoDB自身提供了副本集能将数据分布在多台机器上实现冗余，目的是可以提供自动故障转移、扩展读能力。

（4）速度与持久性

MongoDB的驱动实现一个写入语义 fire and forget ，即通过驱动调用写入时，可以立即得到返回得到成功的结果（即使是报错），这样让写入的速度更加快，当然会有一定的不安全性，完全依赖网络。

MongoDB提供了Journaling日志的概念，实际上像mysql的bin-log日志，当需要插入的时候会先往日志里面写入记录，再完成实际的数据操作，这样如果出现停电，进程突然中断的情况，可以保障数据不会错误，可以通过修复功能读取Journaling日志进行修复。

（5）数据扩展

MongoDB使用分片技术对数据进行扩展，MongoDB能自动分片、自动转移分片里面的数据块，让每一个服务器里面存储的数据都是一样大小。

MongoDB核心服务器主要是通过mongod程序启动的，而且在启动时不需对MongoDB使用的内存进行配置，因为其设计哲学是内存管理最好是交给操作系统，缺少内存配置是MongoDB的设计亮点，另外，还可通过mongos路由服务器使用分片功能。

MongoDB的主要客户端是可以交互的js shell 通过mongo启动，使用js shell能使用js直接与MongoDB进行交流，像使用sql语句查询mysql数据一样使用js语法查询MongoDB的数据，另外还提供了各种语言的驱动包，方便各种语言的接入。

mongomp和mongorestore,备份和恢复数据库的标准工具。输出BSON格式，迁移数据库。

mongoexport和mongoimport，用来导入导出JSON、CSV和TSV数据，数据需要支持多格式时有用。mongoimport还能用与大数据集的初始导入，但是在导入前顺便还要注意一下，为了能充分利用好mongoDB通常需要对数据模型做一些调整。

mongosniff,网络嗅探工具，用来观察发送到数据库的操作。基本就是把网络上传输的BSON转换为易于人们阅读的shell语句。

因此，可以总结得到，MongoDB结合键值存储和关系数据库的最好特性。因为简单，所以数据极快，而且相对容易伸缩还提供复杂查询机制的数据库。MongoDB需要跑在64位的服务器上面，且最好单独部署，因为是数据库，所以也需要对其进行热备、冷备处理。

因为本篇文章不是API手册，所有这里对shell的使用也是基础的介绍什么功能可以用什么语句，主要是为了展示使用MongoDB shell的方便性，如果需要知道具体的MongoDB shell语法可以查阅官方文档。

创建数据库并不是必须的操作，数据库与集合只有在第一次插入文档时才会被创建，与对数据的动态处理方式是一致的。简化并加速开发过程，而且有利于动态分配命名空间。如果担心数据库或集合被意外创建，可以开启严格模式。

以上的命令只是简单实例，假设如果你之前没有学习过任何数据库语法，同时开始学sql查询语法和MongoDB 查询语法，你会发现哪一个更简单呢？如果你使用的是java驱动去操作MongoDB，你会发现任何的查询都像Hibernate提供出来的查询方式一样，只要构建好一个查询条件对象，便能轻松查询（接下来会给出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成没问题，也正因为这样简洁，完善的查询机制，深深的爱上了MongoDB。

使用java驱动链接MongoDB是一件非常简单的事情，简单的引用，简单的做增删改查。在使用完java驱动后我才发现spring 对MongoDB 的封装还不如官方自身提供出来的东西好用，下面简单的展示一下使用。

这里只举例了简单的链接与简单的MongoDB操作，可见其操作的容易性。使用驱动时是基于TCP套接字与MongoDB进行通信的，如果查询结果较多，恰好无法全部放进第一服务器中，将会向服务器发送一个getmore指令获取下一批查询结果。

插入数据到服务器时间，不会等待服务器的响应，驱动会假设写入是成功的，实际是使用客户端生成对象id，但是该行为可以通过配置配置，可以通过安全模式开启，安全模式可以校验服务器端插入的错误。

要清楚了解MongoDB的基本数据单元。在关系型数据库中有带列和行的数据表。而MongoDB数据的基本单元是BSON文档，在键值中有指向不定类型值的键，MongoDB拥有即时查询，但不支持联结操作，简单的键值存储只能根据单个键来获取值，不支持事务，但支持多种原子更新操作。

如读写比是怎样的，需要何种查询，数据是如何更新的，会不会存在什么并发问题，数据结构化的程度是要求高还是低。系统本身的需求决定mysql还是MongoDB。

在关于schema 的设计中要注意一些原则，比如：

数据库是集合的逻辑与物理分组，MongoDB没有提供创建数据库的语法，只有在插入集合时，数据库才开始建立。创建数据库后会在磁盘分配一组数据文件，所有集合、索引和数据库的其他元数据都保存在这些文件中，查阅数据库使用磁盘状态可通过。

集合是结构上或概念上相似得文档的容器，集合的名称可以包含数字、字母或 . 符号，但必须以字母或数字开头，完全。

限定集合名不能超过128个字符，实际上 . 符号在集合中很有用，能提供某种虚拟命名空间，这是一种组织上的原则，和其他集合是一视同仁的。在集合中可以使用。

其次是键值，在MongoDB里面所有的字符串都是UTF-8类型。数字类型包括double、int、long。日期类型都是UTC格式，所以在MongoDB里面看到的时间会比北京时间慢8小时。整个文档大小会*在16m以内，因为这样可以防止创建难看的数据类型，且小文档可以提升性能，批量插入文档理想数字范围是10~200，大小不能超过16MB。

（1）索引能显著减少获取文档的所需工作量，具体的对比可以通过 .explain()方法进行对比

（2）解析查询时MongoDB通过最优计划选择一个索引进行查询，当没有最适合索引时，会先不同的使用各个索引进行查询，最终选出一个最优索引做查询

（3）如果有一个a-b的复合索引，那么仅针对a的索引是冗余的

（4）复合索引里的键的顺序是很重要的

（1）单键索引

（2）复合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段会出现null的值，或是大量文档都不包含被索引的键。

如果数据集很大时，构建索引将会花费很长的时间，且会影响程序性能，可通过

当使用 mongorestore 时会重新构建索引。当曾经执行过大规模的删除时，可使用

对索引进行压缩，重建。

（1）查阅慢查询日志

（2）分析慢查询

注意新版本的MongoDB 的explain方法是需要参数的，不然只显示普通的信息。

本节同样主要简单呈现MongoDB副本集搭建的简易性，与副本集的强壮性，监控容易性

提供主从复制能力，热备能力，故障转移能力

实际上MongoDB对副本集的操作跟mysql主从操作是差不多的，先看一下mysql的主从数据流动过程

而MongoDB主要依赖的日志文件是oplog

写操作先被记录下来，添加到主节点的oplog里。与此同时，所有从结点复制oplog。首先，查看自己oplog里最后一条的时间戳；其次，查询主节点oplog里所有大于此时间戳的条目;最后，把那些条目添加到自己的oplog里并应用到自己的库里。从节点使用长轮询立即应用来自主结点oplog的新条目。

当遇到以下情况，从节点会停止复制

local数据库保存了所有副本集元素据和oplog日志

可以使用以下命令查看复制情况

每个副本集成员每秒钟ping一次其他所有成员，可以通过rs.status()看到节点上次的心跳检测时间戳和健康状况。

这个点没必要过多描述，但是有一个特殊场景，如果从节点和仲裁节点都被杀了，只剩下主节点，他会把自己降级成为从节点。

如果主节点的数据还没有写到从库，那么数据不能算提交，当该主节点变成从节点时，便会触发回滚，那些没写到从库的数据将会被删除，可以通过rollback子目录中的BSON文件恢复回滚的内容。

（1）使用单节点链接

只能链接到主节点，如果链接到从节点的话，会被拒绝写入操作，但是如果没有使用安全模式，因为mongo的fire and forget 特性，会把拒绝写入的异常给吃掉。

（2）使用副本集方式链接

能根据写入的情况自动进行故障转移，但是当副本集进行新的选举时，还是会出现故障，如果不使用安全模式，依旧会出现写不进去，但现实成功的情况。

分片是数据库切分的一个概念实现，这里也是简单总结为什么要使用分片以及分片的原理，操作。

当数据量过大，索引和工作数据集占用的内存就会越来越多，所以需要通过分片负载来解决这个问题

（1）分片组件

（2）分片的核心操作

分片一个集合：分片是根据一个属性的范围进行划分的，MongoDB使用所谓的分片键让每个文档在这些范围里找到自己的位置

块：是位于一个分片中的一段连续的分片键范围，可以理解为若干个块组成分片，分片组成MongoDB的全部数据

（3）拆分与迁移

块的拆分：初始化时只有一个块，达到最大块尺寸64MB或100000个文档就会触发块的拆分。把原来的范围一分为二，这样就有了两个块，每个块都有相同数量的文档。

迁移：当分片中的数据大小不一时会产生迁移的动作，比如分片A的数据比较多，会将分片A里面的一些块转移到分片B里面去。分片集群通过在分片中移动块来实现均衡，是由名为均衡器的软件进程管理的，任务是确保数据在各个分片中保持均匀分布，当集群中拥有块最多的分片与拥有块最少分片的块差大于8时，均衡器就会发起一次均衡处理。

启动两个副本集、三个配置服务器、一个mongos进程

配置分片

（1）分片查询类型

（2）索引

分片集合只允许在_id字段和分片键上添加唯一性索引，其他地方不行，因为这需要在分片间进行通信，实施起来很复杂。

当创建分片时，会根据分片键创建一个索引。

（1）分片键是不可修改的、分片键的选择非常重要

（2）低效的分片键

（3）理想的分片键

（1）部署拓扑

根据不同的数据中心划分

这里写图片描述

（2）最低要求

（3）配置的注意事项

需要估计集群大小，可使用以下命令对现有集合进行分片处理

（4）备份分片集群

备份分片时需要停止均衡器

（1）部署架构

使用64位机器、32位机器会制约mongodb的内存，使其最大值为1.5GB

（2）cpu

mongodb 只有当索引和工作集都可放入内存时，才会遇到CPU瓶颈，CPU在mongodb使用中的作用是用来检索数据，如果看到CPU使用饱和的情况，可以通过查询慢查询日志，排查是不是查询的问题导致的，如果是可以通过添加索引来解决问题

mongodb写入数据时会使用到CPU，但是mongodb写入时间一次只用到一个核，如果有频繁的写入行为，可以通过分片来解决这个问题

（3）内存

大内存是mongodb的保障，如果工作集大小超过内存，将会导致性能下降，因为这将会增加数据加载入内存的动作

（4）硬盘

mongodb默认每60s会与磁盘强制同步一次，称为后台刷新，会产生I/O操作。在重启时mongodb会将磁盘里面的数据加载至内存，高速磁盘将会减少同步的时间

（5）文件系统

使用ext4 和 xfs 文件系统

禁用最后访问时间

（6）文件描述符

linux 默认文件描述符是1024，需要大额度的提升这个额度

（7）时钟

mongodb各个节点服务器之间使用ntp服务器

（1）绑定IP

启动时使用 - -bind_ip 命令

（2）身份验证

启动时使用 - -auth 命令

（3）副本集身份认证

使用keyFile，注意keyFile文件的权限必须是600，不然会启动不起来

（1）拓扑结构

搭建副本集至少需要两个节点，其中仲裁结点不需要有自己的服务器

（2）Journaling日志

写数据时会先写入日志，而此时的数据也不是直接写入硬盘，而是写入内存

但是Journaling日志会消耗内存，所以可以在主库上面关闭，在从库上面启动

可以单独为Journaling日志使用一块固态硬盘

在插入时，可以通过驱动确保Journaling插入后再反馈，但是会非常影响性能。

logpath 选项指定日志存储地址

-vvvvv 选项（v越多，输出越详细）

db.runCommand({logrotare:1}) 开启滚动日志

（1）serverStatus

这里写图片描述

（2）top

（3）db.currentOp()

动态展示mongodb活动数据

占用当前mongodb监听端口往上1000号的端口

（1）mongomp

把数据库内容导出成BSON文件，而mongorestore能读取并还原这些文件

（2）mongorestore

把导出的BSON文件还原到数据库

（3）备份原始数据文件

可以这么做，但是，操作之前需要进行锁库处理 db.runCommand({fsync:1,lock:true})

db.$cmd.sys.unlock.findOne() 请求解锁操作，但是数据库不会立刻解锁，需要使用db.currentOp()验证。

（1）修复

mongd --repair 修复所有数据库

db.runCommand({repairDatabase:1}) 修复单个数据库

修复就是根据Jourling文件读取和重写所有数据文件并重建各个索引

（2）压紧

压紧，会重写数据文件，并重建集合的全部索引，需要停机或者在从库上面运行,如果需要在主库上面运行，需要添加force参数保证加写锁。

（1）监控磁盘状态

（2）为提升性能检查索引和查询

总的来说，扫描尽可能少的文档。

保证没有冗余的索引，冗余的索引会占用磁盘空间、消耗更多的内存，在每次写入时还需做更多工作

（3）添加内存

dataSize 数据大小和 indexSize 索引大小，如果两者的和大于内存，那么将会影响性能。

storageSize超过dataSize 数据大小两倍以上，就会因磁盘碎片而影响性能，需要压缩。

MongoDB是什么,怎么用?看完你就知道了

MongoDB是一款为web应用程序和互联网基础设施设计的数据库管理系统。没错MongoDB就是数据库，是NoSQL类型的数据库。

使用这样的数据模型，使得MongoDB能在生产环境中提供高读写的能力，吞吐量较于mysql等SQL数据库大大增强。

（1）文档数据类型

（2）即时查询能力

（3）复制能力

MongoDB自身提供了副本集能将数据分布在多台机器上实现冗余，目的是可以提供自动故障转移、扩展读能力。

（4）速度与持久性

（5）数据扩展

MongoDB使用分片技术对数据进行扩展，MongoDB能自动分片、自动转移分片里面的数据块，让每一个服务器里面存储的数据都是一样大小。

mongomp和mongorestore,备份和恢复数据库的标准工具。输出BSON格式，迁移数据库。

mongosniff,网络嗅探工具，用来观察发送到数据库的操作。基本就是把网络上传输的BSON转换为易于人们阅读的shell语句。

在关于schema 的设计中要注意一些原则，比如：

集合是结构上或概念上相似得文档的容器，集合的名称可以包含数字、字母或 . 符号，但必须以字母或数字开头，完全。

（1）索引能显著减少获取文档的所需工作量，具体的对比可以通过 .explain()方法进行对比

（2）解析查询时MongoDB通过最优计划选择一个索引进行查询，当没有最适合索引时，会先不同的使用各个索引进行查询，最终选出一个最优索引做查询

（3）如果有一个a-b的复合索引，那么仅针对a的索引是冗余的

（4）复合索引里的键的顺序是很重要的

（1）单键索引

（2）复合索引

（3）唯一性索引

（4）稀疏索引

如索引的字段会出现null的值，或是大量文档都不包含被索引的键。

如果数据集很大时，构建索引将会花费很长的时间，且会影响程序性能，可通过

当使用 mongorestore 时会重新构建索引。当曾经执行过大规模的删除时，可使用

对索引进行压缩，重建。

（1）查阅慢查询日志

（2）分析慢查询

注意新版本的MongoDB 的explain方法是需要参数的，不然只显示普通的信息。

本节同样主要简单呈现MongoDB副本集搭建的简易性，与副本集的强壮性，监控容易性

提供主从复制能力，热备能力，故障转移能力

实际上MongoDB对副本集的操作跟mysql主从操作是差不多的，先看一下mysql的主从数据流动过程

而MongoDB主要依赖的日志文件是oplog

当遇到以下情况，从节点会停止复制

local数据库保存了所有副本集元素据和oplog日志

可以使用以下命令查看复制情况

每个副本集成员每秒钟ping一次其他所有成员，可以通过rs.status()看到节点上次的心跳检测时间戳和健康状况。

这个点没必要过多描述，但是有一个特殊场景，如果从节点和仲裁节点都被杀了，只剩下主节点，他会把自己降级成为从节点。

（1）使用单节点链接

（2）使用副本集方式链接

分片是数据库切分的一个概念实现，这里也是简单总结为什么要使用分片以及分片的原理，操作。

当数据量过大，索引和工作数据集占用的内存就会越来越多，所以需要通过分片负载来解决这个问题

（1）分片组件

（2）分片的核心操作

分片一个集合：分片是根据一个属性的范围进行划分的，MongoDB使用所谓的分片键让每个文档在这些范围里找到自己的位置

块：是位于一个分片中的一段连续的分片键范围，可以理解为若干个块组成分片，分片组成MongoDB的全部数据

（3）拆分与迁移

启动两个副本集、三个配置服务器、一个mongos进程

配置分片

（1）分片查询类型

（2）索引

分片集合只允许在_id字段和分片键上添加唯一性索引，其他地方不行，因为这需要在分片间进行通信，实施起来很复杂。

当创建分片时，会根据分片键创建一个索引。

（1）分片键是不可修改的、分片键的选择非常重要

（2）低效的分片键

（3）理想的分片键

（1）部署拓扑

根据不同的数据中心划分

这里写图片描述

（2）最低要求

（3）配置的注意事项

需要估计集群大小，可使用以下命令对现有集合进行分片处理

（4）备份分片集群

备份分片时需要停止均衡器

（1）部署架构

使用64位机器、32位机器会制约mongodb的内存，使其最大值为1.5GB

（2）cpu

mongodb写入数据时会使用到CPU，但是mongodb写入时间一次只用到一个核，如果有频繁的写入行为，可以通过分片来解决这个问题

（3）内存

大内存是mongodb的保障，如果工作集大小超过内存，将会导致性能下降，因为这将会增加数据加载入内存的动作

（4）硬盘

mongodb默认每60s会与磁盘强制同步一次，称为后台刷新，会产生I/O操作。在重启时mongodb会将磁盘里面的数据加载至内存，高速磁盘将会减少同步的时间

（5）文件系统

使用ext4 和 xfs 文件系统

禁用最后访问时间

（6）文件描述符

linux 默认文件描述符是1024，需要大额度的提升这个额度

（7）时钟

mongodb各个节点服务器之间使用ntp服务器

（1）绑定IP

启动时使用 - -bind_ip 命令

（2）身份验证

启动时使用 - -auth 命令

（3）副本集身份认证

使用keyFile，注意keyFile文件的权限必须是600，不然会启动不起来

（1）拓扑结构

搭建副本集至少需要两个节点，其中仲裁结点不需要有自己的服务器

（2）Journaling日志

写数据时会先写入日志，而此时的数据也不是直接写入硬盘，而是写入内存

但是Journaling日志会消耗内存，所以可以在主库上面关闭，在从库上面启动

可以单独为Journaling日志使用一块固态硬盘

在插入时，可以通过驱动确保Journaling插入后再反馈，但是会非常影响性能。

logpath 选项指定日志存储地址

-vvvvv 选项（v越多，输出越详细）

db.runCommand({logrotare:1}) 开启滚动日志

（1）serverStatus

这里写图片描述

（2）top

（3）db.currentOp()

动态展示mongodb活动数据

占用当前mongodb监听端口往上1000号的端口

（1）mongomp

把数据库内容导出成BSON文件，而mongorestore能读取并还原这些文件

（2）mongorestore

把导出的BSON文件还原到数据库

（3）备份原始数据文件

可以这么做，但是，操作之前需要进行锁库处理 db.runCommand({fsync:1,lock:true})

db.$cmd.sys.unlock.findOne() 请求解锁操作，但是数据库不会立刻解锁，需要使用db.currentOp()验证。

（1）修复

mongd --repair 修复所有数据库

db.runCommand({repairDatabase:1}) 修复单个数据库

修复就是根据Jourling文件读取和重写所有数据文件并重建各个索引

（2）压紧

压紧，会重写数据文件，并重建集合的全部索引，需要停机或者在从库上面运行,如果需要在主库上面运行，需要添加force参数保证加写锁。

（1）监控磁盘状态

（2）为提升性能检查索引和查询

总的来说，扫描尽可能少的文档。

保证没有冗余的索引，冗余的索引会占用磁盘空间、消耗更多的内存，在每次写入时还需做更多工作

（3）添加内存

dataSize 数据大小和 indexSize 索引大小，如果两者的和大于内存，那么将会影响性能。

storageSize超过dataSize 数据大小两倍以上，就会因磁盘碎片而影响性能，需要压缩。

显示全文

全部频道

MongoDB高可用部署