分类 数据库 下的文章

mongodb 复制集 维护小结(转)

副本集成员最多12个成员,其中只有7个成员拥有投票权。这是为了减少 心跳请求的网络流量和选举话费的时间。心跳每2秒发送一次。

一、新增副本集成员

1、登录primary
2、use admin >rs.add("new_node:port") 或 rs.add({"_id":4,"host":"new_node:port","priority":1,"hidden":false})
3、use admin>rs.addArb("new_node;port") 或 rs.addArb({"_id":5,"host":"new_node:port"})或rs.add({'_id':5,"host":"new_node:port","arbiterOnly":true})
仲裁者唯一的作用就是参与选举,仲裁者并不保存数据,也不会为客户端提供服务。成员一旦以仲裁者的身份加入副本集中,它就永远只能是仲裁者,无法将仲裁者
重新配置为非仲裁者,反之亦然。最多只能有一个仲裁者每个副本集中。
注:如果 复制集中 priority=1 (默认),调用rs.add("new_node:port") 该命令 会产生 主从切换 即选举操作;
如果 复制集中 priority=1 (默认),直接调用rs.remove("new_node:port") 该命令 也会产生 主从切换 ;

二、删除副本集成员

1、登录要移除的目标mongodb实例;
2、利用shutdownServer()命令关闭实例;即 db.shutdownServer()
3、登录复制集的primary;
4、primary>use admin
primary>rs.remove("del_node:port");

三、修改成员的优先级及隐藏性

1、登录primary
2、use admin >conf=rs.conf()
mongo>conf.members[1].priority=[0-1000]
mongo>conf.members[1].hidden=true #priority必须为0
mongo>conf.members[9].tags={"dc":"tags_name1"}
mongo>rs.reconfig(conf); # 强制重新配置 rs.reconfig(conf,{"force":true})
成员的属性有下列选项
[, arbiterOnly : true]
[, buildIndexes : ]
[, hidden : true]
[, priority: ]
[, tags: {loc1 : desc1, loc2 : desc2, ..., locN : descN}]
[, slaveDelay : ]#秒为单位。
[, votes : ]
如果该成员要设置为 隐藏(hidden:true) 或延迟(slaveDelay:30) 则其优先级priority必须设置为 0;
也就是说 隐藏成员和延迟成员及buildIndexs:false的成员 的优先级别一定必须是0 即priority=0.
优先级为0的成员不能发起选举操作。
只要优先级>0即使该成员不具有投票资格,也可以成为主节点。
如果某个节点的索引结构和其他节点上的索引结构不一致,则该节点就永远不会变为主节点。
优先级用于表示一个成员渴望成为主节点的程度。优先级的取值范围是[0-100],默认为1。优先级为0的成员永远不能成为主节点。
使用rs.status()和rs.config()能够看到隐藏成员,隐藏成员只对rs.isMaster()不可见。客户端连接到副本集时,会调用rs.isMaster()
来查看可用成员。将隐藏成员设定为非隐藏成员,只需将配置中的hidden设定为false,或删除hidden选项。
每个成员可以拥有多个标签tags {“dc":"tags_name2",qty:"tag_name3"}
votes:0 代表阻止这些成员在选举中投主动票,但是他们仍然可以投否决票。

修改副本集成员配置时的限制:
1、不能修改_id;
2、不能讲接收rs.reconfig命令的成员的优先级设置为 0;
3、不能将仲裁者成员变为非仲裁者成员,反正亦然;
4、不能讲 buildIndexes:false 改为 true;

四、查看副本集成员数据同步(延迟)情况

mongo>db.printReplicationInfo();
mongo>db.printSlaveReplicationInfo();#最好在secondary上执行
mongo>rs.printReplicationInfo()
mongo>rs.printSlaveReplicationInfo()
mongo>use local>db.slaves.find()
在主节点上跟踪延迟:
local.slaves该集合保存着所有正从当前成员进行数据同步的成员,以及每个成员的数据新旧程度。
登录主节点

use local
db.slaves.find()、
查看其中每个成员对应的"syncedTo":{"t":9999999,"i":32} 部分即可知道数据的同步程度。
"_id"字段的值是每个当前成员服务器标识符。可以到每个成员的local.me.find()查看本服务器标识符。
1、
如果多台服务器拥有相同的_id标识符,则依次登录每台服务器成员,删除local.me集合(local.me.dorp()),然后重启mongodb,
重启mongod后,mongod会使用新的“_id”重新生成local.me集合。

2、如果服务器的地址改变但_id没有变,主机名变了,该情况会在本地数据库的日志中看到重复键异常(duplicate key exception)。
解决方法是:删除local.slaves集合即可,不需要重启mongod。

因为mongod不会清理local.slaves集合,故里面的数据可能不准确或过于老旧,可将整个集合删除。当有新的服务器将当前成员作为
复制源时,该集合会重新生成。如果在主节点中看到了某个特定的服务器在该集合中有多个文档,即表示备份节点之间发生了复制链,
该情况不影响数据同步,只是把每个备份节点的同步源告诉主节点。

删除local.me集合,需要重新启动mongod,mongod启动时会使用新的 _id重新生成local.me集合。

删除local.slaves集合,不用重启mongod。该集合中的数据是记录该成员被作为同步源的服务器的数据。该集合用于报告副本集状态。
删除后不久如果有新的节点成员将该服务器节点作为复制源,该集合就会重新生成。

五、主节点降为secondary
mongo>use admin
mongo>rs.stepDown(60)#单位为 秒

六、锁定指定节点在指定时间内不能成为主节点(阻止选举)
mongo>rs.freeze(120)#单位为 秒
释放阻止
mongo>rs.freeze(0)

七、强制节点进入维护模式(recovering)
可以通过执行replSetMaintenanceMode命令强制一个成员进入维护模式。
例如自动检测成员落后主节点指定时间,则将其转入维护模式:
function maybeMaintenanceMode(){
var local=db.getSisterDB("local");
if (!local.isMaster().secondary)
{return;
)
var last=local.oplog.rs.find().sort({"$natural":-1}).next();
var lasttime=last['ts']['t'];
if (lasttime<(new date()).getTime()-30)
{db.adminCommand({"replSetMaintenanceMode":true});
}
};
将成员从维护模式转入正常模式。即恢复:
db.adminCommand({"replSetMaintenanceMode":false});

八、阻止创建索引(不可再修改为可以创建索引,故慎重考虑)
通常会在备份节点的延迟节点上设置阻止创建索引。因为该节点通常只是起到备份数据作用。设置选项 buildIndexs:false即可。该选项是永久性的。如果要将不创建索引的成员修改为可以创建索引的成员,那么必须将这个成员从副本集中移除,再删除它上的所有数据,最后再将其重新添加到副本集中。并且允许其重新进行数据同步。该选项也要求成员的优先级为 0.

九、指定复制源(复制链) 查看复制图谱
使用db.adminCommand({"replSetGetStatus":1})['syncingTo'] 可以查看复制图谱(每个节点的同步源);
在备份节点上执行 rs.status()['sysncingTo'] 同样可以查看复制图谱(同步源);
mongodb是根据ping时间来选择同步源的,会选择一个离自己最近而且数据比自己新的成员作为同步源。
可以使用replSetSyncFrom 命令来指定复制源或使用辅助函数rs.sysncFrom()来修改复制源。
db.adminCommand({"replSetSyncFrom":"server_name:port"});

副本集默认情况下是允许复制链存在的,因为这样可以减少网络流量。但也有可能
花费是时间更长,因为复制链越长,将数据同步到全部服务器的时间有可能就越长(比如每个备份节点都比前一个备份节点稍微旧点,这样就得
从主节点复制数据)。
解决方法:
1、手动改变复制源
登录备份节点:use admin
db.adminCommand({"replSetSyncFrom":"新复制源"})

rs.syncFrom("新复制源")
副本集中的成员会自动选择其他成员作为复制源。这样就会产生复制链。
如果一个备份节点从另一个备份节点(而非主节点)复制数据时,就会形成复制链。
复制链是可以被禁用的,这样就可以强制要求所有备份节点都从主节点复制数据。

禁用复制链:即禁止备份节点从另一个备份节点复制数据。
var config=rs.config()
config.settings=config.settings ||{}
config.settings.chainingAllowed=false
rs.reconfig(config);

十、强制修改副本集成员
var config=rs.config()
config.member[n].host=...
config.member[n].priority=...
.....
rs.reconfig(config,{"force":true})

十一、修改Oplog集合的大小

如果是主节点,则先将primary 降为 secondary。最后确保没有其他secondary 从该节点复制数据。rs.status()
1、关闭该mongod服务 use admin >db.adminCommand({shutdownServer:1});
2、以单机方式重启该mongod(注释掉 配置文件中的 replSet shardsvr ,修改端口号)
3、将local.oplog.rs中的最后一条 insert 操作记录保存到临时集合中
mongo> use local
mongo>var cursor=db.oplog.rs.find({"op":"i"});
mongo>var lastinsert=cursor.sort({$natural:-1}).limit(1).next();
mongo>db.templastop.save(lastinsert);
mongo>db.templastop.findOne()#确保写入
4、将oplog.rs 删除: db.oplog.rs.drop();
5、创建一个新的oplog.rs集合: db.createCollection("oplog.rs":{"capped":true,"size":10240});
6、将临时集合中的最后一条insert操作记录写回新创建的oplog.rs:
var temp=db.templastop.findOne();
db.oplog.rs.insert(temp);
db.oplog.rs.findOne()#确保写回,否则 该节点重新加入副本集后会删除该节点上所有数据,然后重新同步所有数据。
7、最后将该节点以副本集成员的身份重新启动即可。

十二、为复制集成员设置选项

即当运行rs.initiate(replSetcfg) 或运行 rs.add(membercfg)选项时,需要提供描述复制集成员的特定配置结构:
{
_id:replSetName,
members:
[
{_id:,host:<hostname|ip[:port]>,
[priority:,]#默认值为1.0.即选项的值是浮点型
[hidden:true,]#该元素将从db.isMaster()的输出中隐藏该节点。
[arbiterOnly:true,]#默认值为 false
[votes:,]#默认值为1 。改选项的值为整形
[tags:{documents},]
[slaveDelay:,]
[buildIndexes:true,]#默认值为 false。该选项用于禁止创建索引。
}],
settings:{
[chainingAllowed:,]#指定该成员是否允许从其他辅助服务器复制数据。默认值为 true
[getLastErrorModes:,]#模式:用于自定义写顾虑设置
[getLastErrorDefaults:,]#默认值:用于自定义写顾虑设置。
}
}
以上是复制集的完整的配置结构。最高级的配置结构包括3级:
_id、members、settings。
_id是复制集的名称,与创建复制集成员时时候用的 --replSet命令选项时提供的名称一样。
members是数组,由一个描述每个成员的集合组成;这是添加单个服务器到集合中时,应该在rs.add()命令中提供的成员机构;
settings也是数组,该settings数组包含应用到整个复制集的选项。这些选项可以设置复制集成员间如何通信。

十三、Rollback
mongodb只支持小于300M的数据量回滚,如果大于300M的数据需要回滚或要回滚的操作在30分钟以上,只能是手动去回滚。会在mongodb日志中报以下错误:[replica set sync] replSet syncThread: 13410 replSet too much data to roll back
经量避免让rollback发生。方法是:使用 复制的 写顾虑(Write Concern)规则来阻止回滚的发生。
如果发生了回滚操作,则会在mongodb数据文件目录下产生一个以database.collection.timestamp.bson的文件。查看该文件的内容用 bsondump 工具来查看。

十四、读偏好设置(ReadPreferred)
读取偏好是指选择从哪个复制集成员读取数据的方式。可以为驱动指定5中模式来设置读取偏好。
readPreference=primary|primaryPreferred|secondary|secondaryPreferred|nearest
setReadPreferred()命令设置读取偏好。

primary:只从主服务器上读取数据。如果用户显式指定使用标签读取偏好,该读取偏好将被阻塞。这也是默认的读取偏好。
primaryPreferred:读取将被重定向至主服务器;如果没有可用的主服务器,那么读取将被重定向至某个辅助服务器;
secondary:读取将被重定向至辅助服务器节点。如果没有辅助服务器节点,该选项将会产生异常;
secondaryPreferred:读取将被重定向至辅助服务器;如果没有辅助服务器,那么读取将被重定向至主服务器。该选项对应旧的“slaveOK”方法;
nearest:从最近的节点读取数据,不论它是主服务器还是辅助服务器。该选项通过网络延迟决定使用哪个节点服务器。

十五、写顾虑设置(Write Concern)
写顾虑类似读取偏好,通过写顾虑选项可以指定在写操作被确认完成前,数据必须被安全提交到多少个节点。
写顾虑的模式决定了写操作时如何持久化数据。参数“w”会强制 getLastError等待,一直到给定数据的成员都执行完了最后的写入操作。w的值是包含主节点的。
写顾虑的5中模式:
w=0或不确定:单向写操作。写操作执行后,不需要确认提交状态。
w=1或确认:写操作必须等到主服务器的确认。这是默认行为。
w=n或复制集确认:主服务器必须确认该写操作。并且n-1个成员必须从主服务器复制该写入操作。该选项更强大,但是会引起延迟。
w=majority:写操作必须被主服务器确认,同时也需要集合中的大多数成员都确认该操作。而w=n可能会因为系统中断或复制延迟引起问题。
j=true日志:可以与w=写顾虑一起共同指定写入操作必须被写入到日志中,只有这样才算是确认完成。
wtimeout:避免getLastError一直等待下去,该值是命令的超时时间值,如果超过这个时间还没有返回,就会返回失败。该值的单位是毫秒。如果返回失败,值在规定的时间内没有将写入操作复制到"w"个成员。
该操作只对该连接起作用,其他连接不受该连接的"w"值限制。
db.products.insert(
{ item : "envelopes" , qty : 100 , type : "Clasp" },
{ writeConcern : { w : 2 , wtimeout : 5000 } }
)
wtimeout#代表5秒超时

修改默认写顾虑
cfg = rs.conf()
cfg.settings = {}
cfg.settings.getLastErrorDefaults = { w: "majority" , wtimeout: 5000 }
rs.reconfig(cfg)

设置写等待
db.runCommand({"getLastError":1,w:"majority"})

db.runCommand({"getLastError":1,"w":"majority","wtimeout":10000})
即,表示写入操作被复制到了多数个节点上(majority 或 数字),这时的 w会强制 getLastError等待,一直到给定数量的成员执行完了最后的写入操作。而wtimeout是指超过这个时间没有返回则返回失败提示(即无法在指定时间内将写入操作复制到w个成员中),getLastError并不代表写操作失败了,而是代表在指定给定wtimeout时间内没有将写入操作复制到指定的w个成员中。w是限制(控制)写入 速度,只会阻塞这个连接上的操作,其他连接上的操作不受影响。

十六、读取偏好和写顾虑中使用标签(tags)

十七、选举机制
1、自身是否能够与主节点连通;
2、希望被选件为主节点的备份节点的数据是否最新;
3、有没有其他更高优先级的成员可以被选举为主节点;
4、如果被选举为主节点的成员能够得到副本集中“大多数”成员的投票,则它会成为主节点,如果“大多数”成员中只有一个否决了本次选举,则本次选举失败即就会取消。一张否决票相当于10000张赞成票。
5、希望成为主节点的成员必须使用复制将自己的数据更新为最新;

十八、数据初始化过程
1、首先做一些记录前的准备工作:选择一个成员作为同步源,在local.me集合中为自己创建一个标识符,删除索引已存在的数据库,以一个全新的状态开始进行同步;该过程中,所有的数据都会被删除。
2、然后克隆,就是将同步源的所有记录全部复制到本地。
3、然后就进入oplog同步的第一步,克隆过程中的所有操作都会被记录到oplog中。
4、接下来就是oplog同步过程的第二步,用于将第一个oplog同步中的操作记录下来。
5、截止当前,本地的数据应该与主节点在某个时间点的数据集完全一致了,可以开始创建索引了。
6、若当前节点的数据仍然落后同步源,那么oplog同步过程的最后一步就是将创建索引期间的所有操作全部同步过出来,防止该成员成为备份节点。
7、现在当前成员已经完成了初始化数据的同步,切换到普通状态,这时该节点就可以成为备份节点了。

十九、mongodb3.0 建议开启的设置
echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag
执行上面两命令后只是当前起作用。如果重启mongod服务后 就失效。永久起效则
写入到 /etc/rc.local

二十、修改服务器hostname名
1、首先修改 secondary 服务器的 hostname;然后 stop secondary;
2、重启 secondary 以修改后的新hostname;
3、登录 primary ;
4、用rs.reconfig()命令修改 复制集的配置信息;
conf=rs.conf()
conf.members[x].host='new_address:27017'
rs.reconfig(conf);

二十一、生成 keyfile文件

openssl rand -base64 666 > /opt/mongo/conf/MongoReplSet_KeyFile
chown mongod.mongod /opt/mongo/conf/MongoReplSet_KeyFile
chmod 600 /opt/mongo/conf/MongoReplSet_KeyFile

搭建MongoDB复制集

主节点:

28001.conf

port=28001
bind_ip=192.168.0.1
logpath=/usr/local/mongodb/log/28001.log
dbpath=/usr/local/mongodb/data/28001/
logappend=true
pidfilepath=/usr/local/mongodb/data/28001/28001.pid
fork=true
oplogSize=1024
replSet=RS0

28002.conf

port=28002
bind_ip=192.168.0.2
logpath=/usr/local/mongodb/log/28002.log
dbpath=/usr/local/mongodb/data/28002/
logappend=true
pidfilepath=/usr/local/mongodb/data/28002/28002.pid
fork=true
oplogSize=1024
replSet=RS0

28003.conf arbiter投票节点

port=28003
bind_ip=192.168.0.3
logpath=/usr/local/mongodb/log/28003.log
dbpath=/usr/local/mongodb/data/28003/
logappend=true
pidfilepath=/usr/local/mongodb/data/28003/28003.pid
fork=true
oplogSize=1024
replSet=RS0

启动实例:

mongod -f /usr/local/mongodb/conf/28001.conf

mongod -f /usr/local/mongodb/conf/28002.conf

mongod -f /usr/local/mongodb/conf/28003.conf

配置:
mongo 192.168.0.1:28001/admin

config = {
    _id: "RS0",
    members: [
        {_id: 0, host: "192.168.0.1:28001"},
        {_id: 1, host: "192.168.0.2:28002"},
        {_id: 2, host: "192.168.0.3:28003"},
    ]
}

// 设置 arbiter 节点
config.members[2] = {"_id": 2, "host": "192.168.0.3:28003", "arbiterOnly": true}

rs.initiate(config)  //初始化
rs.status //查看状态

redis、memcache、mongoDB有哪些区别?

Memcached

Memcached的优点

Memcached可以利用多核优势,单实例吞吐量极高,可以达到几十万QPS(取决于key、value的字节大小以及服务器硬件性能,日常环境中QPS高峰大约在4-6w左右)。适用于最大程度扛量。

支持直接配置为session handle。

坑少。

Memcached的局限性

只支持简单的key/value数据结构,不像Redis可以支持丰富的数据类型。
无法进行持久化,数据不能备份,只能用于缓存使用,且重启后数据全部丢失。

无法进行数据同步,不能将MC中的数据迁移到其他MC实例中。

Memcached内存分配采用Slab Allocation机制管理内存,value大小分布差异较大时会造成内存利用率降低,并引发低利用率时依然出现踢出等问题。需要用户注重value设计。

Redis
Redis的优点
支持多种数据结构,如 string(字符串)、 list(双向链表)、dict(hash表)、set(集合)、zset(排序set)、hyperloglog(基数估算)

支持持久化操作,可以进行aof及rdb数据持久化到磁盘,从而进行数据备份或数据恢复等操作,较好的防止数据丢失的手段。

支持通过Replication进行数据复制,通过master-slave机制,可以实时进行数据的同步复制,支持多级复制和增量复制,master-slave机制是Redis进行HA的重要手段。

单线程请求,所有命令串行执行,并发情况下不需要考虑数据一致性问题。

支持pub/sub消息订阅机制,可以用来进行消息订阅与通知。

支持简单的事务需求,但业界使用场景很少,并不成熟。

Redis的局限性
Redis只能使用单线程,性能受限于CPU性能,故单实例CPU最高才可能达到5-6wQPS每秒(取决于数据结构,数据大小以及服务器硬件性能,日常环境中QPS高峰大约在1-2w左右)。

支持简单的事务需求,但业界使用场景很少,并不成熟,既是优点也是缺点。

Redis在string类型上会消耗较多内存,可以使用dict(hash表)压缩存储以降低内存耗用。

补充
Mc和Redis都是Key-Value类型,不适合在不同数据集之间建立关系,也不适合进行查询搜索。比如redis的keys pattern这种匹配操作,对redis的性能是灾难。

Mogodb
mogodb是一种文档性的数据库。先解释一下文档的数据库,即可以存放xml、json、bson类型系那个的数据。这些数据具备自述性(self-describing),呈现分层的树状数据结构。redis可以用hash存放简单关系型数据。
mogodb存放json格式数据。

适合场景:事件记录、内容管理或者博客平台,比如评论系统。

nosql的产品目前很多,架构师的选择导向主要有以下两个因素:

1)适合应用程序的使用场景,比如评论系统用比较适合使用mogodb,而mc也可以实现(应用程序把数据转化成json存入,但是部分数据更新不方便)

2)团队开发比较熟悉的技术,比如一个团队一直在使用mc,因而有限选择mc,而不是redis。
还有中严重的状况,开发团队一直使用mogodb,在适合kv nosq的场景下而继续选择mogodb。

Mysql备份和恢复的一种可行方案---Xtrabackup(转)

这几天使用Xtrabackup实现了下mysql的全库备份和恢复,这里和大家分享下实现的思路。

关于Xtrabackup(又或innobackupex)的介绍这里就不啰嗦了,感兴趣的同学请移步官方文档,这里只要知道它提供了mysql备份和恢复的功能就可以了。

备份思路

Xtrabackup提供了全量备份和增量备份两种方式,全量就不解释了,增量是指其可以只备份指定位置后的新增数据。本文介绍的增量备份方法使用到了LSN(Log Sequence Number),可以从备份成功文件夹的xtrabackup_checkpoints文件中获取,其中to_lsn就是下次增量备份的起始位置。
结合两者,我们可以得到下图的备份思路。
1.jpg

解释如下:

由于全量备份和增量备份的命令参数不同,所以首先要判断是否需要全量备份。

如果是全量备份,那么便执行命令,备份成功后,记录xtrabackup_checkpoints文件中的to_lsn,以便后面进行增量备份。

如果是增量备份,那么首先读取上次备份时记录下的to_lsn,如果读取失败,报错并结束。否则执行相应命令,备份成功后记录to_lsn

一个简单的实现脚本,我们叫它backup.sh,如下所示:

#!/bin/sh

# xtrabackup的相关配置
INNOBACKUPEX="innobackupex "
MY_CNF="/home/config/mysql/3307.backup.cnf"
MY_USER="xtrabackup"
MY_PASSWORD="xtrabackup"
MY_SOCKET="/home/socket/mysql/3307.sock"

# 远程备份机 文件名配置
REMOTE_HOST="dbbackup"
REMOTE_DIR="/home/backup/mysql/test"
LOCAL_LSN_FILE="~/.to_lsn_important"
DATE_NAME=`date +%Y-%m-%d-%H-%M-%S`
REMOTE_FILE=$DATE_NAME.tar.gz
LOCK_FILE="~/.mysql.backup.lock"
LOCAL_BACKUP_DIR="/home/backup/mysql/test/$DATE_NAME"

# 输出帮助信息
function usage()
{
    echo "Usage:"
    echo "-f db will be backuped fully with this parameter. If not , incrementally. "
}

#防止同时执行两个备份命令,发生冲突
if [ -f $LOCK_FILE ] ;then
    echo 'Mysql backup lockfile is locked!'
    exit 0
fi

full=0

while getopts "fh" arg #选项后面的冒号表示该选项需要参数
do
    case $arg in
        f)  
            full=1
            ;;
        h)  # 输出帮助信息
            usage
            exit 0
            ;;
    esac
done

echo "backup dir is $REMOTE_DIR/$REMOTE_FILE"

# backup up db to remote host
echo "start to backup db!"`date +%Y-%m-%d-%H-%M-%S`
if [ "$full"x = "1"x ] ;then
    # 全量备份
    echo '1' > $LOCK_FILE
    $INNOBACKUPEX --defaults-file=$MY_CNF --user=$MY_USER --password=$MY_PASSWORD --socket=$MY_SOCKET ./ --stream=tar | gzip | ssh $REMOTE_HOST "cat - > $REMOTE_DIR/FULL-$REMOTE_FILE"
    ssh $REMOTE_HOST "cd $REMOTE_DIR;rm -f xtrabackup_checkpoints;tar zxfi $REMOTE_DIR/FULL-$REMOTE_FILE xtrabackup_checkpoints "
    toLSN=$( ssh $REMOTE_HOST "cat $REMOTE_DIR/xtrabackup_checkpoints|grep to_lsn|awk -F= '{gsub(/ /,\"\",\$2);print \$2}'" )
    if [ $toLSN ] ;then
        echo $toLSN > $LOCAL_LSN_FILE
    else
        echo 'no lsn from remote host!please check!'
    fi
else
    # 增量备份
    if [ -f $LOCAL_LSN_FILE ] ;then
        toLSN=`cat $LOCAL_LSN_FILE`
    fi

    if [ ! $toLSN ] ;then
        echo 'last LSN is not set !please check!'
        exit 0
    fi

    echo '1' > $LOCK_FILE
    mkdir -p $LOCAL_BACKUP_DIR
    echo "last to lsn is "$toLSN
    $INNOBACKUPEX --parallel=6 --defaults-file=$MY_CNF --user=$MY_USER --password=$MY_PASSWORD --socket=$MY_SOCKET --incremental --incremental-lsn=$toLSN $LOCAL_BACKUP_DIR 2>/tmp/innobackexLog
    toLSN=$( cd $LOCAL_BACKUP_DIR/*; cat xtrabackup_checkpoints|grep to_lsn|awk -F= '{gsub(/ /,"",$2);print $2}' )
    echo "new to lsn is "$toLSN;
    if [ $toLSN ] ;then
        echo $toLSN > $LOCAL_LSN_FILE
        cd $LOCAL_BACKUP_DIR/*;tar zc .|ssh $REMOTE_HOST "cat - > $REMOTE_DIR/$REMOTE_FILE"
        echo "save file to $REMOTE_HOST @ $REMOTE_DIR/$REMOTE_FILE"
    else
        echo 'no lsn from local backup file!delete remote backup file!'$LOCAL_BACKUP_DIR/$REMOTE_FILE
    fi
    echo "remove $LOCAL_BACKUP_DIR"
    rm -rf $LOCAL_BACKUP_DIR
fi

rm -f $LOCK_FILE
echo "end to backup db!"`date +%Y-%m-%d-%H-%M-%S`

将上述脚本配置好后,放到mysql主机上,执行 sh backup.sh -f进行全量备份,之后将sh backup.sh添加到crontab中每小时增量备份一次就可以了。

注意--parallel=6使用是有条件的,参见文档。

下面是备份文件夹的效果图。
2.png

恢复思路

一旦线上数据库发生宕机之类的灾难性事故,备份数据就要立马发挥作用了。所谓养兵千日,用兵一时。打开备份文件夹一看,如上面的图,每小时一个压缩文件,时间久了,茫茫多,上百个压缩文件,简直是一定的,这必须得来个脚本自动化恢复数据才成。思路很简单,见下图:
3.jpg

解释如下:

先解压,没啥说的。
找到全量备份的数据,因为增量备份也是以此为基准进行的。上面备份的时候,全量备份文件命名以FULL开头便是为了此处便于查找。
先恢复全量备份数据,然后按照时间顺序恢复增量备份的数据。
将数据恢复到mysql中
启动mysql,连上看看有没问题。
一个简单的实现脚本,我们叫它restore.sh,如下所示:

#!/bin/sh
BACK_DIR="/home/backup/mysql/test"
RESTORE_DIR="/home/tmpback/test"

# xtrabackup恢复时使用的配置文件可能与数据库配置文件不同
RESTORE_MY_CNF="/home/config/mysql/3307.backup.cnf"

# 启动mysql需要的配置文件,按需设定
MY_CNF="/home/config/mysql/3307.cnf"
MY_DATA_DIR="/home/data/mysql/3307"
MY_SOCK_DIR="/home/socket/mysql/"
MY_LOG_DIR="/home/logs/mysqld/3307"

#extract all tar file
fullFileName=""
for file in $( ls $BACK_DIR | grep "tar.gz" )
do
    fileName=${file%.tar.gz}
    full=${file%%-*}
    if [ "${full}"x = "FULL"x ] ;then
        fullFileName=$fileName
    fi
    DEST_DIR="$RESTORE_DIR/$fileName"
    if [ -d $DEST_DIR ] ;then
        echo "$DEST_DIR exists!"
    else
        mkdir -p $DEST_DIR
        echo "start to extract file $file to $DEST_DIR"
        tar zxif $BACK_DIR/$file -C $RESTORE_DIR/$fileName
        echo "end to extract file "$file
    fi
done

echo "full backup dir is "$fullFileName

echo "**start to repare full backup dir"

 # 恢复全量数据
echo "innobackupex --apply-log --redo-only --use-memory=4G $RESTORE_DIR/$fullFileName"
innobackupex --apply-log --redo-only --use-memory=4G "$RESTORE_DIR/$fullFileName"

echo "**end to repare full backup dir"

 # 恢复增量数据
for file in $( ls $RESTORE_DIR|grep -v "FULL" )
do
    echo "**start to repare $file"
    echo "innobackupex --apply-log --redo-only --use-memory=4G $RESTORE_DIR/$fullFileName --incremental-dir=$RESTORE_DIR/$file"
    innobackupex --apply-log --redo-only --use-memory=4G "$RESTORE_DIR/$fullFileName" --incremental-dir="$RESTORE_DIR/$file"

    echo "**end to repare $file"

done

echo "**start to copy back data to mysql"
rm -rf $MY_DATA_DIR
mkdir $MY_DATA_DIR
mkdir $MY_SOCK_DIR
mkdir $MY_LOG_DIR

 #将数据恢复到mysql中
echo "innobackupex --defaults-file=$RESTORE_MY_CNF --copy-back $RESTORE_DIR/$fullFileName"
innobackupex --defaults-file=$RESTORE_MY_CNF --copy-back $RESTORE_DIR/$fullFileName
echo "**end to copy back data to mysql"

chown -R mysql:mysql $MY_DATA_DIR
chown -R mysql:mysql $MY_SOCK_DIR
chown -R mysql:mysql $MY_LOG_DIR

echo "All data has been restored! Try to start mysql now"

echo "mysqld_multi --defaults-file=$MY_CNF start 1"

使用方法很简单,配置好后,直接运行sh restore.sh就可以了。

sql之left join、right join、inner join的区别

  今天和某朋友聊天,谈到他们公司的一个小问题。如下:

表A设备表,存储MAC地址,省份,城市,区。

表B软件表,存储MAC地址,软件名字。

功能是可以按省份,城市,或者区来查询软件列表。

你猜它现在如何做的?

它通过省份,城市,或者区取得MAC地址,然后查询B表用in查询。

这个很明显是不合理的,处理这种多对多的关系,为什么不用多表联查呢?

链表的方法常用的有3个: (inner) join 内部等值连接、left join 左连接 和 right join右连接。

有什么区别呢?怎么用呢? 下面是copy的一篇文章:

left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录

right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录

inner join(等值连接) 只返回两个表中联结字段相等的行

举例如下:

表A记录如下:

aID     aNum

1     a20050111

2     a20050112

3     a20050113

4     a20050114

5     a20050115

表B记录如下:

bID     bName

1     2006032401

2     2006032402

3     2006032403

4     2006032404

8     2006032408


1.left join

sql语句如下:

select * from A left join B on A.aID = B.bID

结果如下:

aID     aNum     bID     bName

1     a20050111    1     2006032401

2     a20050112    2     2006032402

3     a20050113    3     2006032403

4     a20050114    4     2006032404

5     a20050115    NULL     NULL

(所影响的行数为 5 行)

结果说明:

left join是以A表的记录为基础的,A可以看成左表,B可以看成右表,left join是以左表为准的.

换句话说,左表(A)的记录将会全部表示出来,而右表(B)只会显示符合搜索条件的记录(例子中为: A.aID = B.bID).

B表记录不足的地方均为NULL.

2.right join

sql语句如下:

select * from A right join B on A.aID = B.bID

结果如下:

aID     aNum     bID     bName

1     a20050111    1     2006032401

2     a20050112    2     2006032402

3     a20050113    3     2006032403

4     a20050114    4     2006032404

NULL     NULL     8     2006032408

(所影响的行数为 5 行)

结果说明:

仔细观察一下,就会发现,和left join的结果刚好相反,这次是以右表(B)为基础的,A表不足的地方用NULL填充.

3.inner join

sql语句如下:

select * from A innerjoin B on A.aID = B.bID

结果如下:

aID     aNum     bID     bName

1     a20050111    1     2006032401

2     a20050112    2     2006032402

3     a20050113    3     2006032403

4     a20050114    4     2006032404

结果说明:

很明显,这里只显示出了 A.aID = B.bID的记录.这说明inner join并不以谁为基础,它只显示符合条件的记录.

注:

LEFT JOIN操作用于在任何的 FROM 子句中,组合来源表的记录。使用 LEFT JOIN 运算来创建一个左边外部联接。左边外部联接将包含了从第一个(左边)开始的两个表中的全部记录,即使在第二个(右边)表中并没有相符值的记录。

语法:SELECT FROM table1 LEFT JOIN table2 ON table1.field1 compopr table2.field2

说明:

table1, table2参数用于指定要将记录组合的表的名称。

field1, field2参数指定被联接的字段的名称。且这些字段必须有相同的数据类型及包含相同类型的数据,但它们不需要有相同的名称。

compopr参数指定关系比较运算符:"=", "<", ">", "<=>=" 或 "<>"。

如果在INNER JOIN操作中要联接包含Memo 数据类型或 OLE Object 数据类型数据的字段,将会发生错误.

  所以,依我的理解,sql应该这么写:

  select 软件 from 软件表 inner join 设备表 on 软件表.mac=设备表.mac where 设备表.pro = 'xxx' and 设备表.city = 'xxx';