NoSQL 思维导图模板_ProcessOn思维导图、流程图

产品介绍

安装

解压安装并配置环境变量

关闭THD

在vi /etc/rc.local最后添加如下代码 if test -f /sys/kernel/mm/transparent_hugepage/enabled; then echo never > /sys/kernel/mm/transparent_hugepage/enabled fi if test -f /sys/kernel/mm/transparent_hugepage/defrag; then  echo never > /sys/kernel/mm/transparent_hugepage/defrag fi  cat /sys/kernel/mm/transparent_hugepage/enabled always madvise [never]  cat /sys/kernel/mm/transparent_hugepage/defrag always madvise [never] https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/

mv mongo**   /usr/local/mongodb

export PATH=/usr/local/mongodb/bin:$PATH

环境准备

创建所需用户和组

useradd mongod passwd mongod

创建mongodb所需目录结构

mkdir -p /mongodb/conf mkdir -p /mongodb/log mkdir -p /mongodb/data

修改权限

chown -R mongod:mongod /mongodb

切换用户并设置环境变量(上面做过)

su - mongod    vi .bash_profile export PATH=/usr/local/mongodb/bin:$PATH source .bash_profile

启动数据库并初始化数据

启动的时候会初始化数据库、

su - mongod mongod --dbpath=/mongodb/data --logpath=/mongodb/log/mongodb.log --port=27017 --logappend --fork

登录mongodb

mongo

使用配置文件

普通=或yaml

vim /mongodb/conf/mongo.conf logpath=/mongodb/log/mongodb.log dbpath=/mongodb/data port=27017 logappend=true fork=true

--系统日志有关 systemLog: destination: file path: "/mongodb/log/mongodb.log" --日志位置 logAppend: true --日志以追加模式记录 --数据存储有关 storage: journal: enabled: true dbPath: "/mongodb/data" --数据路径的位置 -- 进程控制 processManagement: fork: true --后台守护进程 pidFilePath: <string> --pid文件的位置，一般不用配置，可以去掉这 行，自动生成到data中 --网络配置有关 net: bindIp: <ip> -- 监听地址，如果不配置这行是监听在0.0.0.0 port: <port> -- 端口号,默认不配置端口号，是27017 -- 安全验证有关配置 security: authorization: enabled --是否打开用户名密码验证

例子：vim /mongodb/conf/mongo.conf systemLog:     destination: file     path: "/mongodb/log/mongodb.log"     logAppend: true storage:      journal:            enabled: true     dbPath: "/mongodb/data/" processManagement:       fork: true net:            port: 27017            bindIp: 10.0.0.51,127.0.0.1

关闭Mongodb

关闭mongodb mongod -f /mongodb/conf/mongo.conf --shutdown 使用配置文件启动mongodb mongod -f /mongodb/conf/mongo.conf

用户基本管理

注意事项

用户管理 ***** 注意： 验证库，建立用户时use到的库，在使用用户时，要加上验证库才能登陆。 对于管理员用户,必须在admin下创建. 1. 建用户时,use到的库,就是此用户的验证库 2. 登录时,必须明确指定验证库才能登录 3. 通常,管理员用的验证库是admin,普通用户的验证库一般是所管理的库设置为验证库 4. 如果直接登录到数据库,不进行use,默认的验证库是test,不是我们生产建议的.

基本语法

创建用户

use admin db.createUser( { user: "root", pwd: "123", roles: [ { role: "root", db: "admin" } ] } )

说明

基本语法说明： user:用户名 pwd:密码 roles: role:角色名 db:作用对象 role：root, readWrite,read

用户的验证功能

security: authorization: enabled

登录

mongo -uroot -proot123 admin mongo -uroot -proot123 10.0.51/admin

查看用户

use admin db.system.users.find().pretty()

子主题

CURD

基本命令

help、db.help()、sh.help()、rs.help()、db.version()、db、db.getName()、show dbs、use admin、db.stats()、db.getMongo()

use test、db.createCollection('a')、db.c.insert({username:"mongodb"})、db.c.find()、db.log.renameCollection("log1")

db.dropDatabase()、、db.t1.drop()

insert

db.<集合>.insertOne(<JSON对象>)

db.t1.insert({id:1})

db.t1.insert({id:1,name:"zs"})

db.<集合>.insertMany([<JSON 1>, <JSON 2>, …<JSON n>])

db.fruit.insertMany([ {name: "apple"}, {name: "pear"}, {name: "orange"} ])

for(i=0;i<20;i++){ db.log.insert({"uid":i,"name":"mongodb","age":6,"date":new Date()}); }

find

单条件

db.log.find( { "uid" : 16 } )

多条件

db.log.find( { "uid" : 5, "age" : "6" } )

db.log.find( { $and : [ {"uid" : "5"}, { "age" : "6" }] })

db.log.find( { $or: [{"uid" : 19}, {"uid" : 4}] } )

查询条件对照表

a = 1       {a: 1} a <>1     {a: {$ne: 1}} a > 1       {a: {$gt: 1}} a >= 1    {a: {$gte: 1}} a < 1      {a: {$lt: 1}} a <= 1    {a: {$lte: 1}}

查询逻辑对照表

a = 1 AND b = 1      {a: 1, b: 1}或{$and: [{a: 1}, {b: 1}]} a = 1 OR b = 1         {$or: [{a: 1}, {b: 1}]} a IS NULL                 {a: {$exists: false}} a IN (1, 2, 3)             {a: {$in: [1, 2, 3]}}

子主题

● $lt: 存在并小于 ● $lte: 存在并小于等于 ● $gt: 存在并大于 ● $gte: 存在并大于等于 ● $ne: 不存在或存在但不等于 ● $in: 存在并在指定数组中 ● $nin: 不存在或不在指定数组中 ● $or: 匹配两个或多个条件中的一个 ● $and: 匹配全部条件

使用 find 搜索子文档

db.fruit.insertOne({ name: "apple", from: { country: "China", province: "Guangdong" } })

db.fruit.find( { "from.country" : "China" } )

使用 find 搜索数组

db.fruit.insert([ { "name" : "Apple", color: ["red", "green" ] }, { "name" : "Mango", color: ["yellow", "green"] } ])

查看单个条件： db.fruit.find({color: "red"})

查询多个条件： db.fruit.find({$or: [{color: "red"}, {color: "yellow"}]} )

使用 find 搜索数组中的对象

db.movies.insertOne( { "title" : "Raiders of the Lost Ark", "filming_locations" : [ { "city" : "Los Angeles", "state" : "CA", "country" : "USA" }, { "city" : "Rome", "state" : "Lazio", "country" : "Italy" }, { "city" : "Florence", "state" : "SC", "country" : "USA" } ] })

// 查找城市是 Rome 的记录 db.movies.find({"filming_locations.city": "Rome"})

使用 find 搜索数组中的对象

db.getCollection('movies').find({ "filming_locations.city": "Rome", "filming_locations.country": "USA" })

db.movies.insertOne( { "title" : "11111", "filming_locations" : [ { "city" : "bj", "state" : "CA", "country" : "CHN" }, { "city" : "Rome", "state" : "Lazio", "country" : "Italy" }, { "city" : "tlp", "state" : "SC", "country" : "USA" } ] })

db.getCollection('movies').find({ "filming_locations": { $elemMatch:{"city":"bj", "country": "CHN"} } })

在数组中搜索子对象的多个字段时，如果使用 $elemMatch，它表示必须是同一个子对象满足多个条件。

控制 find 返回的字段

find 可以指定只返回指定的字段； ● _id字段必须明确指明不返回，否则默认返回； ● 在 MongoDB 中我们称这为投影（projection）； ● db.movies.find({},{"_id":0, title:1})

使用 remove 删除文档

remove 命令需要配合查询条件使用； ● 匹配查询条件的的文档会被删除； ● 指定一个空文档条件会删除所有文档； ● 以下示例： db.testcol.remove( { a : 1 } ) // 删除a 等于1的记录 db.testcol.remove( { a : { $lt : 5 } } ) // 删除a 小于5的记录 db.testcol.remove( { } ) // 删除所有记录 db.testcol.remove() //报错

使用 update 更新文档

Update 操作执行格式：db.<集合>.update(<查询条件>, <更新字段>) ● 以以下数据为例： db.fruit.insertMany([ {name: "apple"}, {name: "pear"}, {name: "orange"} ]) db.fruit.updateOne({name: "apple"}, {$set: {from: "China"}})

使用 update 更新文档

● 使用 updateOne 表示无论条件匹配多少条记录，始终只更新第一条； ● 使用 updateMany 表示条件匹配多少条就更新多少条； ● updateOne/updateMany 方法要求更新条件部分必须具有以下之一，否则将报错： • $set/$unset • $push/$pushAll/$pop • $pull/$pullAll • $addToSet ● // 报错 db.fruit.updateOne({name: "apple"}, {from: "China"})

使用 update 更新数组

● $push: 增加一个对象到数组底部 ● $pushAll: 增加多个对象到数组底部 ● $pop: 从数组底部删除一个对象 ● $pull: 如果匹配指定的值，从数组中删除相应的对象 ● $pullAll: 如果匹配任意的值，从数据中删除相应的对象 ● $addToSet: 如果不存在则增加一个值到数组

使用 drop 删除集合

● 使用 db.<集合>.drop() 来删除一个集合 ● 集合中的全部文档都会被删除 ● 集合相关的索引也会被删除 db.colToBeDropped.drop()

使用 dropDatabase 删除数据库

● 使用 db.dropDatabase() 来删除数据库 ● 数据库相应文件也会被删除，磁盘空间将被释放 use tempDB db.dropDatabase() show collections // No collections show dbs // The db is gone

通过python操作mongodb

安装 Python MongoDB 驱动程序

在 Python 中使用 MongoDB 之前必须先安装用于访问数据库的驱动程序： wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo yum install -y python3 pip3 install pymongo 在 python 交互模式下导入 pymongo，检查驱动是否已正确安装： import pymongo pymongo.version

创建连接

确定 MongoDB 连接串 使用驱动连接到 MongoDB 集群只需要指定 MongoDB 连接字符串即可。其基本格式可 以参考文档: Connection String URI Format 最简单的形式是 mongodb://数据库服务器主机地址：端口号 如：mongodb://127.0.0.1:27017 ● 初始化数据库连接 from pymongo import MongoClient uri = "mongodb://root:root123@10.0.0.51:27017" client = MongoClient(uri) client

数据库操作：插入数据

初始化数据库和集合 db = client["eshop"] user_coll = db["users"] 插入一条新的用户数据 new_user = {"username": "nina", "password": "xxxx", "email": "123456@qq.com "} result = user_coll.insert_one(new_user) result

MongoDB RS(Replica Set)复制集

1 复制集的作用

MongoDB 复制集的主要意义在于实现服务高可用,它的现实依赖于两个方面的功能： • 数据写入时将数据迅速复制到另一个独立节点上 • 在接受写入的节点发生故障时自动选举出一个新的替代节点 在实现高可用的同时，复制集实现了其他几个附加作用： • 数据分发：将数据从一个区域复制到另一个区域，减少另一个区域的读延迟 • 读写分离：不同类型的压力分别在不同的节点上执行 • 异地容灾：在数据中心故障时候快速切换到异地

典型复制集结构

PSS、PSA、一个典型的复制集由3个以上具有投票权的节点组成，包括： • 一个主节点（PRIMARY）：接受写入操作和选举时投票 • 两个（或多个）从节点（SECONDARY）：复制主节点上的新数据和选举时投票 • Arbiter（投票节点）

数据是如何复制的

当一个修改操作，无论是插入、更新或删除，到达主节点时，它对数据的操作将被记录下来（经过一些必 要的转换），这些记录称为 oplog。 从节点通过在主节点上打开一个 tailable 游标不断获取新进入主节点的 oplog，并在自己的数据上 回放，以此保持跟主节点的数据一致。

通过选举完成故障恢复

具有投票权的节点之间两两互相发送心跳； ● 当5次心跳未收到时判断为节点失联； ● 如果失联的是主节点，从节点会发起选举，选出新的主节点； ● 如果失联的是从节点则不会产生新的选举； ● 选举基于 RAFT 一致性算法实现，选举成功的必要条件是大多数投票节点存活；

影响选举的因素

整个集群必须有大多数节点存活；被选举为主节点的节点必须： • 能够与多数节点建立连接 • 具有较新的 oplog • 具有较高的优先级（如果有配置）

常见选项

复制集节点有以下常见的选配项： • 是否具有投票权（v 参数）：有则参与投票； • 优先级（priority 参数）：优先级越高的节点越优先成为主节点。优先级为0的节点无法成为主节 点； • 隐藏（hidden 参数）：复制数据，但对应用不可见。隐藏节点可以具有投票仅，但优先级必须为0； • 延迟（slaveDelay 参数）：复制 n 秒之前的数据，保持与主节点的时间差。

复制集注意事项

● 关于硬件： • 因为正常的复制集节点都有可能成为主节点，它们的地位是一样的，因此硬件配置上必须一致； • 为了保证节点不会同时宕机，各节点使用的硬件必须具有独立性。 ● 关于软件： • 复制集各节点软件版本必须一致，以避免出现不可预知的问题。 ● 增加节点不会增加系统写性能！

Replcation Set配置过程详解

创建目录和配日志文件

mkdir -p /mongodb/28017/conf /mongodb/28017/data /mongodb/28017/log mkdir -p /mongodb/28018/conf /mongodb/28018/data /mongodb/28018/log mkdir -p /mongodb/28019/conf /mongodb/28019/data /mongodb/28019/log mkdir -p /mongodb/28020/conf /mongodb/28020/data /mongodb/28020/log

cat > /mongodb/28017/conf/mongod.conf <<EOF systemLog:   destination: file     path: /mongodb/28017/log/mongodb.log     logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/28017/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 1      75%以下       directoryForIndexes: true   collectionConfig:     blockCompressor: zlib   indexConfig:     prefixCompression: true processManagement:   fork: true net:   port: 28017   bindIp: 10.0.0.51,127.0.0.1 replication:   oplogSizeMB: 2048      oplog表的日志大小，只有一张   replSetName: my_repl       复制集的名

配置文件

\cp /mongodb/28017/conf/mongod.conf /mongodb/28018/conf/ \cp /mongodb/28017/conf/mongod.conf /mongodb/28019/conf/ \cp /mongodb/28017/conf/mongod.conf /mongodb/28020/conf/ sed 's#28017#28018#g' /mongodb/28018/conf/mongod.conf -i sed 's#28017#28019#g' /mongodb/28019/conf/mongod.conf -i sed 's#28017#28020#g' /mongodb/28020/conf/mongod.conf -i

启动

mongod -f /mongodb/28017/conf/mongod.conf mongod -f /mongodb/28018/conf/mongod.conf mongod -f /mongodb/28019/conf/mongod.conf mongod -f /mongodb/28020/conf/mongod.conf

配置复制集

（1）1主2从，从库普通从库(PSS) config = {_id: 'my_repl', members: [ {_id: 0, host: '10.0.0.51:28017'}, {_id: 1, host: '10.0.0.51:28018'}, {_id: 2, host: '10.0.0.51:28019'}] } rs.initiate(config)

（2）1主1从1个arbiter(PSA)  config = {_id: 'my_repl', members: [  {_id: 0, host: '10.0.0.51:28017'}, {_id: 1, host: '10.0.0.51:28018'},  {_id: 2, host: '10.0.0.51:28019',"arbiterOnly":true}]  }  rs.initiate(config)

复制集测试：

my_repl:PRIMARY> db.movies.insert([ { "title" : "Jaws", "year" : 1975, "imdb_rating" : 8.1 }, ... { "title" : "Batman", "year" : 1989, "imdb_rating" : 7.6 }, ... ] ); BulkWriteResult({ "writeErrors" : [ ], "writeConcernErrors" : [ ], "nInserted" : 2, "nUpserted" : 0, "nMatched" : 0, "nModified" : 0, "nRemoved" : 0, "upserted" : [ ] })

my_repl:SECONDARY> db.movies.find().pretty(); 注：在mongodb复制集当中，默认从库不允许读写。 rs.slaveOk();    打开从库的读功能 db.movies.find().pretty();

复制集管理操作

（1）查看复制集状态： arbiteronly hidden priority slaveDelay votes rs.status(); //查看整体复制集状态   rs.isMaster(); // 查看当前是否是主节点  （2）添加删除节点在线去添加节点，删除节点 rs.add("10.0.0.1:28020"); // 新增从节点  rs.addArb("10.0.0.1:28020"); // 新增仲裁节点  rs.remove("10.0.0.1:28020"); // 删除一个节点  （3）特殊从节点的配置  • 优先级（priority 参数：0-1000）：    优先级越高的节点越优先成为主节点。    优先级为0的节点无法成为主节点；  • 隐藏（hidden 参数）：复制数据，但对应用不可见。隐藏节点可以具有投票仅，但优先级必须为 0；  • 延迟（slaveDelay 参数）：复制 n 秒之前的数据，保持与主节点的时间差。  配置延时节点（一般延时节点也配置成hidden）【1】这个是顺序列的号从0开始数 cfg=rs.conf()  cfg.members[1].priority=0  cfg.members[1].slaveDelay=120  cfg.members[1].hidden=true   cfg.members[2].votes=0 rs.reconfig(cfg)    重新加载下配置 改回来：  cfg=rs.conf()  cfg.members[2].priority=1  cfg.members[2].slaveDelay=0  cfg.members[2].hidden=0  cfg.members[2].votes=0  rs.reconfig(cfg)  配置成功后，通过以下命令查询配置后的属性  rs.conf();

副本集其他操作命令

--查看副本集的配置信息  admin> rs.config()  --查看副本集各成员的状态  admin> rs.status()  --副本集角色切换（不要人为顺便操作，有风险）主节点切换 admin> rs.stepDown()  注： admin> rs.freeze(300) //锁定从，使其不会转变成主库  freeze()和stepDown单位都是秒。  --设置副本节点可读：在副本节点执行  admin> rs.slaveOk()  eg：  admin> use app  switched to db app app> db.createCollection('a')  { "ok" : 0, "errmsg" : "not master", "code" : 10107 }  --查看副本节点  admin> rs.printSlaveReplicationInfo()   可以看到延时的时间

MongoDB高级运维

常见架构

单机 20%

高可用复制集 70%

分片集群横向扩展 10%

MongoDB高级分片不是针对逻辑层拆分，再底层的存储层拆分。最多支持1024个分片

分片集群机制及原理

为什么使用分片集群

• 数据容量日益增大，访问性能日渐降低，怎么破？ • 新品上线异常火爆，如何支撑更多的并发用户？ • 单库已有 10TB 数据，恢复需要1-2天，如何加速？ • 地理分布数据

如何解决以上问题

•银行交易单表内10亿笔资料 •超负荷运转

分片架构介绍Mongodb sharding cluster【MSC】

• Mongos 路由节点 提供集群单一入口 转发应用端请求 选择合适数据节点进行读写 合并多个数据节点的返回 无状态 建议至少2个 • Config Servers配置节点 提供集群元数据存储 分片数据分布的映射 • Shards 数据节点 以复制集为单位 横向扩展 最大1024分片 分片之间数据不重复 所有分片在一起才可完整工作

MongoDB 分片集群特点

• 应用全透明，无特殊处理 • 数据自动均衡 • 动态扩容，无须下线 • 提供三种分片方式

分片集群数据分布方式

• 基于范围  chunk 每个单元 优点 范围查询性能好 优化读 缺点 往一个分片生成好多chunk 单元写，空闲时触发blance再往其他分片挪数据。数据分布不均匀 容易有写热点 • 基于 Hash  crc32 优点 数据分布均匀 有利于写的优化 存储打的很散 适用于日志，物联网高并发写入场景 缺点 范围查效率低 适合于点查  • 基于 zone / tag 优点 基于DNS 路由到mongodb上 选择最近的服务器

分片集群搭建及扩容

分片规划

10个实例：38017-38026  (1)configserver: 集群的源数据  节点信息 拓扑  数据分布 分片策略 怎样分的 那个分片上的chunk有哪些数据 3台构成的复制集（1主两从，不支持arbiter）38018-38020  (2)shard节点： PSS sh1：38021-23 （1主两从，其中一个节点为arbiter，复制集名字sh1） sh2：38024-26 （1主两从，其中一个节点为arbiter，复制集名字sh2） (3)mongos 38017

从下往上搭建先做shard config 再mongodbs

shard复制集配置

sharding分片配置高点，尤其内存高点  最好64c256g

创建目录

======================================完成shard节点配置===================================

mkdir -p /mongodb/38021/conf /mongodb/38021/log /mongodb/38021/data mkdir -p /mongodb/38022/conf /mongodb/38022/log /mongodb/38022/data mkdir -p /mongodb/38023/conf /mongodb/38023/log /mongodb/38023/data mkdir -p /mongodb/38024/conf /mongodb/38024/log /mongodb/38024/data mkdir -p /mongodb/38025/conf /mongodb/38025/log /mongodb/38025/data mkdir -p /mongodb/38026/conf /mongodb/38026/log /mongodb/38026/data

配置文件

vi /mongodb/38021/conf/mongodb.conf =============== 根据需求修改相应参数：几个分片几个主节点配置文件 2个分片 6个节点 systemLog:   destination: file   path: /mongodb/38021/log/mongodb.log         *日志目录不一样   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/38021/data                           *数据目录不一样   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 1       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true net:   bindIp: 10.0.0.51,127.0.0.1   port: 38021                                                             *端口不一样 replication:                    复制集参数   oplogSizeMB: 2048   replSetName: sh1                                                  *复制集不一样 sharding:                         打开sharding   clusterRole: shardsvr processManagement:   fork: true

从节点的配置文件

cp /mongodb/38024/conf/mongodb.conf /mongodb/38025/conf/  cp /mongodb/38024/conf/mongodb.conf /mongodb/38026/conf/  sed 's#38024#38025#g' /mongodb/38025/conf/mongodb.conf -i  sed 's#38024#38026#g' /mongodb/38026/conf/mongodb.conf -i

所有节点，并搭建复制集

mongod -f /mongodb/38021/conf/mongodb.conf mongod -f /mongodb/38022/conf/mongodb.conf mongod -f /mongodb/38023/conf/mongodb.conf mongod -f /mongodb/38024/conf/mongodb.conf mongod -f /mongodb/38025/conf/mongodb.conf mongod -f /mongodb/38026/conf/mongodb.conf

连接每个分片组的第一个节点A 【生产中建议PSS】

第一个分片集的第一个节点【这里是PSA的】

mongo --port 38021 use admin config = {_id: 'sh1', members: [ {_id: 0, host: '10.0.0.51:38021'}, {_id: 1, host: '10.0.0.51:38022'}, {_id: 2, host: '10.0.0.51:38023',"arbiterOnly":true}]      *PSA } rs.initiate(config)

第二个分片集的第一个节点【这里是PSA的】

mongo --port 38024 use admin config = {_id: 'sh2', members: [ {_id: 0, host: '10.0.0.51:38024'}, {_id: 1, host: '10.0.0.51:38025'}, {_id: 2, host: '10.0.0.51:38026',"arbiterOnly":true}]              *PSA } rs.initiate(config)

======================================以上完成shard节点配置===================================

config节点配置

======================================完成config节点配置===================================

configserver 并不用高配，标准的8c16g就行

目录创建

mkdir -p /mongodb/38018/conf /mongodb/38018/log /mongodb/38018/data mkdir -p /mongodb/38019/conf /mongodb/38019/log /mongodb/38019/data mkdir -p /mongodb/38020/conf /mongodb/38020/log /mongodb/38020/data

修改配置文件

[mongod@server1 ~]$ vi /mongodb/38018/conf/mongodb.conf systemLog:   destination: file   path: /mongodb/38018/log/mongodb.conf   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/38018/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 1       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true net:   bindIp: 10.0.0.51,127.0.0.1   port: 38018 replication:              复制集参数   oplogSizeMB: 2048   replSetName: configReplSet                               *复制集的名字 sharding:                   打开configserver   clusterRole: configsvr processManagement:   fork: true

配置另外俩个config配置文件

cp /mongodb/38018/conf/mongodb.conf /mongodb/38019/conf/ cp /mongodb/38018/conf/mongodb.conf /mongodb/38020/conf/ sed 's#38018#38019#g' /mongodb/38019/conf/mongodb.conf -i sed 's#38018#38020#g' /mongodb/38020/conf/mongodb.conf -i

启动节点

mongod -f /mongodb/38018/conf/mongodb.conf mongod -f /mongodb/38019/conf/mongodb.conf mongod -f /mongodb/38020/conf/mongodb.conf

配置config复制集

mongo --port 38018  use admin  config = {_id: 'configReplSet', members: [  {_id: 0, host: '10.0.0.51:38018'},  {_id: 1, host: '10.0.0.51:38019'},  {_id: 2, host: '10.0.0.51:38020'}]  } rs.initiate(config)

注：configserver 可以是一个节点，官方建议复制集。configserver不能有arbiter。 新版本中，要求必须是复制集。 注：mongodb 3.4之后，虽然要求config server为replica set，但是不支持arbiter

======================================以上完成configserver节点配置==================================

mongos配置

======================================以上完成mongos节点配置==================================

创建目录

mkdir -p /mongodb/38017/conf /mongodb/38017/log

配置文件

vi /mongodb/38017/conf/mongos.conf systemLog:   destination: file   path: /mongodb/38017/log/mongos.log   logAppend: true net:   bindIp: 10.0.0.51,127.0.0.1   port: 38017 sharding:   configDB: configReplSet/10.0.0.51:38018,10.0.0.51:38019,10.0.0.51:38020    * 指定configserver的复制集地址和名 processManagement:   fork: true

======================================以上完成mongos节点配置==================================

启动mongos

mongos -f /mongodb/38017/conf/mongos.conf

=================mongos和configserver通了=但=configserver没和分片连通，不认识分片============================

分片集群操作

连接到其中一个mongos（10.0.0.51），做以下配置 （1）连接到mongs的admin数据库 # su - mongod $ mongo 10.0.0.51:38017/admin （2）添加分片 db.runCommand( { addshard : "sh1/10.0.0.51:38021,10.0.0.51:38022,10.0.0.51:38023",name:"shard1"} ) db.runCommand( { addshard : "sh2/10.0.0.51:38024,10.0.0.51:38025,10.0.0.51:38026",name:"shard2"} ) （3）列出分片 mongos> db.runCommand( { listshards : 1 } ) （4）整体状态查看 mongos> sh.status();

==============================定制分片==(Range、Hash、Zone)======================================

chunk介绍写数据时会生成64M的chunk，每个chunk都会有min、max的值，是一个全局有序的key-value map，满了会触发split(分裂)，分裂成2个chunk，每个一般数据，不断做分裂。业务不忙了，发现数据不均匀，会触发balancer，不繁忙的情况下会按个数或容量均衡到其他分片。

hash会提前预算，预生成每个分片上的chunk，数据会均匀分布到各个分片。俩个节点同时插入数据

zone ,会提前预分配chunk单元，根据location来决定去哪个分片。4.0以后才有

==============================定制分片==(Range、Hash、Zone)======================================

使用分片集群

##RANGE分片配置及测试  test库下的vast大表进行手工分片登录到 1、激活数据库分片功能 mongo --port 38017 admin admin> ( { enablesharding : "数据库名称" } )  eg： admin> db.runCommand( { enablesharding : "test" } )  2、指定分片建对集合分片  登录到mongos eg：范围片键  --创建索引  use test  > db.vast.ensureIndex( { id: 1 } )  --开启分片  > use admin  > db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )   3、集合分片验证  > admin> use test  > test> for(i=1;i<500000;i++){ db.vast.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); }  > test> db.vast.stats()  4、分片结果测试  > shard1:  > mongo --port 38021  > db.vast.count();  > shard2:  > mongo --port 38024  > db.vast.count();

Hash分片例子

对test库下的vast大表进行hash 创建哈希索引 （1）对于test开启分片功能 mongo --port 38017 admin use admin admin> db.runCommand( { enablesharding : "test" } ) （2）对于test库下的vast表建立hash索引 use test test> db.vast.ensureIndex( { id: "hashed" } ) （3）开启分片 use admin admin > sh.shardCollection( "test.vast", { id: "hashed" } ) （4）录入10w行数据测试 use test for(i=1;i<100000;i++){ db.vast.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); } （5）hash分片结果测试 mongo --port 38021 use test db.vast.count(); mongo --port 38024 use test db.vast.count(); --------------------------- g. 分片的管理 1、判断是否Shard集群 admin> db.runCommand({ isdbgrid : 1}) 2、列出所有分片信息 admin> db.runCommand({ listshards : 1}) 3、列出开启分片的数据库 admin> use config config> db.databases.find( { "partitioned": true } ) 或者： config> db.databases.find() //列出所有数据库分片情况 4、查看分片的片键 config> db.collections.find().pretty() { "_id" : "test.vast", "lastmodEpoch" : ObjectId("58a599f19c898bbfb818b63c"), "lastmod" : ISODate("1970-02-19T17:02:47.296Z"), "dropped" : false, "key" : { "id" : 1 }, "unique" : false } 5、查看分片的详细信息 admin> db.printShardingStatus() 或 admin> sh.status()

删除分片

6、删除分片节点（谨慎）自动会均衡数据  动态扩容 （1）确认blance是否在工作 sh.getBalancerState() （2）删除shard2节点(谨慎) mongos> db.runCommand( { removeShard: "shard2" } ) 注意：删除操作一定会立即触发blancer。

balancer操作

7、balancer操作 介绍： mongos的一个重要功能，自动巡查所有shard节点上的chunk的情况，自动做chunk迁移。 什么时候工作？ 1、自动运行，会检测系统不繁忙的时候做迁移 2、在做节点删除的时候，立即开始迁移工作 3、balancer只能在预设定的时间窗口内运行 有需要时可以关闭和开启blancer（备份的时候） mongos> sh.stopBalancer() mongos> sh.startBalancer() 8、自定义 自动平衡进行的时间段  【生产中一定要设置】 https://docs.mongodb.com/manual/tutorial/manage-sharded-clusterbalancer/#schedule-the-balancing-window // connect to mongos           mongo  --port  38017               use config sh.setBalancerState( true ) db.settings.update({ _id : "balancer" }, { $set : { activeWindow : { start : "3:00", stop : "5:00" } } }, true ) sh.getBalancerWindow() sh.status()

分片集群设计

分片的基本标准

• 关于数据：数据量不超过3TB，尽可能保持在2TB一个片； • 关于索引：常用索引必须容纳进内存； • 按照以上标准初步确定分片后，还需要考虑业务压力，随着压力增大，CPU、RAM、磁盘中的任何一项出现瓶颈时，都可以通过添加更多分片来解决。

如何粗略判断需要多少分片

条件                                                                          分片个数 B : 工作集大小 / 单服务器内存容量                           400GB / （256G * 0.6） = 3 A : 所需存储总量 / 单服务器可挂载容量                                    8TB / 2TB = 4 C : 并发量总数 / （单服务器并发量 * 0.7）                       30000 / (9000*0.7) = 6 D: 额外开销                                                                                             ？

分片数量 = max(A, B, C)+D =?

额外的考量

考虑分片的分布： • 是否需要跨机房分布分片？ • 是否需要容灾？ • 高可用的要求如何?

片键类似于索引

1

影响片键效率的主要因素： • 取值基数（Cardinality）； • 取值分布； • 分散写，集中读； • 被尽可能多的业务场景用到； • 避免单调递增或递减的片键；

选择基数大的片键

对于小基数的片键： • 因为备选值有限，那么块的总数量就有限； • 随着数据增多，块的大小会越来越大； • 水平扩展时移动块会非常困难； 例如：存储一个高中的师生数据，以年龄（假设年龄范围为15~65岁）作为片键， 15<=年龄<=65，且只为整数,所以最多只会有51个 chunk 结论：取值基数要大！

选择分布均匀的片键

对于分布不均匀的片键： • 造成某些块的数据量急剧增大 • 这些块压力随之增大 • 数据均衡以 chunk 为单位，所以系统无能为力 • 例如：存储一个学校的师生数据，以年龄（假设年 龄范围为15~65岁）作为片键， 那么： • 15<=年龄<=65，且只为整数 • 大部分人的年龄范围为15~18岁（学生） • 15、16、17、18四个 chunk 的数据量、访问压力远大 于其他 chunk 结论：取值分布应尽可能均匀

jumpbo chunk更改

jumpbo chunk  自动拆不了需要手工去拆 1).首先关闭Balancer mongos>sh.stopBalancer() 2).查询特大块 mongos>use config mongos>db.chunks.find({jumbo:true}) 3).拆分特大块 mongos>sh.splitAt("db.collection", {shardkey:"拆分的临界值"}) 4).手动挪动块(可选步骤) mongos>sh.moveChunk("db.collection", {shardkey:"shardkey所在的块"}, "需要移动的目标 分片ID"); 5).重启Balancer mongos>sh.startBalancer()

通过一个例子来看片键选择

{ _id: ObjectId(), user: 123, time: Date(), subject: “...”, recipients: [], body: “...”, attachments: [] }

如何规划硬件

• mongos 与 config 通常消耗很少的资源，可以选择低规格虚拟机； • 资源的重点在于 shard 服务器： • 需要足以容纳热数据索引的内存； • 正确创建索引后 CPU 通常不会成为瓶颈，除非涉及非常多的计算； • 磁盘尽量选用 SSD； 实际测试是最好的检验，来看你的资源配置是否完备。 另外，即使项目初期已经具备了足够的资源，仍然需要考虑在合适的时候扩展。建议监控 各项资源使用情况，无论哪一项达到60%以上，则开始考虑扩展。 • 扩展需要新的资源，申请新资源需要时间； • 扩展后数据需要均衡，均衡需要时间。应保证新数据入库速度慢于均衡速度 • 均衡需要资源，如果资源即将或已经耗尽，均衡也是会很低效的。

高级集群设计：两地三中心

准备物理机及数据库实例

规划

# 10.0.0.51 primary:10.0.0.51:10001 s1 :10.0.0.51:10002 #    10.0.0.52:10001 s2 :10.0.0.52:10003  :    10.0.0.52:10004 s3 :10.0.53:10005

01地准备实例

创建目录

su - mongod mkdir -p /mongodb/10001/conf /mongodb/10001/data /mongodb/10001/log mkdir -p /mongodb/10002/conf /mongodb/10002/data /mongodb/10002/log

创建配置文件

cat > /mongodb/10001/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/10001/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/10001/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 0.5       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true processManagement:   fork: true net:   port: 10001   bindIp: 10.0.0.51,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: my_repl EOF

01地俩台的配置文件

\cp /mongodb/10001/conf/mongod.conf /mongodb/10002/conf/ sed 's#10001#10002#g' /mongodb/10002/conf/mongod.conf -i mongod -f /mongodb/10001/conf/mongod.conf mongod -f /mongodb/10002/conf/mongod.conf

02地俩台配置文件

创建目录

su - mongod mkdir -p /mongodb/10003/conf /mongodb/10003/data /mongodb/10003/log mkdir -p /mongodb/10004/conf /mongodb/10004/data /mongodb/10004/log

创建配置文件

cat > /mongodb/10003/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/10003/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/10003/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 0.5       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true processManagement:   fork: true net:   port: 10003   bindIp: 10.0.0.52,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: my_repl EOF

02地俩台配置文件

\cp /mongodb/10003/conf/mongod.conf /mongodb/10004/conf/ sed 's#10003#10004#g' /mongodb/10004/conf/mongod.conf -i mongod -f /mongodb/10003/conf/mongod.conf mongod -f /mongodb/10004/conf/mongod.conf

03地一台配置文件

创建目录

su - mongod mkdir -p /mongodb/10005/conf /mongodb/10005/data /mongodb/10005/log

配置文件

cat > /mongodb/10005/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/10005/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/10005/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 0.5       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true processManagement:   fork: true net:   port: 10005   bindIp: 10.0.53,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: my_repl EOF

03地配置文件

mongod -f /mongodb/10005/conf/mongod.conf

连接主节点加载其他节点

mongo --port10001 use aadmin config = {_id: 'my_repl', members: [ {_id: 0, host: '10.0.0.51:10001'}, {_id: 1, host: '10.0.0.51:10002'}, {_id: 2, host: '10.0.0.52:10003'}, {_id: 3, host: '10.0.0.52:10004'}, {_id: 4, host: '10.0.53:10005'} ] }                rs.initiate(config)

查看当前几个主几个从，配置的是1主4从

*显示为primary    rs.status()      有id为01234 5个节点信息

优先级配置，以后切换主库能切换到想要的主库机器上

cfg = rs.conf() cfg.members[1].priority = 20    主库的本地另一个机器上，优先级最高 cfg.members[2].priority = 10    外地02一个机器上，优先级10 cfg.members[3].priority = 10    外地02一个机器上，优先级10 rs.reconfig(cfg)     查看优先级配置                       还有一个外地机器不设优先级，默认为1

复制集安全加固【跨网络因素】

SSL加密方式

生成ket_file

openssl rand -base64 756 > /mongodb/10001/conf/keyfile

拷贝到其他节点

cp -a /mongodb/10001/conf/keyfile /mongodb/10002/conf chmod 600 /mongodb/10001/conf/keyfile /mongodb/10002/conf/keyfile scp /mongodb/10001/conf/keyfile 10.0.0.52:/mongodb/10003/conf scp /mongodb/10001/conf/keyfile 10.0.0.52:/mongodb/10004/conf scp /mongodb/10001/conf/keyfile 10.0.53:/mongodb/10005/conf

授权，防止其他普通用户的读写

chmod 600 /mongodb/10003/conf/keyfile /mongodb/10004/conf/keyfile chmod 600 /mongodb/10005/conf/keyfile

每个节点开启验证【包含了加密连接】

01上 cat >> /mongodb/10001/conf/mongod.conf<<EOF security: keyFile: /mongodb/10001/conf/keyfile EOF cat >>/mongodb/10002/conf/mongod.conf<<EOF security: keyFile: /mongodb/10002/conf/keyfile EOF                     02上 cat >> /mongodb/10003/conf/mongod.conf <<EOF security: keyFile: /mongodb/10003/conf/keyfile EOF cat >> /mongodb/10004/conf/mongod.conf <<EOF security: keyFile: /mongodb/10004/conf/keyfile EOF                         03上 cat >> /mongodb/10005/conf/mongod.conf <<EOF security: keyFile: /mongodb/10005/conf/keyfile EOF

搭建之前就应该修改好配置文件【要不然需要重启】

****从库先开始停，arbit也要停，事务要回滚

use admin db.shutdownServer()

启动所有节点，在主节点添加用户：

启动5个节点

mongod -f /mongodb/1000*/conf/mongod.conf

添加用户

登录主库

mongo --port 10001

添加用户

use admin db.createUser( { user: "root", pwd: "root123", roles: [ { role: "root", db: "admin" } ] } ) 手工交互式输入密码 db.createUser( { user: "root1", pwd: passwordPrompt(), roles: [ { role: "root", db: "admin" } ] } ) 手工交互式验证 my_repl:PRIMARY> use admin switched to db admin my_repl:PRIMARY> db.auth("root1",passwordPrompt()) Enter password:

高级集群设计：多地域Zone分片

shard节点配置------跨地域分片【01本地1主1从和02从+02本地1主1从和01从】

创建目录

su - mongod mkdir -p /mongodb/20001/conf /mongodb/20001/data /mongodb/20001/log mkdir -p /mongodb/20002/conf /mongodb/20002/data /mongodb/20002/log mkdir -p /mongodb/20003/conf /mongodb/20003/data /mongodb/20003/log

配置文件

cat > /mongodb/20001/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/20001/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/20001/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 0.5       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true processManagement:   fork: true net:   port: 20001   bindIp: 10.0.0.51,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: CN_sh             *本地的和外地的这里区别 sharding:   clusterRole: shardsvr EOF

其他配置文件修改

\cp /mongodb/20001/conf/mongod.conf /mongodb/20002/conf/ \cp /mongodb/20001/conf/mongod.conf /mongodb/20003/conf/ sed 's#20001#20002#g' /mongodb/20002/conf/mongod.conf -i sed 's#20001#20003#g' /mongodb/20003/conf/mongod.conf -i 单独改一下外地的从节点配置文件

=========================================01-==================================

创建目录

su - mongod mkdir -p /mongodb/20001/conf /mongodb/20001/data /mongodb/20001/log mkdir -p /mongodb/20002/conf /mongodb/20002/data /mongodb/20002/log mkdir -p /mongodb/20003/conf /mongodb/20003/data /mongodb/20003/log

配置文件

cat > /mongodb/20001/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/20001/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/20001/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:     cacheSizeGB: 0.5     directoryForIndexes: true   collectionConfig:     blockCompressor: zlib   indexConfig:     prefixCompression: true processManagement:   fork: true net:   port: 20001   bindIp: 10.0.0.52,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: US_sh                 *这里 sharding:   clusterRole: shardsvr EOF

其他配置文件修改

\cp /mongodb/20001/conf/mongod.conf /mongodb/20002/conf/ \cp /mongodb/20001/conf/mongod.conf /mongodb/20003/conf/ sed 's#20001#20002#g' /mongodb/20002/conf/mongod.conf -i sed 's#20001#20003#g' /mongodb/20003/conf/mongod.conf -i 单独改一下外地的从节点配置文件

=========================================02-==================================

configserver配置

mkdir -p /mongodb/20004/conf /mongodb/20004/data /mongodb/20004/log mkdir -p /mongodb/20005/conf /mongodb/20005/data /mongodb/20005/log mkdir -p /mongodb/20006/conf /mongodb/20006/data /mongodb/20006/log cat > /mongodb/20004/conf/mongod.conf <<EOF systemLog:   destination: file   path: /mongodb/20004/log/mongodb.log   logAppend: true storage:   journal:     enabled: true   dbPath: /mongodb/20004/data   directoryPerDB: true   #engine: wiredTiger   wiredTiger:     engineConfig:       cacheSizeGB: 0.5       directoryForIndexes: true     collectionConfig:       blockCompressor: zlib     indexConfig:       prefixCompression: true processManagement:   fork: true net:   port: 20004   bindIp: 10.0.0.51,127.0.0.1 replication:   oplogSizeMB: 2048   replSetName: config sharding:   clusterRole: configsvr EOF \cp /mongodb/20004/conf/mongod.conf /mongodb/20005/conf/ \cp /mongodb/20004/conf/mongod.conf /mongodb/20006/conf/ sed 's#20004#20005#g' /mongodb/20005/conf/mongod.conf -i sed 's#20004#20006#g' /mongodb/20006/conf/mongod.conf -i mongod -f /mongodb/20004/conf/mongod.conf mongod -f /mongodb/20005/conf/mongod.conf mongod -f /mongodb/20006/conf/mongod.conf

俩地配置复制集群

01地 2001

config = {_id: 'CN_sh', members: [ {_id: 0, host: '10.0.0.51:20001'}, {_id: 1, host: '10.0.0.51:20002'}, {_id: 2, host: '10.0.0.52:20003'}] } rs.initiate(config)

02地 2001

config = {_id: 'US_sh', members: [ {_id: 0, host: '10.0.0.52:20001'}, {_id: 1, host: '10.0.0.52:20002'}, {_id: 2, host: '10.0.0.51:20003'}] } rs.initiate(config)

01地 2001配置复制集群

configserver机器上配置【模拟的是51节点上】

config = {_id: 'config', members: [ {_id: 0, host: '10.0.0.51:20004'}, {_id: 1, host: '10.0.0.51:20005'}, {_id: 2, host: '10.0.0.51:20006'}] } rs.initiate(config)

mongos配置

一般配置俩

A地配置

创建目录 mkdir -p /mongodb/20010/conf /mongodb/20010/log 配置文件修改 cat > /mongodb/20010/conf/mongos.conf<<EOF systemLog:   destination: file   path: /mongodb/20010/log/mongos.log   logAppend: true net:   bindIp: 10.0.0.51,127.0.0.1   port: 20010 sharding:   configDB: config/10.0.0.51:20004,10.0.0.51:20005,10.0.0.51:20006 processManagement:   fork: true EOF 启动mongos mongos -f /mongodb/20010/conf/mongos.conf

B地配置

创建目录 mkdir -p /mongodb/20011/conf /mongodb/20011/log 配置文件 cat> /mongodb/20011/conf/mongos.conf <<EOF systemLog:   destination: file   path: /mongodb/20011/log/mongos.log   logAppend: true net:   bindIp: 10.0.0.52,127.0.0.1   port: 20011 sharding:   configDB: config/10.0.0.51:20004,10.0.0.51:20005,10.0.0.51:20006 processManagement:   fork: true EOF 启动mongos mongos -f /mongodb/20011/conf/mongos.conf

连接分片节点

任意一个mongos就行

db.runCommand( { addshard : "CN_sh/10.0.0.51:20001,10.0.0.51:20002,10.0.0.52:20003",name:"CN_sh"} ) db.runCommand( { addshard : "US_sh/10.0.0.52:20001,10.0.0.52:20002,10.0.0.51:20003",name:"US_sh"} )

查看集群信息

sh.status()

分片定制

添加Tag来标识分片

sh.addShardTag("CN_sh", "shard00") sh.addShardTag("US_sh", "shard01")

||*激活库的分片功能【上面笔记记载】

-- 激活表所在库的分片功能,设置表的分片规则 use admin db.runCommand( { enablesharding : "zonedb" } ) sh.shardCollection("zonedb.vast", {order_id: 1});

||*设置分片键

==|设置分片策略[可以基于地域分片]

sh.addTagRange("zonedb.vast",{ "order_id" : MinKey },{ "order_id" : 500 },"shard00" ) sh.addTagRange("zonedb.vast",{"order_id" : 501 },{"order_id" : MaxKey},"shard01" )

zonedb.vast(order_id，order_name)  1-500 shard000  501-最大值shard01

备份恢复

备份

备份工具

mongoexport/mongoimport 导入/导出的是JSON格式或者CSV格式， mongodump/mongorestore导入/导出的是BSON（二进制）格式。

应用场景

应用场景: mongoexport/mongoimport:json csv 1、异构平台迁移 mysql <---> mongodb   比较慢 2、同平台，跨大版本：mongodb 2 ----> mongodb 3 mongodump/mongorestore 日常备份恢复时使用.

子主题