MongoDB副本集+分片集群搭建

单机安装部署

准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
（1）redhat或centos6.2以上系统
（2）系统开发包完整
（3）ip地址和hosts文件解析正常
（4）iptables防火墙&SElinux关闭
（5）关闭大页内存机制
########################################################################
#CentOS
root用户下 /etc/rc.local 最后添加如下代码
cat >> /etc/rc.local << EOF
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
EOF    

cat  /sys/kernel/mm/transparent_hugepage/enabled        
cat /sys/kernel/mm/transparent_hugepage/defrag  

#其他系统关闭参照官方文档：   
https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/

安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#进入/web/soft/目录下载
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.12.tgz
#解压
tar -zxf mongodb-linux-x86_64-rhel70-3.6.12.tgz
#改名
mv mongodb-linux-x86_64-rhel70-3.6.12 mongodb
#创建日志、数据和配置文件目录
mkdir -p /web/data/mongodb/
mkdir -p /web/logs/mongodb/
mkdir -p /web/soft/mongodb/conf/
#授权
chown -R deploy.deploy /web/soft/mongodb/
#设置环境变量
cat >> /etc/profile <<EOF
export PATH=/web/soft/mongodb/bin:$PATH
EOF

source /etc/profile
#启动
mongod --dbpath=/web/data/mongodb/ --logpath=/web/logs/mongodb/mongodb.log --port=27017 --logappend --fork

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
cat > /web/soft/mongodb/conf/mongodb.conf <<EOF
systemLog:
   destination: file        
   path: "/web/logs/mongodb/mongodb.log"
   logAppend: true
storage:
   journal:
      enabled: true
   dbPath: "/web/data/mongodb/"
processManagement:
   fork: true
net:            
   bindIp: 192.168.177.200,127.0.0.1
   port: 27017
EOF

#关闭
mongod -f /web/soft/mongodb/conf/mongodb.conf --shutdown
#启动
mongod -f /web/soft/mongodb/conf/mongodb.conf

########################################################
--系统日志有关  
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>                       -- 监听地址必须设置
   port: <port>                       -- 端口号,默认不配置端口号，是27017
   
-- 安全验证有关配置      
security:
  authorization: enabled              --是否打开用户名密码验证

systemd管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
cat > /etc/systemd/system/mongod.service <<EOF
[Unit]
Description=mongodb 
After=network.target remote-fs.target nss-lookup.target
[Service]
User=deploy
Type=forking
ExecStart=/web/soft/mongodb/bin/mongod --config /web/soft/mongodb/conf/mongodb.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/web/soft/mongodb/bin/mongod --config /web/soft/mongodb/conf/mongodb.conf --shutdown
PrivateTmp=true  
[Install]
WantedBy=multi-user.target
EOF

MongoDB基本操作

默认库

1
2
3
4
5
6
7
8
9
10
11
12
13
#查看所有数据库
show  databases/show dbs
#查看表
show tables
#切换
use admin
#当use一个不存在的库时会虚拟这个库 只有当在库中做修改的时候才能查询到
#查看当前所在库
db
test:#登录时默认存在的库
admin库:#系统预留库,MongoDB系统管理库
local库:#本地预留库,存储关键日志
config库:#MongoDB配置信息库

命令

db对象

1
2
3
4
5
6
7
8
#查看库相关命令
db.[TAB][TAB] 
#查看库命令介绍示例
db.help() 
#查看表相关命令
db.amt.[TAB][TAB] 
#查看表命令介绍示例
db.amt.help()

rs复制集

1
2
3
4
#查看复制集相关命令
rs.[TAB][TAB]
#查看复制集命令介绍示例
rs.help()

sh分片集群

1
2
3
4
#查看分片集群相关命令
sh.[TAB][TAB]
#查看分片集群命令介绍示例
sh.help()

对象操作

库操作

1
2
3
4
5
#创建
> use amt
#删除当前库
> db.dropDatabase()
{ "dropped" : "amt", "ok" : 1 }

集合操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#创建集合
> db.createCollection('amt')
{ "ok" : 1 }
> db.createCollection('amtuser')
#删除集合 .指定集合名称drop
> db.amt.drop()
true
方法2：当插入一个文档的时候，一个集合就会自动创建。

> use amt
#给amtuser集合中插入数据
> db.amtuser.insert({id:1,name:"张三",age:20,gender:"男"})
WriteResult({ "nInserted" : 1 })
> db.amtuser.insert({id:2,name:"李四",age:28,gender:"男"})
> db.amtuser.insert({id:3,name:"王五",age:18,gender:"女"})

文档操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#测试数据录入
for(i=0;i<10000;i++){db.amtuser.insert({"uid":i,"name":"mongodb","age":6,"date":newDate()})}

#统计集合中行数
> db.amtuser.count()
3
#查询集合中所有数据
> db.amtuser.find()
{ "_id" : ObjectId("672b05c6df37ce934a286665"), "id" : 1, "name" : "张三", "age" : 20, "gender" : "男" }
{ "_id" : ObjectId("672b07bedf37ce934a286666"), "id" : 2, "name" : "李四", "age" : 28, "gender" : "男" }
{ "_id" : ObjectId("672b07d3df37ce934a286667"), "id" : 3, "name" : "王五", "age" : 18, "gender" : "女" }....
#格式化查询 json格式显示
> db.amtuser.find().pretty()
{
	"_id" : ObjectId("672b05c6df37ce934a286665"),
	"id" : 1,
	"name" : "张三",
	"age" : 20,
	"gender" : "男"
}....
#条件查询
> db.amtuser.find({id:1})
{ "_id" : ObjectId("672b05c6df37ce934a286665"), "id" : 1, "name" : "张三", "age" : 20, "gender" : "男" }
#删除集合中所有记录
> db.amtuser.remove({})
WriteResult({ "nRemoved" : 3 })
#每页显示50条记录：
> DBQuery.shellBatchSize=50;

#集合中索引+数据压缩存储之后的大小
> db.amtuser.totalSize()

用户权限及管理

1
2
3
4
5
6
7
8
验证库: 建立用户时use到的库，在使用用户时，要加上验证库才能登陆。

对于管理员用户,必须在admin下创建
1. 建用户时,use到的库,就是此用户的验证库
2. 登录时,必须明确指定验证库才能登录
3. 通常,管理员用的验证库是admin,普通用户的验证库一般是所管理的库设置为验证库
4. 如果直接登录到数据库,不进行use,默认的验证库是test,不是我们生产建议的
5. 从3.6 版本开始，不添加bindIp参数，默认不让远程登录，只能本地管理员登录

用户创建语法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
use admin 
db.createUser
{
    user: "<name>",
    pwd: "<cleartext password>",
    roles: [
       { role: "<role>",
     db: "<database>" } | "<role>",
    ...
    ]
}

基本语法说明：
user:用户名
pwd:密码
roles:
    role:角色名
    db:作用对象 
role：root(超级管理员), readWrite(可读可写),read(只读)  
验证数据库：
mongo -u admin -p 123456 192.168.177.200:27017/amt

用户管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#创建超级管理员：管理所有数据库 创建前必须use到admin库下
mongo
> use admin
> db.createUser(
	{
    	user: "admin",
    	pwd: "123456",
    	roles: [ { role: "root", db: "admin" } ]
	}
)

#查看用户信息
> db.system.users.find()
{ "_id" : "admin.admin", "user" : "admin", "db" : "admin", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "CSDO31USXJjz31vFAH5exQ==", "storedKey" : "8GwQGAB7zXChHjSlrIagBiBeKhM=", "serverKey" : "A7SYZ5t48kfZr5FD5qWE6LpKtWw=" } }, "roles" : [ { "role" : "root", "db" : "admin" } ] }

#删除用户 root登陆
> db.createUser({user: "amt",pwd: "123456",roles: [ { role: "readWrite" , db: "amt" } ]})
mongo -u admin -p 123456 192.168.177.200/admin
> use amt
> db.dropUser("amt")
#验证删除
> use admin
> db.system.users.find()

验证用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> db.auth('admin','123456')
1

#开启安全认证
cat >> /web/soft/mongodb/conf/mongodb.conf <<EOF
security:
  authorization: enabled
EOF

#重启
systemctl restart mongod

#登陆验证
mongo -u admin -p 123456 admin
mongo -uadmin -p123456  192.168.177.200/admin
#或
> mongo
> use admin
> db.auth('admin','123456')

创建应用用户

1
2
3
4
5
6
7
8
9
10
11
12
mongo
> use amt
> db.createUser(
	{
		user: "amt",
    	pwd: "123456",
    	roles: [ { role: "readWrite", db: "amt" } ]
	}
)

#验证
mongo -u amt -p 123456 amt

MongoDB复制集

原理

1
2
3
基本构成是1主2从的结构，自带互相监控投票机制（Raft（MongoDB）  Paxos（mysql MGR 用的是变种））
如果发生主库宕机，复制集内部会进行投票选举，选择一个新的主库替代原有主库对外提供服务。同时复制集会自动通知
客户端程序，主库已经发生切换了。应用就会连接到新的主库。

主从：当主节点不可用，符合条件的从节点将进行选举，以将自己选举为新的主节点。

主从+仲裁：仲裁节点参与选举，但不持有数据

环境

192.168.177.200 主 192.168.177.201 从 192.168.177.202 从
27010 27010 27010

准备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#进入/web/soft/目录下载
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.12.tgz
#解压
tar -zxf mongodb-linux-x86_64-rhel70-3.6.12.tgz
#改名
mv mongodb-linux-x86_64-rhel70-3.6.12 mongodb
#创建日志、数据和配置文件目录
mkdir -p /web/data/mongodb/27010/
mkdir -p /web/logs/mongodb/27010/
mkdir -p /web/soft/mongodb/27010/conf/
#授权
chown -R deploy.deploy /web/soft/mongodb/
chown -R deploy.deploy /web/logs/mongodb/
chown -R deploy.deploy /web/data/mongodb/
#设置环境变量
cat >> /etc/profile <<EOF
export PATH=/web/soft/mongodb/bin:$PATH
EOF
#重新加载环境变量
source /etc/profile

配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
cat > /web/soft/mongodb/27010/conf/mongod.conf <<EOF
systemLog:
  destination: file
  path: /web/logs/mongodb/27010/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /web/data/mongodb/27010/
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
processManagement:
  fork: true
net:
  bindIp: 0.0.0.0
  port: 27010
replication:
  oplogSizeMB: 2048
  replSetName: repl
EOF

启动

1
2
mongod -f /web/soft/mongodb/27010/conf/mongod.conf
ps -ef|grep mongodb

普通复制集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#1主2从，普通从库
mongo --port 27010 admin
config = {
	_id: 'repl', members: 
		[
			{_id: 0, host: '192.168.177.200:27010'},
         	 {_id: 1, host: '192.168.177.201:27010'},
        	 {_id: 2, host: '192.168.177.202:27010'}
     	]
}
#初始化
rs.initiate(config) 
#查询复制集状态
rs.status();

仲裁

1
2
3
4
5
6
7
8
9
10
11
mongo -port 27010 admin
config = {
	_id: 'repl', members:
		[
			{_id: 0, host: '192.168.177.200:27010'},
			{_id: 1, host: '192.168.177.201:27010'},
			{_id: 2, host: '192.168.177.202:27010',"arbiterOnly":true}
		]
}
#初始化
rs.initiate(config)

复制集状态

1
2
3
4
5
6
#查看整体复制集状态
rs.status();
#查看当前是否是主节点
rs.isMaster();
#查看复制集配置信息
rs.conf();

添加删除节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#删除一个节点
rs.remove("ip:port");
#新增从节点
rs.add("ip:port");
#新增仲裁节点
rs.addArb("ip:port");

#新增从节点
#1、连接到主节点
mongo -port 27010 admin
rs.remove("192.168.177.202:27010");
#2、添加从节点
rs.add("192.168.177.202:27010")
#查看节点状态
rs.isMaster()
{
"hosts" : [
		"192.168.177.200:27010",
		"192.168.177.201:27010",
		"192.168.177.202:27010"
	]
}

#添加arbiter节点
#1、连接到主节点
mongo -port 27010 admin
rs.remove("192.168.177.202:27010");
#2、添加仲裁节点
rs.addArb("192.168.177.202:27010")
#3、查看节点状态
rs.isMaster()
{
	"hosts" : [
		"192.168.177.200:27010",
		"192.168.177.201:27010"
	],
	"arbiters" : [
		"192.168.177.202:27010"
	]
}

命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#查看副本集的配置信息
admin> rs.conf()
#查看副本集各成员的状态
admin> rs.status()
#副本集角色切换（不要人为随便操作）
admin> rs.stepDown()
#锁定从，使其不会转变成主库
rs.freeze(300)          #freeze()和stepDown单位都是秒。
#查看副本节点（监控主从延时）
rs.printSlaveReplicationInfo()
source: 192.168.177.200:27010
	syncedTo: Mon Nov 11 2024 16:45:41 GMT+0800 (CST)
	0 secs (0 hrs) behind the primary 
#从库执行设置从库可读
rs.slaveOk()

特殊从节点

介绍

1
2
3
#arbiter节点：主要负责选主过程中的投票，但是不存储任何数据，也不提供任何服务
#hidden节点：隐藏节点，不参与选主，也不对外提供服务。
#delay节点：延时节点，数据落后于主库一段时间，因为数据是延时的，也不应该提供服务或参与选主，所以通常会配合hidden（隐藏）一般情况下 delay+hidden 一起配置使用

配置延时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
cfg=rs.conf() 
# 0 不参与选主
cfg.members[2].priority=0
#隐藏
cfg.members[2].hidden=true
#延时
cfg.members[2].slaveDelay=120
rs.reconfig(cfg)


#取消以上配置
#定义变量
cfg=rs.conf() 
#使用节点顺序为2[0为起点]的主机调用变量中的配置进行修改
cfg.members[2].priority=1
cfg.members[2].hidden=false
cfg.members[2].slaveDelay=0
#重载配置
rs.reconfig(cfg)    
#配置成功后，通过以下命令查询配置后的属性
rs.conf();

MongoDB Sharding Cluster 分片集群

1
2
3
Shard: 分片节点 存放数据
Config Servers：记录节点信息、分片配置和数据分布
Router： 对外提供服务

规划

1
2
3
4
5
6
7
8
#10个实例
1、ConfigServers:27011
#3台构成复制集(1主2从，不支持arbiter)(复制集名字 cs)
2、Shard节点：
rs1：27012     (1主2从，一个节点为arbiter，复制集名字 rs1)
rs2：27013     (1主2从，一个节点为arbiter，复制集名字 rs2)
3、mongos:
27020
192.168.177.200 192.168.177.201 192.168.177.202
27011 27012 27013 27020 27011 27012 27013 27011 27012 27013

目录创建

1
2
3
mkdir -p /web/data/mongodb/2701{1..3}/ /web/logs/mongodb/2701{1..3}/ /web/soft/mongodb/2701{1..3}/conf/
#192.168.177.200
mkdir -p /web/logs/mongodb/27020/ /web/soft/mongodb/27020/conf/

Shard节点配置

shard1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
cat > /web/soft/mongodb/27012/conf/mongod.conf <<EOF
systemLog:
  destination: file
  path: /web/logs/mongodb/27012/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /web/data/mongodb/27012/
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
processManagement:
  fork: true
net:
  bindIp: 0.0.0.0
  port: 27012
replication:
  oplogSizeMB: 2048
  replSetName: rs1
sharding:
  clusterRole: shardsvr  
EOF

shard2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
cat > /web/soft/mongodb/27013/conf/mongod.conf <<EOF
systemLog:
  destination: file
  path: /web/logs/mongodb/27013/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /web/data/mongodb/27013/
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
processManagement:
  fork: true
net:
  bindIp: 0.0.0.0
  port: 27013
replication:
  oplogSizeMB: 2048
  replSetName: rs2
sharding:
  clusterRole: shardsvr  
EOF

启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
mongod -f /web/soft/mongodb/27012/conf/mongod.conf
mongod -f /web/soft/mongodb/27013/conf/mongod.conf
ps -ef |grep mongod
#192.168.177.200
mongo --port 27012
use  admin
config = {
	_id: 'rs1', members:
		[
			{_id: 0, host: '192.168.177.200:27012'},
			{_id: 1, host: '192.168.177.201:27012'},
			{_id: 2, host: '192.168.177.202:27012',"arbiterOnly":true}
		]
}
rs.initiate(config)

mongo --port 27013
use  admin
config = {
	_id: 'rs2', members:
		[
			{_id: 0, host: '192.168.177.200:27013'},
			{_id: 1, host: '192.168.177.201:27013'},
			{_id: 2, host: '192.168.177.202:27013',"arbiterOnly":true}
		]
}
rs.initiate(config)

ConfigServers节点配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
cat > /web/soft/mongodb/27011/conf/mongod.conf <<EOF
systemLog:
  destination: file
  path: /web/logs/mongodb/27011/mongodb.log
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /web/data/mongodb/27011/
  directoryPerDB: true
  #engine: wiredTiger
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
net:
  bindIp: 0.0.0.0
  port: 27011
replication:
  oplogSizeMB: 2048
  replSetName: cs
sharding:
  clusterRole: configsvr
processManagement: 
  fork: true
EOF

启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mongod -f /web/soft/mongodb/27011/conf/mongod.conf
ps -ef |grep mongod
#192.168.177.200
mongo --port 27011
use  admin
config = {
	_id: 'cs', members:
		[
			{_id: 0, host: '192.168.177.200:27011'},
			{_id: 1, host: '192.168.177.201:27011'},
			{_id: 2, host: '192.168.177.202:27011'}
		]
}
rs.initiate(config)

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

Mongos节点配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
cat > /web/soft/mongodb/27020/conf/mongos.conf <<EOF
systemLog:
  destination: file
  path: /web/logs/mongodb/27020/mongos.log
  logAppend: true
net:
  bindIp: 0.0.0.0
  port: 27020
sharding:
#ConfigServers 节点名、地址
  configDB: cs/192.168.177.200:27011,192.168.177.201:27011,192.168.177.202:27011
processManagement: 
  fork: true
EOF

启动

1
mongos -f /web/soft/mongodb/27020/conf/mongos.conf

分片集群添加节点

1
2
3
4
5
6
7
8
9
#连接mongos/admin数据库
mongo 192.168.177.200:27020/admin
#添加分片
db.runCommand({ addshard : "rs1/192.168.177.200:27012,192.168.177.201:27012,192.168.177.202:27012",name:"shard1"})
db.runCommand({ addshard : "rs2/192.168.177.200:27013,192.168.177.201:27013,192.168.177.202:27013",name:"shard2"})
#列出分片
db.runCommand( { listshards : 1 } )
#整体状态查看
sh.status();
1
#自动分片mongos 采用广播形式  数据不均匀 单点访问频繁

RANGE分片配置

激活数据分片功能

1
2
3
4
5
mongo 192.168.177.200:27020/admin
# 开启库的分片功能
db.runCommand({ enablesharding : "数据库名称" })
###
db.runCommand({ enablesharding : "amt" })

指定分片键对集合分片

1
2
3
4
5
6
# 创建索引
use amt
db.user.ensureIndex({ id: 1 })
# 开启分片
use admin
db.runCommand({ shardcollection : "amt.user",key : {id: 1}})

数据录入

1
2
3
use test
for(i=1;i<1000000;i++){ db.user.insert({"id":i,"name":"amt","age":18,"date":new Date()}); }
db.user.stats()

验证

1
2
3
4
5
6
7
8
9
# shard1:
mongo --port 27012
use amt
db.user.count();

# shard2:
mongo --port 27013
use amt
db.user.count();

Hash分片

1
2
3
4
5
6
7
8
9
10
11
12
# 对amtdb库下的user大表进行hash
# 创建哈希索引
# 对于amtdb开启分片功能
mongo --port 27020 admin
use admin
db.runCommand( { enablesharding : "amtdb" } )
# 对于oldboy库下的vast表建立hash索引
use amtdb
db.user.ensureIndex( { id: "hashed" } )
# 开启分片 
use admin
sh.shardCollection( "amtdb.user", { id: "hashed" } )

录入数据

1
2
3
# 录入10w行数据测试
use amtdb
for(i=1;i<100000;i++){ db.user.insert({"id":i,"name":"amtdb","age":18,"date":new Date()}); }

验证

1
2
3
4
5
6
# shard1
mongo --port 27012 amtdb
db.user.count();
# shard2
mongo --port 27013 amtdb
db.user.count();

分片集群查询及管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#判断是否Shard集群
mongos> db.runCommand({ isdbgrid : 1})
#列出所有分片信息
use admin
admin> db.runCommand({ listshards : 1})
# 列出开启分片的数据库
admin> use config
config> db.databases.find( { "partitioned": true } )
##或者：列出所有数据库分片情况
config> db.databases.find() 
#查看分片的片键
db.collections.find().pretty()
{
	"_id" : "amt.user",
	"lastmodEpoch" : ObjectId("6732c5b6d6df0dcdb17cdf26"),
	"lastmod" : ISODate("1970-02-19T17:02:47.296Z"),
	"dropped" : false,
	"key" : {
		"id" : 1
	},
	"unique" : false,
	"uuid" : UUID("c156517d-1744-4061-bece-c9c61996bbec")
}
#查看分片的详细信息
admin> sh.status()
#删除分片节点（谨慎）
##1、确认blance是否在工作
sh.getBalancerState()
##2、删除shard2节点(谨慎)
mongos> db.runCommand( { removeShard: "shard2" } )
#注意：删除操作一定会立即触发blancer。

balancer操作

介绍

1
2
3
4
5
6
7
8
9
mongos的一个重要功能，自动巡查所有shard节点上的chunk的情况，自动做chunk迁移。
什么时候工作？
1、自动运行，会检测系统不繁忙的时候做迁移
2、在做节点删除的时候，立即开始迁移工作
3、balancer只能在预设定的时间窗口内运行(圣餐)

有需要时可以关闭和开启blancer（备份的时候）
mongos> sh.stopBalancer()
mongos> sh.startBalancer()

自定义 自动平衡进行时间段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
https://docs.mongodb.com/manual/tutorial/manage-sharded-cluster-balancer/#schedule-the-balancing-window
#connect to mongos
mongo 192.168.177.200:27020

use config
#sh.getBalancerState() 查看是否启用  默认true
sh.setBalancerState( true )
#sh.isBalancerRunning() 查看是否在运行状态
#确保负载均衡器未stopped
sh.startBalancer()
#设定规则1、业务不繁忙期间 2、避开备份恢复时间点
db.settings.update({ _id : "balancer" }, { $set : { activeWindow : { start : "3:00", stop : "5:00" } } }, true )

sh.getBalancerWindow()
sh.status()

#关于集合的balancer
#关闭某个集合的balance
sh.disableBalancing("students.grades")
#打开某个集合的balancer
sh.enableBalancing("students.grades")
#确定某个集合的balance是开启或者关闭
db.getSiblingDB("config").collections.findOne({_id : "students.grades"}).noBalance;

备份恢复

备份工具

1
2
1、**   mongoexport(导出)/mongoimport(导入)
2、***** mongodump(导出)/mongorestore(导入)

区别

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

mongoexport

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
mongoexport具体用法如下所示：
$ mongoexport --help  
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection(表名[集合名])的名字
-f:指明要导出那些列
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
--authenticationDatabase admin


1.单表备份至json格式
mongoexport -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -c user -o /tmp/user.json

注：备份文件的名字可以自定义，默认导出了JSON格式的数据。

2. 单表备份至csv格式
如果我们需要导出CSV格式的数据，则需要使用----type=csv参数：

mongoexport -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -c user --type=csv -f _id,id,name,age,date -o /tmp/user.csv

mongoimport

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$ mongoimport --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导入那些列
-j,--numInsertionWorkers=<number>  number of insert operations to run concurrently              (defaults to 1)

#并行
数据恢复:
1.恢复json格式表数据到user
mongoimport -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amtdb -c user /tmp/user.json

2.恢复csv格式的文件到amtuser
如果要导入CSV格式文件中的内容，则需要通过--type参数指定导入格式，具体如下所示：
错误的恢复
注意：
#1、csv格式的文件头行，有列名字
mongoimport -uadmin -p123456 --port 27017 --authenticationDatabase admin   -d amtdb -c amtuser --type=csv --headerline --file  /tmp/user.csv
# --headerline:指明第一行是列名，不需要导入 仅适用于导入 csv 文件。

#2、csv格式的文件头行，没有列名字  需要指定列名
mongoimport -uadmin -p123456 --port 27017 --authenticationDatabase admin   -d amtdb -c amtusers --type=csv -f _id,id,name,age,date --file  /tmp/user.csv

异构平台迁移

Mysql导出数据迁移到MongoDB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
mysql   -----> mongodb  
amt数据库下amtuser表进行导出，导入到mongodb

#mysql开启安全路径
cat >> /etc/mysql/3307/my.cnf << EOF
secure-file-priv=/tmp
EOF

#重启数据库生效
systemctl start mysqld3307
mysql -S /web/data/mysql/3307/mysql.sock

#导出mysql的amtuser表数据
select * from amt.amtuser into outfile '/tmp/amtuser.csv' fields terminated by ',';

#处理备份文件
desc amt.amtuser
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| id    | int(11)      | YES  |     | NULL    |       |
| name  | varchar(255) | YES  |     | NULL    |       |
| age   | int(11)      | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+

vim /tmp/amtuser.csv   ----> 添加第一行列名信息
id,name,age

#在mongodb中导入备份
mongoimport -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt  -c amtuser --type=csv -f id,name,age --file  /tmp/amtuser.csv

mongo -u admin -p 123456 admin
use amt
db.amtuser.find();

#################################################
假如amt数据库共100张表，全部迁移到mongodb

#获取amt库下所有表的列名
select table_name ,group_concat(column_name) from columns where table_schema='amt' group by table_name;
#导出csv格式数据到/tmp 下
select * from world.city into outfile '/tmp/user.csv' fields terminated by ',';
#生成amt数据库所有表数据导出语句
select concat("select * from ",table_schema,".",table_name ," into outfile '/tmp/",table_schema,"_",table_name,".csv' fields terminated by ',';") from information_schema.tables where table_schema ='amt';

#导入：
提示：使用infomation_schema.columns + information_schema.tables

Mysql导入导出csv

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#mysql导出csv：
select * from test_info   
into outfile '/tmp/test.csv'   
fields terminated by ','　　　 ------字段间以,号分隔
optionally enclosed by '"'　　 ------字段用 " 号括起
escaped by '"'   　　　　　　   ------字段中使用的转义符为"
lines terminated by '\r\n';　　------行以\r\n结束

#mysql导入csv：
load data infile '/tmp/test.csv'   
into table test_info    
fields terminated by ','  
optionally enclosed by '"' 
escaped by '"'   
lines terminated by '\r\n';

mongodump和mongorestore

介绍

1
mongodump能够在Mongodb运行时进行备份，它的工作原理是对运行的Mongodb做查询，然后将所有查到的文档写入磁盘。但是存在的问题时使用mongodump产生的备份不一定是数据库的实时快照，如果我们在备份时对数据库进行了写入操作，则备份出来的文件可能不完全和Mongodb实时数据相等。另外在备份时可能会对其它客户端性能产生不利的影响。

mongodump用法

1
2
3
4
5
6
7
8
9
10
11
$ mongodump --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
-j, --numParallelCollections=  number of collections to dump in parallel (4 by default)
--oplog  备份的同时备份oplog

全库备份

1
2
3
mkdir -p /web/backup/mongodb
#备份所有数据库
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -o /web/backup/mongodb

单库备份

1
2
#备份amt库
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -o /web/backup/mongodb

集合备份

1
2
#备份amt库下user集合
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -c user -o /web/backup/mongodb

压缩备份

1
2
3
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -o /web/backup/mongodb --gzip
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -o /web/backup/mongodb --gzip
mongodump -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -c user -o /web/backup/mongodb --gzip

恢复amt库

1
mongorestore -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt  /web/backup/mongodb/amt

恢复amt库下的user集合

1
2
3
4
5
mongorestore -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt -c user --gzip /web/backup/mongodb/amt/user.bson.gz
#注意备份文件为压缩格式需要加 --gzip 不是则不用加

#drop表示恢复的时候把之前的集合drop掉(危险)
mongorestore -uadmin -p123456 --port 27017 --authenticationDatabase admin -d amt --drop  /web/backup/mongodb/amt

mongodump和mongorestore高级企业应用（–oplog）

1
2
3
注意：这是replica set或者master/slave模式专用
--oplog
use oplog for taking a point-in-time snapshot

介绍

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
在replica set中oplog是一个定容集合（capped collection），它的默认大小是磁盘空间的5%（可以通过--oplogSizeMB参数修改）.

位于local库的db.oplog.rs，有兴趣可以看看里面到底有些什么内容。
其中记录的是整个mongod实例一段时间内数据库的所有变更（插入/更新/删除）操作。
当空间用完时新记录自动覆盖最老的记录。
其覆盖范围被称作oplog时间窗口。需要注意的是，因为oplog是一个定容集合，
所以时间窗口能覆盖的范围会因为你单位时间内的更新次数不同而变化。
想要查看当前的oplog时间窗口预计值，可以使用以下命令：


mongod -f /web/soft/mongodb/27010/conf/mongod.conf
mongo --port 27010

use local 
repl:PRIMARY> show tables
me
oplog.rs
replset.election
replset.minvalid
replset.oplogTruncateAfterPoint
startup_log
system.replset
system.rollback.id

db.oplog.rs.find().pretty()
#事件发生时间戳
"ts" : Timestamp(1731310137, 1),
#动作
"op" : "n",
#"i": insert
#"u": update
#"d": delete
#"c": db cmd
#具体操作
"o" : {
		"msg" : "periodic noop"
	}

repl:PRIMARY> rs.printReplicationInfo()
#集合大小
configured oplog size:   2048MB
#预计窗口覆盖时间
log length start to end: 91710secs (25.48hrs)
oplog first event time:  Mon Nov 11 2024 15:26:15 GMT+0800 (CST)
oplog last event time:   Tue Nov 12 2024 16:54:45 GMT+0800 (CST)
now:                     Tue Nov 12 2024 16:54:46 GMT+0800 (CST)

oplog企业级应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1、实现热备，在备份时使用--oplog选项
注：为了演示效果我们在备份过程，模拟数据插入
2、准备测试数据
mongo --port 27010
use amt
for(var i = 1 ;i < 100; i++) {db.foo.insert({a:i});}

use local
repl:PRIMARY> db.oplog.rs.find({"op":"i"}).pretty()

#oplog 配合mongodump实现热备
mongodump --port 27010 --oplog -o /web/backup/mongodb/
#作用介绍：--oplog 会记录备份过程中的数据变化。会以oplog.bson保存下来
#恢复
mongorestore  --port 27010 --oplogReplay /web/backup/mongodb/

oplog高级应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
背景：每天0点全备，oplog恢复窗口为48小时
某天，上午10点amt.user 业务表被误删除。
恢复思路：
    0、停应用
    2、找测试库
    3、恢复昨天晚上全备
    4、截取全备之后到amt.user误删除时间点的oplog，并恢复到测试库
    5、将误删除表导出，恢复到生产库

恢复步骤：
模拟故障环境：

1、全备数据库
#模拟原始数据
mongo --port 27010
use amt
for(var i = 1 ;i < 100; i++) {db.user.insert({a: i});}

#全备:
rm -rf /web/backup/mongodb/*
mongodump --port 27010 --oplog -o /web/backup/mongodb

--oplog功能:在备份同时,将备份过程中产生的日志进行备份
文件必须存放在/web/backup/mongodb下,自动命令为oplog.bson

再次模拟数据
db.user.insert({id:1})
db.user.insert({id:2})


2、上午10点：删除wo库下的ci表
10:00时刻,误删除
db.user.drop()
show tables;

3、备份现有的oplog.rs表
mongodump --port 27010 -d local -c oplog.rs  -o /web/backup/mongodb

4、截取oplog并恢复到drop之前的位置
更合理的方法：登陆到原数据库
mongo --port 27010
 use local
db.oplog.rs.find({op:"c"}).pretty();
{
	"ts" : Timestamp(1731405032, 1),
	"t" : NumberLong(3),
	"h" : NumberLong("-2399337216496883561"),
	"v" : 2,
	"op" : "c",
	"ns" : "amt.$cmd",
	"ui" : UUID("2fbc47e9-a1d1-4ad1-941b-98a3c6f0aa48"),
	"wall" : ISODate("2024-11-12T09:50:32.955Z"),
	"o" : {
		"drop" : "user"
	}
}
获取到oplog误删除时间点位置:
"ts" : Timestamp(1731405032, 1)

 5、恢复备份+应用oplog
cd /web/backup/mongodb/local
ls
oplog.rs.bson  oplog.rs.metadata.json
cp oplog.rs.bson ../oplog.bson 
rm -rf /mongodb/backup/local/

mongorestore --port 27010 --oplogReplay --oplogLimit "1731405032:1" /web/backup/mongodb/

分片集群的备份思路

1
2
3
4
5
6
7
8
9
10
11
1、需要备份什么
config server
shard 节点

单独进行备份
2、备份有什么困难和问题
（1）chunk迁移的问题
    人为控制在备份的时候，避开迁移的时间窗口
（2）shard节点之间的数据不在同一时间点。
    选业务量较少的时候       
Ops Manager
MongoDB
#Linux #MongoDB #Sharding Cluster
MongoDB副本集+分片集群搭建
https://yftxhy.site/2024/11/12/MongoDB副本集+分片集群搭建/
作者
Taozi
发布于
2024年11月12日
许可协议