NoSQL
2023-12-11 17:55:07 0 举报AI智能生成
Mongodb
作者其他创作
大纲/内容
Mongodb
产品介绍
安装
解压安装并配置环境变量
关闭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/
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
passwd mongod
创建mongodb所需目录结构
mkdir -p /mongodb/conf
mkdir -p /mongodb/log
mkdir -p /mongodb/data
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
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
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
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 --是否打开用户名密码验证
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
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
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下创建.
1. 建用户时,use到的库,就是此用户的验证库
2. 登录时,必须明确指定验证库才能登录
3. 通常,管理员用的验证库是admin,普通用户的验证库一般是所管理的库设置为验证库
4. 如果直接登录到数据库,不进行use,默认的验证库是test,不是我们生产建议的.
基本语法
创建用户
use admin
db.createUser(
{
user: "root",
pwd: "123",
roles: [ { role: "root", db: "admin" } ]
}
)
db.createUser(
{
user: "root",
pwd: "123",
roles: [ { role: "root", db: "admin" } ]
}
)
说明
基本语法说明：
user:用户名
pwd:密码
roles:
role:角色名
db:作用对象
role：root, readWrite,read
user:用户名
pwd:密码
roles:
role:角色名
db:作用对象
role：root, readWrite,read
用户的验证功能
security:
authorization: enabled
authorization: enabled
登录
mongo -uroot -proot123 admin
mongo -uroot -proot123 10.0.51/admin
mongo -uroot -proot123 10.0.51/admin
查看用户
use admin
db.system.users.find().pretty()
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"}
])
{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 {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]}}
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: 匹配全部条件
● $lte: 存在并小于等于
● $gt: 存在并大于
● $gte: 存在并大于等于
● $ne: 不存在或存在但不等于
● $in: 存在并在指定数组中
● $nin: 不存在或不在指定数组中
● $or: 匹配两个或多个条件中的一个
● $and: 匹配全部条件
使用 find 搜索子文档
db.fruit.insertOne({
name: "apple",
from: {
country: "China",
province: "Guangdong" }
})
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"] }
])
{ "name" : "Apple", color: ["red", "green" ] },
{ "name" : "Mango", color: ["yellow", "green"] }
])
查看单个条件：
db.fruit.find({color: "red"})
db.fruit.find({color: "red"})
查询多个条件：
db.fruit.find({$or: [{color: "red"}, {color: "yellow"}]} )
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" }
]
})
"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"})
db.movies.find({"filming_locations.city": "Rome"})
使用 find 搜索数组中的对象
db.getCollection('movies').find({
"filming_locations.city": "Rome",
"filming_locations.country": "USA"
})
"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" }
]
})
"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"}
}
})
"filming_locations": {
$elemMatch:{"city":"bj", "country": "CHN"}
}
})
在数组中搜索子对象的多个字段时，如果使用 $elemMatch，它表示必须是同一个子对象满足多个条件。
控制 find 返回的字段
find 可以指定只返回指定的字段；
● _id字段必须明确指明不返回，否则默认返回；
● 在 MongoDB 中我们称这为投影（projection）；
● db.movies.find({},{"_id":0, title:1})
● _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() //报错
● 匹配查询条件的的文档会被删除；
● 指定一个空文档条件会删除所有文档；
● 以下示例：
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"}})
● 以以下数据为例：
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"})
● 使用 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: 如果不存在则增加一个值到数组
● $pushAll: 增加多个对象到数组底部
● $pop: 从数组底部删除一个对象
● $pull: 如果匹配指定的值，从数组中删除相应的对象
● $pullAll: 如果匹配任意的值，从数据中删除相应的对象
● $addToSet: 如果不存在则增加一个值到数组
使用 drop 删除集合
● 使用 db.<集合>.drop() 来删除一个集合
● 集合中的全部文档都会被删除
● 集合相关的索引也会被删除
db.colToBeDropped.drop()
● 集合中的全部文档都会被删除
● 集合相关的索引也会被删除
db.colToBeDropped.drop()
使用 dropDatabase 删除数据库
● 使用 db.dropDatabase() 来删除数据库
● 数据库相应文件也会被删除，磁盘空间将被释放
use tempDB
db.dropDatabase()
show collections // No collections
show dbs // The db is gone
● 数据库相应文件也会被删除，磁盘空间将被释放
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
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
使用驱动连接到 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
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（投票节点）
• 一个主节点（PRIMARY）：接受写入操作和选举时投票
• 两个（或多个）从节点（SECONDARY）：复制主节点上的新数据和选举时投票
• Arbiter（投票节点）
数据是如何复制的
当一个修改操作，无论是插入、更新或删除，到达主节点时，它对数据的操作将被记录下来（经过一些必
要的转换），这些记录称为 oplog。
从节点通过在主节点上打开一个 tailable 游标不断获取新进入主节点的 oplog，并在自己的数据上
回放，以此保持跟主节点的数据一致。
要的转换），这些记录称为 oplog。
从节点通过在主节点上打开一个 tailable 游标不断获取新进入主节点的 oplog，并在自己的数据上
回放，以此保持跟主节点的数据一致。
通过选举完成故障恢复
具有投票权的节点之间两两互相发送心跳；
● 当5次心跳未收到时判断为节点失联；
● 如果失联的是主节点，从节点会发起选举，选出新的主节点；
● 如果失联的是从节点则不会产生新的选举；
● 选举基于 RAFT 一致性算法实现，选举成功的必要条件是大多数投票节点存活；
● 当5次心跳未收到时判断为节点失联；
● 如果失联的是主节点，从节点会发起选举，选出新的主节点；
● 如果失联的是从节点则不会产生新的选举；
● 选举基于 RAFT 一致性算法实现，选举成功的必要条件是大多数投票节点存活；
影响选举的因素
整个集群必须有大多数节点存活；被选举为主节点的节点必须：
• 能够与多数节点建立连接
• 具有较新的 oplog
• 具有较高的优先级（如果有配置）
• 能够与多数节点建立连接
• 具有较新的 oplog
• 具有较高的优先级（如果有配置）
常见选项
复制集节点有以下常见的选配项：
• 是否具有投票权（v 参数）：有则参与投票；
• 优先级（priority 参数）：优先级越高的节点越优先成为主节点。优先级为0的节点无法成为主节
点；
• 隐藏（hidden 参数）：复制数据，但对应用不可见。隐藏节点可以具有投票仅，但优先级必须为0；
• 延迟（slaveDelay 参数）：复制 n 秒之前的数据，保持与主节点的时间差。
• 是否具有投票权（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
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 复制集的名
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
\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
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)
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)
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" : [ ]
})
"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();
注：在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();
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() 可以看到延时的时间
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天，如何加速？
• 地理分布数据
• 新品上线异常火爆，如何支撑更多的并发用户？
• 单库已有 10TB 数据，恢复需要1-2天，如何加速？
• 地理分布数据
如何解决以上问题
•银行交易单表内10亿笔资料
•超负荷运转
•超负荷运转
分片架构介绍Mongodb sharding cluster【MSC】
• Mongos 路由节点
提供集群单一入口
转发应用端请求
选择合适数据节点进行读写
合并多个数据节点的返回
无状态
建议至少2个
• Config Servers配置节点
提供集群元数据存储
分片数据分布的映射
• Shards 数据节点
以复制集为单位
横向扩展
最大1024分片
分片之间数据不重复
所有分片在一起才可完整工作
提供集群单一入口
转发应用端请求
选择合适数据节点进行读写
合并多个数据节点的返回
无状态
建议至少2个
• Config Servers配置节点
提供集群元数据存储
分片数据分布的映射
• Shards 数据节点
以复制集为单位
横向扩展
最大1024分片
分片之间数据不重复
所有分片在一起才可完整工作
MongoDB 分片集群特点
• 应用全透明，无特殊处理
• 数据自动均衡
• 动态扩容，无须下线
• 提供三种分片方式
• 数据自动均衡
• 动态扩容，无须下线
• 提供三种分片方式
分片集群数据分布方式
• 基于范围 chunk 每个单元
优点 范围查询性能好 优化读
缺点 往一个分片生成好多chunk 单元写，空闲时触发blance再往其他分片挪数据。数据分布不均匀 容易有写热点
• 基于 Hash crc32
优点 数据分布均匀 有利于写的优化 存储打的很散 适用于日志，物联网高并发写入场景
缺点 范围查效率低 适合于点查
• 基于 zone / tag
优点 基于DNS 路由到mongodb上 选择最近的服务器
优点 范围查询性能好 优化读
缺点 往一个分片生成好多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
(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
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
===============
根据需求修改相应参数：几个分片几个主节点配置文件 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
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
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)
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)
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
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
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
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
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)
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
新版本中，要求必须是复制集。
注：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
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();
（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();
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()
创建哈希索引
（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。
（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()
介绍：
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、磁盘中的任何一项出现瓶颈时，都可以通过添加更多分片来解决。
• 关于索引：常用索引必须容纳进内存；
• 按照以上标准初步确定分片后，还需要考虑业务压力，随着压力增大，CPU、RAM、磁盘中的任何一项出现瓶颈时，都可以通过添加更多分片来解决。
如何粗略判断需要多少分片
条件 分片个数
B : 工作集大小 / 单服务器内存容量 400GB / （256G * 0.6） = 3
A : 所需存储总量 / 单服务器可挂载容量 8TB / 2TB = 4
C : 并发量总数 / （单服务器并发量 * 0.7） 30000 / (9000*0.7) = 6
D: 额外开销 ？
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）；
• 取值分布；
• 分散写，集中读；
• 被尽可能多的业务场景用到；
• 避免单调递增或递减的片键；
• 取值基数（Cardinality）；
• 取值分布；
• 分散写，集中读；
• 被尽可能多的业务场景用到；
• 避免单调递增或递减的片键；
选择基数大的片键
对于小基数的片键：
• 因为备选值有限，那么块的总数量就有限；
• 随着数据增多，块的大小会越来越大；
• 水平扩展时移动块会非常困难；
例如：存储一个高中的师生数据，以年龄（假设年龄范围为15~65岁）作为片键，
15<=年龄<=65，且只为整数,所以最多只会有51个 chunk
结论：取值基数要大！
• 因为备选值有限，那么块的总数量就有限；
• 随着数据增多，块的大小会越来越大；
• 水平扩展时移动块会非常困难；
例如：存储一个高中的师生数据，以年龄（假设年龄范围为15~65岁）作为片键，
15<=年龄<=65，且只为整数,所以最多只会有51个 chunk
结论：取值基数要大！
选择分布均匀的片键
对于分布不均匀的片键：
• 造成某些块的数据量急剧增大
• 这些块压力随之增大
• 数据均衡以 chunk 为单位，所以系统无能为力 • 例如：存储一个学校的师生数据，以年龄（假设年
龄范围为15~65岁）作为片键，
那么：
• 15<=年龄<=65，且只为整数
• 大部分人的年龄范围为15~18岁（学生） • 15、16、17、18四个 chunk 的数据量、访问压力远大
于其他 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()
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: []
}
_id: ObjectId(),
user: 123,
time: Date(),
subject: “...”,
recipients: [],
body: “...”,
attachments: []
}
如何规划硬件
• mongos 与 config 通常消耗很少的资源，可以选择低规格虚拟机；
• 资源的重点在于 shard 服务器：
• 需要足以容纳热数据索引的内存；
• 正确创建索引后 CPU 通常不会成为瓶颈，除非涉及非常多的计算；
• 磁盘尽量选用 SSD；
实际测试是最好的检验，来看你的资源配置是否完备。
另外，即使项目初期已经具备了足够的资源，仍然需要考虑在合适的时候扩展。建议监控
各项资源使用情况，无论哪一项达到60%以上，则开始考虑扩展。
• 扩展需要新的资源，申请新资源需要时间；
• 扩展后数据需要均衡，均衡需要时间。应保证新数据入库速度慢于均衡速度
• 均衡需要资源，如果资源即将或已经耗尽，均衡也是会很低效的。
• 资源的重点在于 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
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
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
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
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
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
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
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
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
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)
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个节点信息
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
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/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
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
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()
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:
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
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
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
单独改一下外地的从节点配置文件
\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
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
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
单独改一下外地的从节点配置文件
\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
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)
{_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)
{_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)
{_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
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
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"} )
"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")
sh.addShardTag("US_sh", "shard01")
||*激活库的分片功能【上面笔记记载】
-- 激活表所在库的分片功能,设置表的分片规则
use admin
db.runCommand( { enablesharding : "zonedb" } )
sh.shardCollection("zonedb.vast", {order_id: 1});
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" )
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（二进制）格式。
mongodump/mongorestore导入/导出的是BSON（二进制）格式。
应用场景
应用场景:
mongoexport/mongoimport:json csv
1、异构平台迁移 mysql <---> mongodb 比较慢
2、同平台，跨大版本：mongodb 2 ----> mongodb 3
mongodump/mongorestore
日常备份恢复时使用.
mongoexport/mongoimport:json csv
1、异构平台迁移 mysql <---> mongodb 比较慢
2、同平台，跨大版本：mongodb 2 ----> mongodb 3
mongodump/mongorestore
日常备份恢复时使用.
子主题
子主题
子主题
子主题
子主题
子主题
子主题
子主题
0 条评论
下一页
