三、 MongoDB Sharding Cluster 分片集群

山河不入梦�

已于 2022-07-06 09:46:44 修改

阅读量686

点赞数

于 2021-04-15 08:50:45 首次发布

本文链接：https://blog.csdn.net/weixin_52847533/article/details/115678549

版权

MongoDB 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.分片集群说明

** 为什么分片？**

比如说有个非常大的表和几十亿的数据，另外除了几十亿数据量特别大以外用户访问量也特别大，针对表的级别。就需要进行逻辑化的操作。垂直水平。为了大数据的存储和访问所以分片。

在这里插入图片描述
分片集群由三大部分构成：
第一部分：
router(路由)，
mongos 需要1台机器

第二部分：

config server(配置节点，相当于路由的秘书)，记录着节点信息，和分步策略
config server 需要复制集所以至少需要3台机器一主两从

第三部分
shard(后端节点)
后端节点每个节点要设定复制集，一主两从所以至少要6台机

所有用户连接都会通过路由来连接，路由来分发请求，路由本身是无状态的（没脑子），用户数据插入，路由是没办法判断处理的
路由接收到用户数据插入请求，会读取配置节点里的信息，路由会通过配置节点里的信息得知数据应该放在哪个节点中。

二、分片集群的配置

规划：
10个实例：3807-38026
configserver:配置节点
3台构成的复制集（1主两从，不支持arbiter）38018-38020（复制集名字configsvr）
shard节点：
sh1：38021-23 （1主两从，其中一个节点为arbiter，复制集名字sh1）
sh2：38024-26 （1主两从，其中一个节点为arbiter，复制集名字sh2）

配置过程

1. 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

 // 修改配置文件

// sh1 第一个分片
 cat > /mongodb/38021/conf/mongodb.conf<<EOF 
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.52,127.0.0.1
  port: 38021
replication:
  oplogSizeMB: 2048
  replSetName: sh1
sharding:
  clusterRole: shardsvr
processManagement: 
  fork: true
EOF
cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38022/conf/
cp  /mongodb/38021/conf/mongodb.conf  /mongodb/38023/conf/
sed 's#38021#38022#g' /mongodb/38022/conf/mongodb.conf -i
sed 's#38021#38023#g' /mongodb/38023/conf/mongodb.conf -i

 // sh2 第二个分片
 cat > /mongodb/38024/conf/mongodb.conf<<EOF 
systemLog:
  destination: file
  path: /mongodb/38024/log/mongodb.log   
  logAppend: true
storage:
  journal:
    enabled: true
  dbPath: /mongodb/38024/data
  directoryPerDB: true
  wiredTiger:
    engineConfig:
      cacheSizeGB: 1
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zlib
    indexConfig:
      prefixCompression: true
net:
  bindIp: 10.0.0.52,127.0.0.1
  port: 38024
replication:
  oplogSizeMB: 2048
  replSetName: sh2
sharding:
  clusterRole: shardsvr
processManagement: 
  fork: true
EOF

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  



mongo --port 38021 admin

config = {_id: 'sh1', members: [
                          {_id: 0, host: '10.0.0.52:38021'},
                          {_id: 1, host: '10.0.0.52:38022'},
                          {_id: 2, host: '10.0.0.52:38023',"arbiterOnly":true}]
           }

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

2.config节点配置：

目录创建：

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

修改配置文件：

cat > /mongodb/38018/conf/mongodb.conf <<EOF
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.52,127.0.0.1
  port: 38018
replication:
  oplogSizeMB: 2048
  replSetName: configReplSet
sharding:
  clusterRole: configsvr
processManagement: 
  fork: true
EOF

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 

mongo --port 38018 admin
config = {_id: 'configReplSet', members: [
                          {_id: 0, host: '10.0.0.52:38018'},
                          {_id: 1, host: '10.0.0.52:38019'},
                          {_id: 2, host: '10.0.0.52:38020'}]
           }
rs.initiate(config)  
  
  
注：configserver 可以是一个节点，官方建议复制集。configserver不能有arbiter。
新版本中，要求必须是复制集。
注：mongodb 3.4之后，虽然要求config server为replica set，但是不支持arbiter

3.mongos节点配置：

创建目录：

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

配置文件：

cat >/mongodb/38017/conf/mongos.conf<<EOF
systemLog:
  destination: file
  path: /mongodb/38017/log/mongos.log
  logAppend: true
net:
  bindIp: 10.0.0.52,127.0.0.1
  port: 38017
sharding:
  configDB: configReplSet/10.0.0.52:38018,10.0.0.52:38019,10.0.0.52:38020
processManagement: 
  fork: true
EOF         
4.3启动mongos
mongos -f /mongodb/38017/conf/mongos.conf

4.分片集群操作：

连接到其中一个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();

在这里插入图片描述

文字说明：
分片集群由三大部分构成：
router(路由)，
mongos 需要1台机器

config server(配置节点，相当于路由的秘书)，记录着节点信息，和分步策略
config server 需要复制集所以需要3台机器  一主两从

shard(后端节点)
后端节点每个节点要设定复制集，一主量从  所以要6台机

1.所有用户连接都会通过路由来连接，路由来分发请求，路由本身是无状态的（没脑子），用户数据插入，路由是没办法判断处理的
2.路由接收到用户数据插入请求，会读取配置节点里的信息，路由会通过配置节点里的信息得知数据应该放在哪个节点中。

三、使用RANGE分片集群

RANGE分片配置及测试

test库下的vast大表进行手工分片

1. 激活数据库分片功能

mongo --port 38017 admin
admin>  ( { enablesharding : "数据库名称" } )

eg：
admin> db.runCommand( { enablesharding : "test" } )

2.指定分片键，对集合分片

eg：范围片键
--创建索引
use test
> db.vast.ensureIndex( { id: 1 } )

#--开启分片
use admin
> db.runCommand( { shardcollection : "test.vast",key : {id: 1} } )

3.集合分片验证

shard1:
mongo --port 38021
db.vast.count();

shard2:
mongo --port 38024
db.vast.count();

四、Hash分片例子：

1.对xiaoming库下的vast大表进行hash

创建哈希索引

（1）对于xiaoming开启分片功能
mongo --port 38017 admin
use admin
admin> db.runCommand( { enablesharding : "xiaoming" } )

（2）对于xiaoming库下的vast表建立hash索引
use xiaoming
oldboy> db.vast.ensureIndex( { id: "hashed" } )


（3）开启分片 
use admin
admin > sh.shardCollection( "oldboy.vast", { id: "hashed" } )

（4）录入10w行数据测试
use xiaoming
for(i=1;i<100000;i++){ db.vast.insert({"id":i,"name":"shenzheng","age":70,"date":new Date()}); }

（5）hash分片结果测试
mongo --port 38021
use xiaoming
db.vast.count();

mongo --port 38024
use xiaoming
db.vast.count();

2.对分片集群的查看信息

2.1、判断是否Shard集群
admin> db.runCommand({ isdbgrid : 1})

2.2、列出所有分片信息
admin> db.runCommand({ listshards : 1})

2.3、列出开启分片的数据库
admin> use config

config> db.databases.find( { "partitioned": true } )
或者：
config> db.databases.find() //列出所有数据库分片情况

2.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
}

#2.5、查看分片的详细信息
admin> db.printShardingStatus()
或
admin> sh.status()   *****



#2.6删除分片节点（谨慎）
（1）确认blancer是否在工作
sh.getBalancerState()
（2）删除shard2节点(谨慎)
mongos> db.runCommand( { removeShard: "shard2" } )
注意：删除操作一定会立即触发blancer。

3.balancer操作 *****

介绍：

mongos的一个重要功能，自动巡查所有shard节点上的chunk的情况，自动做chunk迁移。

什么时候工作？
1、自动运行，会检测系统不繁忙的时候做迁移
2、在做节点删除的时候，立即开始迁移工作消耗大
3、balancer只能在预设定的时间窗口内运行 *****

有需要时可以关闭和开启blancer（备份的时候）

mongos> sh.stopBalancer()
mongos> sh.startBalancer()

4.自定义自动平衡进行的时间段

https://docs.mongodb.com/manual/tutorial/manage-sharded-cluster-balancer/#schedule-the-balancing-window
// connect to mongos

 mongo --port 38017 admin
use config
sh.setBalancerState( true )
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、备份恢复工具介绍：

（1） mongoexport/mongoimport
（2） mongodump/mongorestore

2、备份工具区别在哪里？

2.1.

mongoexport/mongoimport 导入/导出的是JSON格式或者CSV格式
mongodump/mongorestore 导入/导出的是BSON格式。

2.2. JSON可读性强但体积较大，BSON则是二进制文件，体积小但对人类几乎没有可读性。

2.3. 在一些mongodb版本之间，BSON格式可能会随版本不同而有所不同，所以不同版本之间用mongodump/mongorestore可能不会成功，具体要看版本之间的兼容性。当无法使用BSON进行跨版本的数据迁移的时候，

使用JSON格式即mongoexport/mongoimport是一个可选项。
跨版本的mongodump/mongorestore个人并不推荐，实在要做请先检查文档看两个版本是否兼容（大部分时候是的）

2.4. JSON虽然具有较好的跨版本通用性，但其只保留了数据部分，不保留索引，账户等其他基础信息。使用时应该注意。

应用场景总结:
mongoexport/mongoimport:json csv
1、异构平台迁移 mysql <—> mongodb
2、同平台，跨大版本：mongodb 2 ----> mongodb 3*

日常备份恢复时使用.

mongodump/mongorestore

3.导出工具mongoexport

Mongodb中的mongoexport工具可以把一个collection导出成JSON格式或CSV格式的文件。
可以通过参数指定导出的数据项，也可以根据指定的条件导出数据。
（1）版本差异较大
（2）异构平台数据迁移

mongoexport具体用法如下所示：

$ mongoexport --help  
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导出那些列
-o:指明到要导出的文件名
-q:指明导出数据的过滤条件
--authenticationDatabase admin

3.1 单表备份至json格式

mongoexport -uroot -proot123 --port 27017 --authenticationDatabase admin -d misyang -c log -o /mongodb/log.json

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

3.2单表备份至csv格式

如果我们需要导出CSV格式的数据，则需要使用----type=csv参数：

 mongoexport -uroot -proot123 --port 27017 --authenticationDatabase admin -d misyang -c log --type=csv -f uid,name,age,date  -o /mongodb/log.csv

4.导入工具mongoimport

Mongodb中的mongoimport工具可以把一个特定格式文件中的内容导入到指定的collection中。该工具可以导入JSON格式数据，也可以导入CSV格式数据。具体使用如下所示：

$ mongoimport --help
参数说明：
-h:指明数据库宿主机的IP
-u:指明数据库的用户名
-p:指明数据库的密码
-d:指明数据库的名字
-c:指明collection的名字
-f:指明要导入那些列
-j, --numInsertionWorkers=<number>  number of insert operations to run concurrently                                                  (defaults to 1)
//并行

4.1数据恢复

#1.恢复json格式表数据到log1

mongoimport -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy -c log1 /mongodb/log.json


#2.恢复csv格式的文件到log2
上面演示的是导入JSON格式的文件中的内容，如果要导入CSV格式文件中的内容，则需要通过--type参数指定导入格式，具体如下所示：
错误的恢复

#注意：
（1）csv格式的文件头行，有列名字
mongoimport   -uroot -proot123 --port 27017 --authenticationDatabase admin   -d oldboy -c log2 --type=csv --headerline --file  /mongodb/log.csv

（2）csv格式的文件头行，没有列名字
mongoimport   -uroot -proot123 --port 27017 --authenticationDatabase admin   -d oldboy -c log3 --type=csv -f id,name,age,date --file  /mongodb/log1.csv

--headerline:指明第一行是列名，不需要导入。

在这里插入图片描述

4.2 异构平台迁移案例（项目）

mysql -----> mongodb
world数据库下city表进行导出，导入到mongodb

（1）mysql开启安全路径

vim /etc/my.cnf   --->添加以下配置
secure-file-priv=/tmp

--重启数据库生效
/etc/init.d/mysqld restart

（2）导出mysql的t100w表数据
source /root/t100w.sql

select * from t100w into outfile "/tmp/t100w.csv" fieldsterminated by ',';

#要给文件加上属主属组
chown mongod.mongod /tmp/t100w.csv 

(3)在mongodb中导入备份
mongoimport -uroot -proot123  --authenticationDatabase admin -d app  -c t100w --type=csv -f  id,num,k1,k2,dt  --file  /tmp/t100w.csv

要看下原mysql表中的列名，-f  id,num,k1,k2,dt 

use app
db.t100w.count()

-------------
world共100张表，全部迁移到mongodb

select * from world.city into outfile '/tmp/world_city.csv' fields terminated by ',';

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 ='world';

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

------------

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';

5.mongodump和mongorestore介绍

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

1. mongodump用法如下：

$ 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

2.mongodump和mongorestore基本使用

2.1 备份方式

# 全库备份
mkdir /mongodb/backup
mongodump  -uroot -proot123 --port 27017 --authenticationDatabase admin -o /mongodb/backup

#--单库备份
$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d world -o /mongodb/backup/

#--备份oldboy库下的log集合
$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy -c log -o /mongodb/backup/

# --压缩备份
$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldguo -o /mongodb/backup/ --gzip
 mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -o /mongodb/backup/ --gzip
$ mongodump   -uroot -proot123 --port 27017 --authenticationDatabase admin -d app -c vast -o /mongodb/backup/ --gzip

#--恢复world库
$ mongorestore   -uroot -proot123 --port 27017 --authenticationDatabase admin -d world1  /mongodb/backup/world

#--恢复oldguo库下的t1集合
[mongod@db03 oldboy]$ mongorestore   -uroot -proot123 --port 27017 --authenticationDatabase admin -d world -c t1  --gzip  /mongodb/backup.bak/oldboy/log1.bson.gz 

# --drop表示恢复的时候把之前的集合drop掉(危险)
$ mongorestore  -uroot -proot123 --port 27017 --authenticationDatabase admin -d oldboy --drop  /mongodb/backup/oldboy

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

注意：这是replica set或者master/slave模式专用

--oplog
 use oplog for taking a point-in-time snapshot
 
 #这个参数是mongodump备份时需要添加的，加完会基于时间点的快照备份，除了时间点备份以外，同时在备份期间会产生日志（oplog）.一并备走

7.1oplog介绍

在replica set中oplog是一个定容集合（capped collection），它的默认大小是磁盘空间的5%（可以通过–oplogSizeMB参数修改）.

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

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

use local 
 db.oplog.rs.find().pretty()  
 例：db.oplog.rs.find({"op":"i"}).pretty()
 
#重要信息
"ts" : Timestamp(1553597844, 1),
	"op" : "n"
	"o"  :

    "i": insert
    "u": update
    "d": delete
    "c": db cmd
	
------------
#记录oplod的空间和存在时间信息
test:PRIMARY> rs.printReplicationInfo()
configured oplog size:   1561.5615234375MB <--集合大小
log length start to end: 423849secs (117.74hrs) <--预计窗口覆盖时间
oplog first event time:  Wed Sep 09 2015 17:39:50 GMT+0800 (CST)
oplog last event time:   Mon Sep 14 2015 15:23:59 GMT+0800 (CST)
now:                     Mon Sep 14 2015 16:37:30 GMT+0800 (CST)


------------

7.2 oplog企业级应用

（1）实现热备，在备份时使用–oplog选项
注：为了演示效果我们在备份过程，模拟数据插入
（2）准备测试数据

use oldboy
for(var i = 1 ;i < 100; i++) {
    db.foo.insert({a:i});
}
my_repl:PRIMARY> db.oplog.rs.find({"op":"i"}).pretty()

7.3 oplog 配合mongodump实现热备

mongodump --port 28017 --oplog -o /mongodb/backup
作用介绍：--oplog 会记录备份过程中的数据变化。会以oplog.bson保存下来

恢复：
mongorestore  --port 28017 --oplogReplay /mongodb/backup

7.4 oplog高级应用 ==========binlog应用

背景：每天0点全备，oplog恢复窗口为48小时
某天，上午10点world.city 业务表被误删除。

恢复思路：
0、停应用
2、找测试库
3、恢复昨天晚上全备
4、截取全备之后到world.city误删除时间点的oplog，并恢复到测试库
5、将误删除表导出，恢复到生产库

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

1、全备数据库

模拟原始数据

mongo --port 28017
use vast
for(var i = 1 ;i < 100; i++) {
    db.ci.insert({a: i});
}

全备:


rm -rf /mongodb/backup/*

mongodump --port 28017 --oplog -o /mongodb/backup

--oplog功能:在备份同时,将备份过程中产生的日志进行备份

文件必须存放在/mongodb/backup下,自动命令为oplog.bson

再次模拟数据

db.ci1.insert({id:1})
db.ci2.insert({id:2})


2、上午10点：删除wo库下的ci表
10:00时刻,误删除

db.ci.drop()
show tables;

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

4、截取oplog并恢复到drop之前的位置
更合理的方法：登陆到原数据库
[mongod@db03 local]$ mongo --port 28017
my_repl:PRIMARY> use local
db.oplog.rs.find({op:"c"}).pretty();

{
	"ts" : Timestamp(1553659908, 1),
	"t" : NumberLong(2),
	"h" : NumberLong("-7439981700218302504"),
	"v" : 2,
	"op" : "c",
	"ns" : "wo.$cmd",
	"ui" : UUID("db70fa45-edde-4945-ade3-747224745725"),
	"wall" : ISODate("2019-03-27T04:11:48.890Z"),
	"o" : {
		"drop" : "ci"
	}
}

"ts" : Timestamp(1563958129, 1),

获取到oplog误删除时间点位置:
"ts" : Timestamp(1553659908, 1)
	
 5、恢复备份+应用oplog
[mongod@db03 backup]$ cd /mongodb/backup/local/
[mongod@db03 local]$ ls
oplog.rs.bson  oplog.rs.metadata.json
[mongod@db03 local]$ cp oplog.rs.bson ../oplog.bson 
rm -rf /mongodb/backup/local/
mongorestore --port 28018  --oplogReplay --oplogLimit "1563958129:1"  --drop   /mongodb/backup/

8.分片集群的备份思路（了解）

1、你要备份什么？
config server
shard 节点

单独进行备份
2、备份有什么困难和问题
（1）chunk迁移的问题
人为控制在备份的时候，避开迁移的时间窗口
（2）shard节点之间的数据不在同一时间点。
选业务量较少的时候

Ops Manager

山河不入梦�

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
三、 MongoDB Sharding Cluster 分片集群

一.分片集群说明** 为什么分片？**比如说有个非常大的表和几十亿的数据，另外除了几十亿数据量特别大以外用户访问量也特别大，针对表的级别。就需要进行逻辑化的操作。垂直水平。为了大数据的存储和访问所以分片。分片集群由三大部分构成：第一部分：router(路由)，mongos 需要1台机器第二部分：config server(配置节点，相当于路由的秘书)，记录着节点信息，和分步策略config server 需要复制集所以至少需要3台机器一主两从第三部分shard(后端节点)后端
复制链接

扫一扫