一、主从架构
主从架构一般如下所示
这里从节点一般设置成只读(readonly)模式。这样做,有以下几个考虑:
-
有时候一些运营类的查询语句会被放到备库上去查,设置为只读可以防止误操作;
-
防止切换逻辑有 bug,比如切换过程中出现双写,造成主备不一致;
-
可以用 readonly 状态,来判断节点的角色。
你可能会问,我把备库设置成只读了,还怎么跟主库保持同步更新呢?
这个问题,你不用担心。因为 readonly 设置对超级 (super) 权限用户是无效的,而用于同步更新的线程,就拥有超级权限。
1.主从复制
1.主从复制原理
Mysql的主从复制中主要有三个线程: master(binlog dump thread)、slave(I/O thread 、SQL thread) ,Master一条线程和Slave中的两条线程。
整体上来说,复制有3个步骤:
- master将改变记录到二进制日志(binary log)中(这些记录叫做二进制日志事件,binary log events);
- 从节点 I/O线程接收 binlog 变动内容,并将其写入到 中继日志(relay log) 文件中。;
- 从节点的SQL 线程读取 relay log 文件内容对数据更新进行重放,最终保证主从数据库的一致性。
复制流程如下:
注:主从节点使用 binglog 文件 + position 偏移量来定位主从同步的位置,从节点会保存其已接收到的偏移量,如果从节点发生宕机重启,则会自动从 position 的位置发起同步。
详细流程如下:
第一部分就是master记录二进制日志。
在每个事务更新数据完成之前,master在二进制日志中记录这些改变。MySQL将事务串行的写入二进制日志,即使事务中的语句都是交叉执行的。在事件写入二进制日志完成后,master通知存储引擎提交事务。
第二部分就是slave将master的binary log拷贝到它自己的中继日志。
首先,slave开始一个工作线程——I/O线程。I/O线程在master上打开一个普通的连接,然后开始binlog dump process。Binlog dump process从master的二进制日志中读取事件,如果已经跟上master,它会睡眠并等待master产生新的事件。I/O线程将这些事件写入中继日志。
SQL slave thread(SQL从线程)处理该过程的最后一步。
SQL线程从中继日志读取事件,并重放其中的事件而更新slave的数据,使其与master中的数据一致。只要该线程与I/O线程保持一致,中继日志通常会位于OS的缓存中,所以中继日志的开销很小。
此外,在master中也有一个工作线程:和其它MySQL的连接一样,slave在master中打开一个连接也会使得master开始一个线程。复制过程有一个很重要的限制——复制在slave上是串行化的,也就是说master上的并行更新操作不能在slave上并行操作。
2.主从复制策略
1.异步复制
上述处理流程就是异步复制的流程。
而mysql默认的复制方式是异步复制
主库把日志发送给从库后不关心从库是否已经处理,这样会产生一个问题就是假设主库挂了,从库处理失败了,这时候从库升为主库后,日志就丢失了。
由此产生两个概念。
2.全同步复制
主库写入binlog后强制同步日志到从库,所有的从库都执行完成后才返回给客户端,但是很显然这个方式的话性能会受到严重影响。
这里我理解即使是全同步复制,当在复制的过程中主库挂了,那部分数据也丢失了,但主从之间数据还是一致的。由于主库的事务没有提交,那么用户将收到的执行事务失败的错误,那么等主库恢复好了之后,用户将进行二次提交,那么数据就恢复正常了。所以我认为全同步复制只能保证主从之间的数据强一致性,但无法保证因主库宕机而造成的数据丢失问题。
3.半同步复制
和全同步不同的是,半同步复制的逻辑是这样,从库写入日志成功后返回ACK确认给主库,主库收到至少一个从库的确认就认为写操作完成。
配置半同步复制的时候,有一个重要的参数“rpl_semi_sync_master_wait_no_slave”,
含义是:“至少等待数据复制到几个从节点再返回”。这个数量配置的越大,丢数据的风险越小,但是集群的性能和可用性就越差。最大可以配置成和从节点的数量一样,这样就变成了同步复制。
一般情况下,配成默认值 1 也就够了,这样性能损失最小,可用性也很高,只要还有一个从库活着,就不影响主库读写。丢数据的风险也不大,只有在恰好主库和那个有最新数据的从库一起坏掉的情况下,才有可能丢数据。
另外一个重要的参数是“rpl_semi_sync_master_wait_point”,这个参数控制主库执行事务的线程,是在提交事务之前(AFTER_SYNC)等待复制,还是在提交事务之后(AFTER_COMMIT)等待复制。默认是 AFTER_SYNC,也就是先等待复制,再提交事务,这样完全不会丢数据。AFTER_COMMIT 具有更好的性能,不会长时间锁表,但还是存在宕机丢数据的风险。
另外,虽然我们配置了同步或者半同步复制,并且要等待复制成功后再提交事务,还是有一
种特别容易被忽略、可能存在丢数据风险的情况。如果说,主库提交事务的线程等待复制的时间超时了,这种情况下事务仍然会被正常提交。并且,MySQL 会自动降级为异步复制模式,直到有足够多(rpl_semi_sync_master_wait_no_slave)的从库追上主库,才能恢复成半同步复制。如果这个期间主库宕机,仍然存在丢数据的风险
3.并行复制演进
如果备库执行日志的速度持续低于主库生成日志的速度,那这个延迟就有可能成了小时级别。而且对于一个压力持续比较高的主库来说,备库很可能永远都追不上主库的节奏。
这就涉及到今天我要给你介绍的话题:备库并行复制能力。
为了便于你理解,我们再一起看一下极客时间第 24 篇文章《MySQL 是怎么保证主备一致的?》的主备流程图。
图 1 主备流程图
谈到主备的并行复制能力,我们要关注的是图中黑色的两个箭头。一个箭头代表了客户端写入主库,另一箭头代表的是备库上 sql_thread 执行中转日志(relay log)。如果用箭头的粗细来代表并行度的话,那么真实情况就如图 1 所示,第一个箭头要明显粗于第二个箭头。
在主库上,影响并发度的原因就是各种锁了。由于 InnoDB 引擎支持行锁,除了所有并发事务都在更新同一行(热点行)这种极端场景外,它对业务并发度的支持还是很友好的。所以,你在性能测试的时候会发现,并发压测线程 32 就比单线程时,总体吞吐量高。
而日志在备库上的执行,就是图中备库上 sql_thread 更新数据 (DATA) 的逻辑。如果是用单线程的话,就会导致备库应用日志不够快,造成主备延迟。
在官方的 5.6 版本之前,MySQL 只支持单线程复制,由此在主库并发高、TPS 高时就会出现严重的主备延迟问题。
从单线程复制到最新版本的多线程复制,中间的演化经历了好几个版本。接下来,我就跟你说说 MySQL 多线程复制的演进过程。
其实说到底,所有的多线程复制机制,都是要把图 1 中只有一个线程的 sql_thread,拆成多个线程,也就是都符合下面的这个模型:
图 2 多线程模型
图 2 中,coordinator 就是原来的 sql_thread, 不过现在它不再直接更新数据了,只负责读取中转日志和分发事务。真正更新日志的,变成了 worker 线程。而 work 线程的个数,就是由参数 slave_parallel_workers 决定的。根据我的经验,把这个值设置为 8~16 之间最好(32 核物理机的情况),毕竟备库还有可能要提供读查询,不能把 CPU 都吃光了。
接下来,你需要先思考一个问题:事务能不能按照轮询的方式分发给各个 worker,也就是第一个事务分给 worker_1,第二个事务发给 worker_2 呢?
其实是不行的。因为,事务被分发给 worker 以后,不同的 worker 就独立执行了。但是,由于 CPU 的调度策略,很可能第二个事务最终比第一个事务先执行。而如果这时候刚好这两个事务更新的是同一行,也就意味着,同一行上的两个事务,在主库和备库上的执行顺序相反,会导致主备不一致的问题。
接下来,请你再设想一下另外一个问题:同一个事务的多个更新语句,能不能分给不同的 worker 来执行呢?
答案是,也不行。举个例子,一个事务更新了表 t1 和表 t2 中的各一行,如果这两条更新语句被分到不同 worker 的话,虽然最终的结果是主备一致的,但如果表 t1 执行完成的瞬间,备库上有一个查询,就会看到这个事务“更新了一半的结果”,破坏了事务逻辑的隔离性。
所以,coordinator 在分发的时候,需要满足以下这两个基本要求:
-
不能造成更新覆盖。这就要求更新同一行的两个事务,必须被分发到同一个 worker 中。
-
同一个事务不能被拆开,必须放到同一个 worker 中。
各个版本的多线程复制,都遵循了这两条基本原则。
按照并行复制的维度一般分为以下几个级别
- 行维度
- 表维度
- 数据库维度
接下来,我们就看看各个版本的并行复制策略,详细的复制策略可参考极客时间第26篇
1.官方 MySQL 5.5 版本
官方 MySQL 5.5 版本是不支持并行复制的。
2.官方 MySQL5.6 版本
官方 MySQL5.6 版本,支持了并行复制,只是支持的粒度是按库并行。
MySQL5.6的并行复制是基于数据库级别的,不同数据库的事务可以同时进行binlog重放。
如果用户的MySQL数据库实例中存在多个schema,对于从机复制的速度的确可以有比较大的帮助;
如果在MySQL 5.6版本开启并行复制功能,那么SQL线程就变为了coordinator线程,如果用户实例仅有一个库,那么就无法实现并行回放,甚至性能会比原来的单线程更差。
3.MariaDB版本
MySQL5.7 版本里,官方借助了MariaDB 的并行复制策略,即按照组提交维度进行并行控制。
下面是MariaDB的复制思想
在之前介绍了 redo log 组提交 (group commit) 优化, 而 MariaDB 的并行复制策略利用的就是这个特性:
能够在同一组里提交的事务,一定不会修改同一行;
主库上可以并行执行的事务,备库上也一定是可以并行执行的。
在实现上,MariaDB 是这么做的:
在一组里面一起提交的事务,有一个相同的 commit_id,下一组就是 commit_id+1;
commit_id 直接写到 binlog 里面;
传到备库应用的时候,相同 commit_id 的事务分发到多个 worker 执行;
这一组全部执行完成后,coordinator 再去取下一批。
当时,这个策略出来的时候是相当惊艳的。因为,之前业界的思路都是在“分析 binlog,并拆分到 worker”上。而 MariaDB 的这个策略,目标是“模拟主库的并行模式”。
但是,这个策略有一个问题,它并没有实现“真正的模拟主库并发度”这个目标。在主库上,一组事务在 commit 的时候,下一组事务是同时处于“执行中”状态的。
如图 5 所示,假设了三组事务在主库的执行情况,你可以看到在 trx1、trx2 和 trx3 提交的时候,trx4、trx5 和 trx6 是在执行的。这样,在第一组事务提交完成的时候,下一组事务很快就会进入 commit 状态。
图 5 主库并行事务
而按照 MariaDB 的并行复制策略,备库上的执行效果如图 6 所示。
图 6 MariaDB 并行复制,备库并行效果
可以看到,在备库上执行的时候,要等第一组事务完全执行完成后,第二组事务才能开始执行,这样系统的吞吐量就不够。
另外,这个方案很容易被大事务拖后腿。假设 trx2 是一个超大事务,那么在备库应用的时候,trx1 和 trx3 执行完成后,就只能等 trx2 完全执行完成,下一组才能开始执行。这段时间,只有一个 worker 线程在工作,是对资源的浪费。
不过即使如此,这个策略仍然是一个很漂亮的创新。因为,它对原系统的改造非常少,实现也很优雅。
这里思考一个问题,对同一行作更新的几个事务,如果 commit_id 相同,是不是在备库并行执行的时候会导致数据不一致?
这个问题的答案是更新同一行的事务是不可能同时进入 commit 状态的,也就是他们的commit_id肯定是不同的。
4.官方MySQL 5.7版本
不过,MySQL 5.7 这个策略,针对并行度做了优化。这个优化的思路也很有趣儿。
由参数 slave-parallel-type 来控制并行复制策略:
-
配置为 DATABASE,表示使用 MySQL 5.6 版本的按库并行策略;
-
配置为 LOGICAL_CLOCK,表示的就是类似 MariaDB 的策略。
你可以先考虑这样一个问题:同时处于“执行状态(running)”的所有事务,是不是可以并行?
答案是,不能。
因为,这里面可能有由于锁冲突而处于锁等待状态的事务。如果这些事务在备库上被分配到不同的 worker,就会出现备库跟主库不一致的情况。
而上面提到的 MariaDB 这个策略的核心,是“所有处于 commit”状态的事务可以并行。事务处于 commit 状态,表示已经通过了锁冲突的检验了。
其实,不用等到 commit 阶段,只要能够到达 redo log prepare 阶段,就表示事务已经通过锁冲突的检验了。
因此,MySQL 5.7 并行复制策略的思想是:
-
同时处于 prepare 状态的事务,在备库执行时是可以并行的;
-
处于 prepare 状态的事务,与处于 commit 状态的事务之间,在备库执行时也是可以并行的。
我在《极客时间》第 23 篇文章,讲 binlog 的组提交的时候,介绍过两个参数:
-
binlog_group_commit_sync_delay 参数,表示延迟多少微秒后才调用 fsync;
-
binlog_group_commit_sync_no_delay_count 参数,表示累积多少次以后才调用 fsync。
这两个参数是用于故意拉长 binlog 从 write 到 fsync 的时间,以此减少 binlog 的写盘次数。在 MySQL 5.7 的并行复制策略里,它们可以用来制造更多的“同时处于 prepare 阶段的事务”。这样就增加了备库复制的并行度。
也就是说,这两个参数,既可以“故意”让主库提交得慢些以提高iops,又可以让备库执行得快些。在 MySQL 5.7 处理备库延迟的时候,可以考虑调整这两个参数值,来达到提升备库复制并发度的目的。
5.官方MySQL 5.7.22 版本
在 2018 年 4 月份发布的 MySQL 5.7.22 版本里,MySQL 增加了一个新的并行复制策略,基于 WRITESET 的并行复制维度
相应地,新增了一个参数 binlog-transaction-dependency-tracking,用来控制是否启用这个新策略。这个参数的可选值有以下三种。
-
COMMIT_ORDER,表示的就是前面介绍的,根据同时进入 prepare 和 commit 来判断是否可以并行的策略。
-
WRITESET,表示的是对于事务涉及更新的每一行,计算出这一行的 hash 值,组成集合 writeset。如果两个事务没有操作相同的行,也就是说它们的 writeset 没有交集,就可以并行。
-
WRITESET_SESSION,是在 WRITESET 的基础上多了一个约束,即在主库上同一个线程先后执行的两个事务,在备库执行的时候,要保证相同的先后顺序。
当然为了唯一标识,这个 hash 值是通过“库名 + 表名 + 索引名 + 值”计算出来的。如果一个表上除了有主键索引外,还有其他唯一索引,那么对于每个唯一索引,insert 语句对应的 writeset 就要多增加一个 hash 值。
你可能看出来了,这跟我们前面介绍的基于 MySQL 5.5 版本的按行分发的策略是差不多的。不过,MySQL 官方的这个实现还是有很大的优势:
-
writeset 是在主库生成后直接写入到 binlog 里面的,这样在备库执行的时候,不需要解析 binlog 内容(event 里的行数据),节省了很多计算量;
-
不需要把整个事务的 binlog 都扫一遍才能决定分发到哪个 worker,更省内存;
-
由于备库的分发策略不依赖于 binlog 内容,所以 binlog 是 statement 格式也是可以的。
因此,MySQL 5.7.22 的并行复制策略在通用性上还是有保证的。
当然,对于“表上没主键”和“外键约束”的场景,WRITESET 策略也是没法并行的,也会暂时退化为单线程模型。
这里在介绍一下极客时间作者的行维度并发复制的思想
要解决热点表的并行复制问题,就需要一个按行并行复制的方案。
按行复制的核心思路是:如果两个事务没有更新相同的行,它们在备库上可以并行执行。显然,这个模式要求 binlog 格式必须是 row。
这时候,我们判断一个事务 T 和 worker 是否冲突,用的就规则就不是“修改同一个表”,而是“修改同一行”。
按行复制和按表复制的数据结构差不多,也是为每个 worker,分配一个 hash 表。只是要实现按行分发,这时候的 key,就必须是“库名 + 表名 + 唯一键的值”。
但是,这个“唯一键”只有主键 id 还是不够的,我们还需要考虑下面这种场景,表 t1 中除了主键,还有唯一索引 a:
CREATE TABLE `t1` ( `id` int(11) NOT NULL, `a` int(11) DEFAULT NULL, `b` int(11) DEFAULT NULL, PRIMARY KEY (`id`), UNIQUE KEY `a` (`a`) ) ENGINE=InnoDB; insert into t1 values(1,1,1),(2,2,2),(3,3,3),(4,4,4),(5,5,5);
假设,接下来我们要在主库执行这两个事务:
图 4 唯一键冲突示例
可以看到,这两个事务要更新的行的主键值不同,但是如果它们被分到不同的 worker,就有可能 session B 的语句先执行。这时候 id=1 的行的 a 的值还是 1,就会报唯一键冲突。
因此,基于行的策略,事务 hash 表中还需要考虑唯一键,即 key 应该是“库名 + 表名 + 索引 a 的名字 +a 的值”。
比如,在上面这个例子中,我要在表 t1 上执行 update t1 set a=1 where id=2 语句,在 binlog 里面记录了整行的数据修改前各个字段的值,和修改后各个字段的值。
因此,coordinator 在解析这个语句的 binlog 的时候,这个事务的 hash 表就有三个项:
key=hash_func(db1+t1+“PRIMARY”+2), value=2; 这里 value=2 是因为修改前后的行 id 值不变,出现了两次。
key=hash_func(db1+t1+“a”+2), value=1,表示会影响到这个表 a=2 的行。
key=hash_func(db1+t1+“a”+1), value=1,表示会影响到这个表 a=1 的行。
可见,相比于按表并行分发策略,按行并行策略在决定线程分发的时候,需要消耗更多的计算资源。你可能也发现了,这两个方案其实都有一些约束条件:
要能够从 binlog 里面解析出表名、主键值和唯一索引的值。也就是说,主库的 binlog 格式必须是 row;
表必须有主键;
不能有外键。表上如果有外键,级联更新的行不会记录在 binlog 中,这样冲突检测就不准确。
但,好在这三条约束规则,本来就是 DBA 之前要求业务开发人员必须遵守的线上使用规范,所以这两个并行复制策略在应用上也没有碰到什么麻烦。
对比按表分发和按行分发这两个方案的话,按行分发策略的并行度更高。不过,如果是要操作很多行的大事务的话,按行分发的策略有两个问题:
耗费内存。比如一个语句要删除 100 万行数据,这时候 hash 表就要记录 100 万个项。
耗费 CPU。解析 binlog,然后计算 hash 值,对于大事务,这个成本还是很高的。
所以,我在实现这个策略的时候会设置一个阈值,单个事务如果超过设置的行数阈值(比如,如果单个事务更新的行数超过 10 万行),就暂时退化为单线程模式,退化过程的逻辑大概是这样的:
coordinator 暂时先 hold 住这个事务;
等待所有 worker 都执行完成,变成空队列;
coordinator 直接执行这个事务;
恢复并行模式。
这里在多说一句,由于我们不是DBA人员,所以借用极客时间时间作者的一句话。
在介绍完每个并行复制策略后,我还和你分享了不同策略的优缺点:
- 如果你是 DBA,就需要根据不同的业务场景,选择不同的策略;
- 如果是你业务开发人员,也希望你能从中获取灵感用到平时的开发工作中。
从这些分析中,你也会发现大事务不仅会影响到主库,也是造成备库复制延迟的主要原因之一。因此,在平时的开发工作中,我建议你尽量减少大事务操作,把大事务拆成小事务。
2.主备切换
1.可靠性优先策略
从状态 1 到状态 2 切换的详细过程是这样的:
-
判断备库 B 现在的 seconds_behind_master,如果小于某个值(比如 5 秒)继续下一步,否则持续重试这一步;
-
把主库 A 改成只读状态,即把 readonly 设置为 true;
-
判断备库 B 的 seconds_behind_master 的值,直到这个值变成 0 为止;
-
把备库 B 改成可读写状态,也就是把 readonly 设置为 false;
-
把业务请求切到备库 B。
这个切换流程,一般是由专门的 HA 系统来完成的,我们暂时称之为可靠性优先流程。
图 2 MySQL 可靠性优先主备切换流程
备注:图中的 SBM,是 seconds_behind_master 参数的简写。
可以看到,这个切换流程中是有不可用时间的。
因为在步骤 2 之后,主库 A 和备库 B 都处于 readonly 状态,也就是说这时系统处于不可写状态,直到步骤 5 完成后才能恢复。
在这个不可用状态中,比较耗费时间的是步骤 3,可能需要耗费好几秒的时间。这也是为什么需要在步骤 1 先做判断,确保 seconds_behind_master 的值足够小。
试想如果一开始主备延迟就长达 30 分钟,而不先做判断直接切换的话,系统的不可用时间就会长达 30 分钟,这种情况一般业务都是不可接受的。
接下来我们再看看,按照可靠性优先的思路,异常切换会是什么效果?
假设,主库 A 和备库 B 间的主备延迟是 30 分钟,这时候主库 A 掉电了,HA 系统要切换 B 作为主库。我们在主动切换的时候,可以等到主备延迟小于 5 秒的时候再启动切换,但这时候已经别无选择了。
图 5 可靠性优先策略,主库不可用
采用可靠性优先策略的话,你就必须得等到备库 B 的 seconds_behind_master=0 之后,才能切换。但现在的情况比刚刚更严重,并不是系统只读、不可写的问题了,而是系统处于完全不可用的状态。因为,主库 A 掉电后,我们的连接还没有切到备库 B。
你可能会问,那能不能直接切换到备库 B,但是保持 B 只读呢?
这样也不行。
因为,这段时间内,中转日志还没有应用完成,如果直接发起主备切换,客户端查询看不到之前执行完成的事务,会认为有“数据丢失”。
虽然随着中转日志的继续应用,这些数据会恢复回来,但是对于一些业务来说,查询到“暂时丢失数据的状态”也是不能被接受的。
所以那‘沉默的30 分钟’只有尽快使SBM=0完成主从切换吧,使业务的伤害降到最低,那30分钟由于业务都是报错的,所以并不会产生脏数据,这也是不幸中的万幸了吧。
聊到这里你就知道了,在满足数据可靠性的前提下,MySQL 高可用系统的可用性,是依赖于主备延迟的。延迟的时间越小,在主库故障的时候,服务恢复需要的时间就越短,可用性就越高。
当然,系统的不可用时间,是由这个数据可靠性优先的策略决定的。你也可以选择可用性优先的策略,来把这个不可用时间几乎降为 0。
2.可用性优先策略
如果我强行把步骤 4、5 调整到最开始执行,也就是说不等主备数据同步,直接把连接切到备库 B,并且让备库 B 可以读写,那么系统几乎就没有不可用时间了。
我们把这个切换流程,暂时称作可用性优先流程。这个切换流程的代价,就是可能出现数据不一致的情况。
接下来,我就和你分享一个可用性优先流程产生数据不一致的例子。假设有一个表 t:
mysql> CREATE TABLE `t` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`c` int(11) unsigned DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
insert into t(c) values(1),(2),(3);
这个表定义了一个自增主键 id,初始化数据后,主库和备库上都是 3 行数据。接下来,业务人员要继续在表 t 上执行两条插入语句的命令,依次是:
| |
|
假设,现在主库上其他的数据表有大量的更新,导致主备延迟达到 5 秒。在插入一条 c=4 的语句后,发起了主备切换。
图 3 是可用性优先策略,且 binlog_format=mixed时的切换流程和数据结果。
图 3 可用性优先策略,且 binlog_format=mixed
现在,我们一起分析下这个切换流程:
-
步骤 2 中,主库 A 执行完 insert 语句,插入了一行数据(4,4),之后开始进行主备切换。
-
步骤 3 中,由于主备之间有 5 秒的延迟,所以备库 B 还没来得及应用“插入 c=4”这个中转日志,就开始接收客户端“插入 c=5”的命令。
-
步骤 4 中,备库 B 插入了一行数据(4,5),并且把这个 binlog 发给主库 A。
-
步骤 5 中,备库 B 执行“插入 c=4”这个中转日志,插入了一行数据(5,4)。而直接在备库 B 执行的“插入 c=5”这个语句,传到主库 A,就插入了一行新数据(5,5)。
最后的结果就是,主库 A 和备库 B 上出现了两行不一致的数据。可以看到,这个数据不一致,是由可用性优先流程导致的。
那么,如果我还是用可用性优先策略,但设置 binlog_format=row,情况又会怎样呢?
因为 row 格式在记录 binlog 的时候,会记录新插入的行的所有字段值,所以最后只会有一行不一致。而且,两边的主备同步的应用线程会报错 duplicate key error 并停止。也就是说,这种情况下,备库 B 的 (5,4) 和主库 A 的 (5,5) 这两行数据,都不会被对方执行。
图 4 中我画出了详细过程,你可以自己再分析一下。
图 4 可用性优先策略,且 binlog_format=row
从上面的分析中,你可以看到一些结论:
-
使用 row 格式的 binlog 时,数据不一致的问题更容易被发现。而使用 mixed 或者 statement 格式的 binlog 时,数据很可能悄悄地就不一致了。如果你过了很久才发现数据不一致的问题,很可能这时的数据不一致已经不可查,或者连带造成了更多的数据逻辑不一致。
-
主备切换的可用性优先策略会导致数据不一致。
因此,大多数情况下,我都建议你使用可靠性优先策略。毕竟对数据服务来说的话,数据的可靠性一般还是要优于可用性的。
但事无绝对,有没有哪种情况数据的可用性优先级更高呢?
答案是,有的。
我曾经碰到过这样的一个场景:
- 有一个库的作用是记录操作日志。这时候,如果数据不一致可以通过 binlog 来修补,而这个短暂的不一致也不会引发业务问题。
- 同时,业务系统依赖于这个日志写入逻辑,如果这个库不可写,会导致线上的业务操作无法执行。
这时候,你可能就需要选择先强行切换,事后再补数据的策略。
当然,事后复盘的时候,我们想到了一个改进措施就是,让业务逻辑不要依赖于这类日志的写入。也就是说,日志写入这个逻辑模块应该可以降级,比如写到本地文件,或者写到另外一个临时库里面。
这样的话,这种场景就又可以使用可靠性优先策略了。
3.主从切换
再谈主从切换前,我先强调一下一定避免主节点宕机,主节点宕机是一件很严重的事情,所以主节点限流是非常有必要的。
如图 1 所示,就是一个基本的一主多从结构。
图 1 一主多从基本结构
图中,虚线箭头表示的是主备关系,也就是 A 和 A’互为主备, 从库 B、C、D 指向的是主库 A。一主多从的设置,一般用于读写分离,主库负责所有的写入和一部分读,其他的读请求则由从库分担。
今天我们要讨论的就是,在一主多从架构下,主库故障后的主备切换问题。
如图 2 所示,就是主库发生故障,主备切换后的结果。
图 2 一主多从基本结构 -- 主备切换
相比于一主一备的切换流程,一主多从结构在切换完成后,A’会成为新的主库,从库 B、C、D 也要改接到 A’。正是由于多了从库 B、C、D 重新指向的这个过程,所以主备切换的复杂性也相应增加了。
这里要说明一下,虽然主从切换能解决主节点宕机时保证业务可用性的问题,但很难避免切换过程中的数据丢失问题,所以其实不少公司当发现主节点宕机后,一般会有监控并手动或者自动重启,虽然区间会服务不可用,但最起码数据是没有丢失的,且主从切换维护麻烦,等你把主从关系切换完后,可能主节点早就已经重启好了。
接下来,我们再一起看看一个切换系统会怎么完成一主多从的主备切换过程。
1.基于位点的主备切换
这里,我们需要先来回顾一个知识点。
当我们把节点 B 设置成节点 A’的从库的时候,需要执行一条 change master 命令:
CHANGE MASTER TO
MASTER_HOST=$host_name
MASTER_PORT=$port
MASTER_USER=$user_name
MASTER_PASSWORD=$password
MASTER_LOG_FILE=$master_log_name
MASTER_LOG_POS=$master_log_pos
这条命令有这么 6 个参数:
- MASTER_HOST、MASTER_PORT、MASTER_USER 和 MASTER_PASSWORD 四个参数,分别代表了主库 A’的 IP、端口、用户名和密码。
- 最后两个参数 MASTER_LOG_FILE 和 MASTER_LOG_POS 表示,要从主库的 master_log_name 文件的 master_log_pos 这个位置的日志继续同步。而这个位置就是我们所说的同步位点,也就是主库对应的文件名和日志偏移量。
那么,这里就有一个问题了,节点 B 要设置成 A’的从库,就要执行 change master 命令,就不可避免地要设置位点的这两个参数,但是这两个参数到底应该怎么设置呢?
原来节点 B 是 A 的从库,本地记录的也是 A 的位点。但是相同的日志,A 的位点和 A’的位点是不同的。因此,从库 B 要切换的时候,就需要先经过“找同步位点”这个逻辑。
这个位点很难精确取到,只能取一个大概位置。为什么这么说呢?
我来和你分析一下看看这个位点一般是怎么获取到的,你就清楚其中不精确的原因了。
考虑到切换过程中不能丢数据,所以我们找位点的时候,总是要找一个“稍微往前”的,然后再通过判断跳过那些在从库 B 上已经执行过的事务。
一种取同步位点的方法是这样的:
-
等待新主库 A’把中转日志(relay log)全部同步完成;
-
在 A’上执行 show master status 命令,得到当前 A’上最新的 File 和 Position;
-
取原主库 A 故障的时刻 T;
-
用 mysqlbinlog 工具解析 A’的 File,得到 T 时刻的位点。
|
图 3 mysqlbinlog 部分输出结果
图中,end_log_pos 后面的值“123”,表示的就是 A’这个实例,在 T 时刻写入新的 binlog 的位置。然后,我们就可以把 123 这个值作为 $master_log_pos ,用在节点 B 的 change master 命令里。
当然这个值并不精确。为什么呢?
你可以设想有这么一种情况,假设在 T 这个时刻,主库 A 已经执行完成了一个 insert 语句插入了一行数据 R,并且已经将 binlog 传给了 A’和 B,然后在传完的瞬间主库 A 的主机就掉电了。
那么,这时候系统的状态是这样的:
-
在从库 B 上,由于同步了 binlog, R 这一行已经存在;
-
在新主库 A’上, R 这一行也已经存在,日志是写在 123 这个位置之后的;
-
我们在从库 B 上执行 change master 命令,指向 A’的 File 文件的 123 位置,就会把插入 R 这一行数据的 binlog 又同步到从库 B 去执行。
这时候,从库 B 的同步线程就会报告 Duplicate entry ‘id_of_R’ for key ‘PRIMARY’ 错误,提示出现了主键冲突,然后停止同步。
所以,通常情况下,我们在切换任务的时候,要先主动跳过这些错误,有两种常用的方法。
一种做法是,主动跳过一个事务。跳过命令的写法是:
set global sql_slave_skip_counter=1;
start slave;
因为切换过程中,可能会不止重复执行一个事务,所以我们需要在从库 B 刚开始接到新主库 A’时,持续观察,每次碰到这些错误就停下来,执行一次跳过命令,直到不再出现停下来的情况,以此来跳过可能涉及的所有事务。
另外一种方式是,通过设置 slave_skip_errors 参数,直接设置跳过指定的错误。
在执行主备切换时,有这么两类错误,是经常会遇到的:
- 1062 错误是插入数据时唯一键冲突;
- 1032 错误是删除数据时找不到行。
因此,我们可以把 slave_skip_errors 设置为 “1032,1062”,这样中间碰到这两个错误时就直接跳过。
这里需要注意的是,这种直接跳过指定错误的方法,针对的是主备切换时,由于找不到精确的同步位点,所以只能采用这种方法来创建从库和新主库的主备关系。
这个背景是,我们很清楚在主备切换过程中,直接跳过 1032 和 1062 这两类错误是无损的,所以才可以这么设置 slave_skip_errors 参数。等到主备间的同步关系建立完成,并稳定执行一段时间之后,我们还需要把这个参数设置为空,以免之后真的出现了主从数据不一致,也跳过了。
2.基于 GTID 的主备切换
通过 sql_slave_skip_counter 跳过事务和通过 slave_skip_errors 忽略错误的方法,虽然都最终可以建立从库 B 和新主库 A’的主备关系,但这两种操作都很复杂,而且容易出错。所以,MySQL 5.6 版本引入了 GTID,彻底解决了这个困难。
那么,GTID 到底是什么意思,又是如何解决找同步位点这个问题呢?现在,我就和你简单介绍一下。
GTID 的全称是 Global Transaction Identifier,也就是全局事务 ID,是一个事务在提交的时候生成的,是这个事务的唯一标识。它由两部分组成,格式是:
|
其中:
- server_uuid 是一个实例第一次启动时自动生成的,是一个全局唯一的值;
- gno 是一个整数,初始值是 1,每次提交事务的时候分配给这个事务,并加 1。
这里我需要和你说明一下,在 MySQL 的官方文档里,GTID 格式是这么定义的:
|
这里的 source_id 就是 server_uuid;而后面的这个 transaction_id,我觉得容易造成误导,所以我改成了 gno。为什么说使用 transaction_id 容易造成误解呢?
因为,在 MySQL 里面我们说 transaction_id 就是指事务 id,事务 id 是在事务执行过程中分配的,如果这个事务回滚了,事务 id 也会递增,而 gno 是在事务提交的时候才会分配。
从效果上看,GTID 往往是连续的,因此我们用 gno 来表示更容易理解。
GTID 模式的启动也很简单,我们只需要在启动一个 MySQL 实例的时候,加上参数 gtid_mode=on 和 enforce_gtid_consistency=on 就可以了。
在 GTID 模式下,每个事务都会跟一个 GTID 一一对应。这个 GTID 有两种生成方式,而使用哪种方式取决于 session 变量 gtid_next 的值。
-
如果 gtid_next=automatic,代表使用默认值。这时,MySQL 就会把 server_uuid:gno 分配给这个事务。
a. 记录 binlog 的时候,先记录一行 SET @@SESSION.GTID_NEXT=‘server_uuid:gno’;
b. 把这个 GTID 加入本实例的 GTID 集合。 -
如果 gtid_next 是一个指定的 GTID 的值,比如通过 set gtid_next='current_gtid’指定为 current_gtid,那么就有两种可能:
a. 如果 current_gtid 已经存在于实例的 GTID 集合中,接下来执行的这个事务会直接被系统忽略;
b. 如果 current_gtid 没有存在于实例的 GTID 集合中,就将这个 current_gtid 分配给接下来要执行的事务,也就是说系统不需要给这个事务生成新的 GTID,因此 gno 也不用加 1。
注意,一个 current_gtid 只能给一个事务使用。这个事务提交后,如果要执行下一个事务,就要执行 set 命令,把 gtid_next 设置成另外一个 gtid 或者 automatic。
这样,每个 MySQL 实例都维护了一个 GTID 集合,用来对应“这个实例执行过的所有事务”。
这样看上去不太容易理解,接下来我就用一个简单的例子,来和你说明 GTID 的基本用法。
我们在实例 X 中创建一个表 t。
CREATE TABLE `t` (
`id` int(11) NOT NULL,
`c` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;
insert into t values(1,1);
图 4 初始化数据的 binlog
可以看到,事务的 BEGIN 之前有一条 SET @@SESSION.GTID_NEXT 命令。这时,如果实例 X 有从库,那么将 CREATE TABLE 和 insert 语句的 binlog 同步过去执行的话,执行事务之前就会先执行这两个 SET 命令, 这样被加入从库的 GTID 集合的,就是图中的这两个 GTID。
假设,现在这个实例 X 是另外一个实例 Y 的从库,并且此时在实例 Y 上执行了下面这条插入语句:
|
并且,这条语句在实例 Y 上的 GTID 是 “aaaaaaaa-cccc-dddd-eeee-ffffffffffff:10”。
那么,实例 X 作为 Y 的从库,就要同步这个事务过来执行,显然会出现主键冲突,导致实例 X 的同步线程停止。这时,我们应该怎么处理呢?
处理方法就是,你可以执行下面的这个语句序列:
set gtid_next='aaaaaaaa-cccc-dddd-eeee-ffffffffffff:10';
begin;
commit;
set gtid_next=automatic;
start slave;
其中,前三条语句的作用,是通过提交一个空事务,把这个 GTID 加到实例 X 的 GTID 集合中。如图 5 所示,就是执行完这个空事务之后的 show master status 的结果。
图 5 show master status 结果
可以看到实例 X 的 Executed_Gtid_set 里面,已经加入了这个 GTID。
这样,我再执行 start slave 命令让同步线程执行起来的时候,虽然实例 X 上还是会继续执行实例 Y 传过来的事务,但是由于“aaaaaaaa-cccc-dddd-eeee-ffffffffffff:10”已经存在于实例 X 的 GTID 集合中了,所以实例 X 就会直接跳过这个事务,也就不会再出现主键冲突的错误。
在上面的这个语句序列中,start slave 命令之前还有一句 set gtid_next=automatic。这句话的作用是“恢复 GTID 的默认分配行为”,也就是说如果之后有新的事务再执行,就还是按照原来的分配方式,继续分配 gno=3。
现在,我们已经理解 GTID 的概念,再一起来看看基于 GTID 的主备复制的用法。
在 GTID 模式下,备库 B 要设置为新主库 A’的从库的语法如下
CHANGE MASTER TO
MASTER_HOST=$host_name
MASTER_PORT=$port
MASTER_USER=$user_name
MASTER_PASSWORD=$password
master_auto_position=1
其中,master_auto_position=1 就表示这个主备关系使用的是 GTID 协议。可以看到,前面让我们头疼不已的 MASTER_LOG_FILE 和 MASTER_LOG_POS 参数,已经不需要指定了。
我们把现在这个时刻,实例 A’的 GTID 集合记为 set_a,实例 B 的 GTID 集合记为 set_b。接下来,我们就看看现在的主备切换逻辑。
我们在实例 B 上执行 start slave 命令,取 binlog 的逻辑是这样的:
-
实例 B 指定主库 A’,基于主备协议建立连接。
-
实例 B 把 set_b 发给主库 A’。
-
实例 A’算出 set_a 与 set_b 的差集,也就是所有存在于 set_a,但是不存在于 set_b 的 GTID 的集合,判断 A’本地是否包含了这个差集需要的所有 binlog 事务。
a. 如果不包含,表示 A’已经把实例 B 需要的 binlog 给删掉了,直接返回错误;
b. 如果确认全部包含,A’从自己的 binlog 文件里面,找出第一个不在 set_b 的事务,发给 B; -
之后就从这个事务开始,往后读文件,按顺序取 binlog 发给 B 去执行。
其实,这个逻辑里面包含了一个设计思想:在基于 GTID 的主备关系里,系统认为只要建立主备关系,就必须保证主库发给备库的日志是完整的。因此,如果实例 B 需要的日志已经不存在,A’就拒绝把日志发给 B。
这跟基于位点的主备协议不同。基于位点的协议,是由备库决定的,备库指定哪个位点,主库就发哪个位点,不做日志的完整性判断。
基于上面的介绍,我们再来看看引入 GTID 后,一主多从的切换场景下,主备切换是如何实现的。
由于不需要找位点了,所以从库 B、C、D 只需要分别执行 change master 命令指向实例 A’即可。
其实,严谨地说,主备切换不是不需要找位点了,而是找位点这个工作,在实例 A’内部就已经自动完成了。但由于这个工作是自动的,所以对 HA 系统的开发人员来说,非常友好。
之后这个系统就由新主库 A’写入,主库 A’的自己生成的 binlog 中的 GTID 集合格式是:server_uuid_of_A’:1-M。
如果之前从库 B 的 GTID 集合格式是 server_uuid_of_A:1-N, 那么切换之后 GTID 集合的格式就变成了 server_uuid_of_A:1-N, server_uuid_of_A’:1-M。
当然,主库 A’之前也是 A 的备库,因此主库 A’和从库 B 的 GTID 集合是一样的。这就达到了我们预期。
接下来,我再举个例子帮你理解 GTID。
我和你提到业务高峰期的慢查询性能问题时,分析到如果是由于索引缺失引起的性能问题,我们可以通过在线加索引来解决。但是,考虑到要避免新增索引对主库性能造成的影响,我们可以先在备库加索引,然后再切换。
当时我说,在双 M 结构下,备库执行的 DDL 语句也会传给主库,为了避免传回后对主库造成影响,要通过 set sql_log_bin=off 关掉 binlog。
评论区有位同学提出了一个问题:这样操作的话,数据库里面是加了索引,但是 binlog 并没有记录下这一个更新,是不是会导致数据和日志不一致?
这个问题提得非常好。当时,我在留言的回复中就引用了 GTID 来说明。今天,我再和你展开说明一下。
假设,这两个互为主备关系的库还是实例 X 和实例 Y,且当前主库是 X,并且都打开了 GTID 模式。这时的主备切换流程可以变成下面这样:
-
在实例 X 上执行 stop slave。
-
在实例 Y 上执行 DDL 语句。注意,这里并不需要关闭 binlog。
-
执行完成后,查出这个 DDL 语句对应的 GTID,并记为 server_uuid_of_Y:gno。
-
到实例 X 上执行以下语句序列:
set GTID_NEXT="server_uuid_of_Y:gno";
begin;
commit;
set gtid_next=automatic;
start slave;
这样做的目的在于,既可以让实例 Y 的更新有 binlog 记录,同时也可以确保不会在实例 X 上执行这条更新。
- 接下来,执行完主备切换,然后照着上述流程再执行一遍即可。
3.基于MHA自动主从切换
前面两种基于位点和基于GTID都需要我们人肉手动的去发现和执行主从切换,我们有没有什么办法可以自动进行发现和完成主从切换勒?
我想一定是有的,不然没有任何一家企业愿意去做手动切换。
1.MHA是什么?
MHA(Master High Availability)是一款开源的 MySQL 的高可用程序,它为 MySQL 主从复制架构提供了 automating master failover 功能。MHA 在监控到 master 节点故障时,会提升其中拥有最新数据的 slave 节点成为新的master 节点,在此期间,MHA 会通过于其它从节点获取额外信息来避免一致性方面的问题。MHA 还提供了 master 节点的在线切换功能,即按需切换 master/slave 节点。
MHA 是由日本人 yoshinorim(原就职于DeNA现就职于FaceBook)开发的比较成熟的 MySQL 高可用方案。MHA 能够在30秒内实现故障切换,并能在故障切换中,最大可能的保证数据一致性。目前淘宝也正在开发相似产品 TMHA, 目前已支持一主一从。
MHA优点:
- 自动故障转移快
- 主库崩溃不存在数据一致性问题
- 性能优秀,支持半同步复制和异步复制
- 一个Manager监控节点可以监控多个集群
2.MHA架构
MHA 服务有两种角色, MHA Manager(管理节点)和 MHA Node(数据节点):
MHA Manager:
通常单独部署在一台独立机器上管理多个 master/slave 集群(组),每个 master/slave 集群称作一个 application,用来管理统筹整个集群。
MHA node:
运行在每台 MySQL 服务器上(master/slave/manager),它通过监控具备解析和清理 logs 功能的脚本来加快故障转移。
主要是接收管理节点所发出指令的代理,代理需要运行在每一个 mysql 节点上。简单讲 node 就是用来收集从节点服务器上所生成的 bin-log 。对比打算提升为新的主节点之上的从节点的是否拥有并完成操作,如果没有发给新主节点在本地应用后提升为主节点。
由上图我们可以看出,每个复制组内部和 Manager 之间都需要ssh实现无密码互连,只有这样,在 Master 出故障时, Manager 才能顺利的连接进去,实现主从切换功能。
目前MHA主要支持一主多从的架构,要搭建MHA,要求一个复制集群中必须最少有三台数据库服务器
3.MHA工作流程
(1) 把宕机master的binlog保存下来
(2) 根据binlog位置点找到最新的slave
(3) 用最新slave的relaylog修复其它slave
(4) 将保存下来的binlog在最新的slave上恢复
(5) 将最新的slave提升为master
(6) 将其它slave重新指向新提升的master,并开启主从复制
4.主从延迟
1.定义
数据库中的数据在主库完成更新后,是异步同步到每个从库上的,这个过程有一个微小的时间差,这个时间差叫主从同步延迟。
正常情况下,主从延迟非常小,不超过 1ms。但即使这个非常小的延迟,也会导致在某一个时刻,主库和从库上的数据是不一致的。应用程序需要能接受并克服这种主从不一致的情况,否则就会引发一些由于主从延迟导致的数据错误。
主备切换可能是一个主动运维动作,比如软件升级、主库所在机器按计划下线等,也可能是被动操作,比如主库所在机器掉电。
接下来,我们先一起看看主动切换的场景。
在介绍主动切换流程的详细步骤之前,我要先跟你说明一个概念,即“同步延迟”。与数据同步有关的时间点主要包括以下三个:
主库 A 执行完成一个事务,写入 binlog,我们把这个时刻记为 T1;
之后传给备库 B,我们把备库 B 接收完这个 binlog 的时刻记为 T2;
备库 B 执行完成这个事务,我们把这个时刻记为 T3。
所谓主备延迟,就是同一个事务,在备库执行完成的时间和主库执行完成的时间之间的差值,也就是 T3-T1。
你可以在备库上执行 show slave status 命令,它的返回结果里面会显示 seconds_behind_master,用于表示当前备库延迟了多少秒。
seconds_behind_master 的计算方法是这样的:
每个事务的 binlog 里面都有一个时间字段,用于记录主库上写入的时间;
备库取出当前正在执行的事务的时间字段的值,计算它与当前系统时间的差值,得到 seconds_behind_master。
可以看到,其实 seconds_behind_master 这个参数计算的就是 T3-T1。所以,我们可以用 seconds_behind_master 来作为主备延迟的值,这个值的时间精度是秒。
你可能会问,如果主备库机器的系统时间设置不一致,会不会导致主备延迟的值不准?
其实不会的。因为,备库连接到主库的时候,会通过执行 SELECT UNIX_TIMESTAMP() 函数来获得当前主库的系统时间。如果这时候发现主库的系统时间与自己不一致,备库在执行 seconds_behind_master 计算的时候会自动扣掉这个差值。
需要说明的是,在网络正常的时候,日志从主库传给备库所需的时间是很短的,即 T2-T1 的值是非常小的。也就是说,网络正常情况下,主备延迟的主要来源是备库接收完 binlog 和执行完这个事务之间的时间差。
所以说,主备延迟最直接的表现是,备库消费中转日志(relay log)的速度,比主库生产 binlog 的速度要慢。接下来,我就和你一起分析下,这可能是由哪些原因导致的。
2.产生原因
谈到MySQL数据库主从同步延迟原理,得从mysql的数据库主从复制原理说起,mysql的主从复制都是单线程的操作,主库对所有DDL和 DML产生binlog,binlog是顺序写,所以效率很高,slave的Slave_IO_Running线程到主库取日志,效率很比较高,下一步, 问题来了,slave的Slave_SQL_Running线程将主库的DDL和DML操作在slave实施,DML和DDL的IO操作是随即的,不是顺 序的,成本高很多,还可能可slave上的其他查询产生lock争用,由于Slave_SQL_Running也是单线程的,所以一个DDL卡主了,需要 执行10分钟,那么所有之后的DDL会等待这个DDL执行完才会继续执行,这就导致了延时。
有朋友会问:“主库上那个相同的DDL也需要执行10分,为什 么slave会延时?”,答案是master可以并发,Slave_SQL_Running线程却不可以。
1.非对称部署
首先,有些部署条件下,备库所在机器的性能要比主库所在的机器性能差。
一般情况下,有人这么部署时的想法是,反正备库没有请求,所以可以用差一点儿的机器。或者,他们会把 20 个主库放在 4 台机器上,而把备库集中在一台机器上。
其实我们都知道,更新请求对 IOPS 的压力,在主库和备库上是无差别的。所以,做这种部署时,一般都会将备库设置为“非双 1”的模式。
但实际上,更新过程中也会触发大量的读操作。所以,当备库主机上的多个备库都在争抢资源的时候,就可能会导致主备延迟了。
当然,这种部署现在比较少了。
因为主备可能发生切换,备库随时可能变成主库,所以主备库选用相同规格的机器,并且做对称部署,是现在比较常见的情况。
2.备库压力过大
做了对称部署以后,还可能会有延迟。这是为什么呢?
一般的想法是,主库既然提供了写能力,那么备库可以提供一些读能力。或者一些运营后台需要的分析语句,不能影响正常业务,所以只能在备库上跑。
我真就见过不少这样的情况。由于主库直接影响业务,大家使用起来会比较克制,反而忽视了备库的压力控制。结果就是,备库上的查询耗费了大量的 CPU 资源,影响了同步速度,造成主备延迟。
这种情况,我们一般可以这么处理:
-
一主多从。除了备库外,可以多接几个从库,让这些从库来分担读的压力。
-
通过 binlog 输出到外部系统,比如 Hadoop 这类系统,让外部系统提供统计类查询的能力。
其中,一主多从的方式大都会被采用。因为作为数据库系统,还必须保证有定期全量备份的能力。而从库,就很适合用来做备份。
还有就是当主库的TPS并发较高时,产生的DDL数量超过slave一个sql线程所能承受的范围(即执行这些ddl语句会耗时较大),那么延时就产生了,当然还有就是可能与slave的大型query语句产生了锁等待。
以 MySQL 为例,主从复制延迟可能达到 1 秒,如果有大量数据同步,延迟 1 分钟也是有可能的。
3.大事务
大事务这种情况很好理解。因为主库上必须等事务执行完成才会写入 binlog,再传给备库。所以,如果一个主库上的语句执行 10 分钟,那这个事务很可能就会导致从库延迟 10 分钟。
不知道你所在公司的 DBA 有没有跟你这么说过:不要一次性地用 delete 语句删除太多数据。其实,这就是一个典型的大事务场景。
比如,一些归档类的数据,平时没有注意删除历史数据,等到空间快满了,业务开发人员要一次性地删掉大量历史数据。同时,又因为要避免在高峰期操作会影响业务(至少有这个意识还是很不错的),所以会在晚上执行这些大量数据的删除操作。
结果,负责的 DBA 同学半夜就会收到延迟报警。然后,DBA 团队就要求你后续再删除数据的时候,要控制每个事务删除的数据量,分成多次删除
另一种典型的大事务场景,就是大表 DDL。这个场景,处理方案就是,计划内的 DDL,建议使用 gh-ost 方案。
然后在补充一点最好在业务低峰期的时候,确保主库能够支持所有业务查询,并且如果做了主从同步,当查询从节点发现主从同步延迟时间大于某一个阀值时,可适当将流量切换到主节点,等备库延迟追上以后,再把读请求切回备库。
当然如果没有对应的降级方案,在确保业务低峰期时段时,可直接把读请求都切到主库,再在主库上做 DDL。等备库延迟追上以后,再把读请求切回备库。
3.主从延迟监控
一般现在的数据库运维系统都有备库延迟监控,其实就是在备库上执行 show slave status,采集 seconds_behind_master 的值。
如果出现下面这种情况,说明已经出现了主从延迟,产生的原因则是备库的同步在这段时间完全被堵住了。
产生这种现象典型的场景主要包括两种:
1.一种是大事务(包括大表 DDL、一个事务操作很多行);
这种情况建议直接找DBA去解决,如果公司没有DBA团队,个人建议可以先等等看,看是否大事务是否能正常备份执行完,并检查从库是否有锁等待,及时清理从库造成锁等待的查询线程。
2.还有一种情况比较隐蔽,就是备库起了一个长事务,比如
begin;
select * from t limit 1;
然后就不动了。
这时候主库对表 t 做了一个加字段操作,即使这个表很小,这个 DDL 在备库应用的时候也会被堵住,也能看到这个现象。
比如看下面这个示例
mysql> show processlist;
+----+-----------------+-----------------+------+---------+------+----------------------------------+----------------------------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+-----------------+-----------------+------+---------+------+----------------------------------+----------------------------------------+
| 5 | event_scheduler | localhost | NULL | Daemon | 2239 | Waiting on empty queue | NULL |
| 17 | root | localhost | NULL | Query | 0 | init | show processlist |
| 18 | root | localhost | NULL | Query | 19 | User sleep | select id,sleep(1) from sbtest.sbtest1 |
| 19 | system user | connecting host | NULL | Connect | 243 | Waiting for source to send event | NULL |
| 20 | system user | | | Query | 13 | Waiting for table metadata lock | alter table sbtest.sbtest1 add c2 int |
+----+-----------------+-----------------+------+---------+------+----------------------------------+----------------------------------------+
5 rows in set (0.00 sec)
这种情况建议直接找DBA去解决,如果公司没有DBA团队,我个人建议可以将从库的所有查询线程都kill掉,看主从同步是否有所缓解。
4.减小主从延迟
最简单的减少slave同步延时的方案就是在架构上做优化,尽量让主库的DDL快速执行,另外就是使用比主库更好的硬件设备作为slave。
1.优化io
主库是写,对数据安全性较高,比如 sync_binlog=1,innodb_flush_log_at_trx_commit = 1 之类的设置,而slave则不需要这么高的数据安全,完全可以将sync_binlog设置为0或者关闭binlog,innodb_flush_log_at_trx_commit也可以设置为0来提高sql的执行效率。
2.优化并行复制策略
假设一个 MySQL 5.7.22 版本以上的主库,单线程插入了很多数据,过了 3 个小时后,我们要给这个主库搭建一个相同版本的备库。
这时候,你为了更快地让备库追上主库,要开并行复制。在 binlog-transaction-dependency-tracking 参数的 COMMIT_ORDER、WRITESET 和 WRITE_SESSION 这三个取值中,你会选择哪一个呢?
这个问题的答案是,应该将这个参数设置为 WRITESET。
由于主库是单线程压力模式,所以每个事务的 commit_id(组提交ID) 都不同,那么设置为 COMMIT_ORDER 模式的话,从库也只能单线程执行。
同样地,由于 WRITESET_SESSION 模式要求在备库应用日志的时候,同一个线程的日志必须与主库上执行的先后顺序相同,也会导致主库单线程压力模式下退化成单线程复制。
所以,应该将 binlog-transaction-dependency-tracking 设置为 WRITESET。
二、双机架构
一般分为双主架构和主备架构
1.双主架构
大部分这种架构用的比较少,因为难以解决数据的一致性问题。
1.部署架构
它的基本架构设计如下图所示:
图 9 MySQL 主备切换流程 -- 双 M 结构
对比图 9 和图 1,你可以发现,双 M 结构和 M-S 结构,其实区别只是多了一条线,即:节点 A 和 B 之间总是互为主备关系。这样在切换的时候就不用再修改主备关系。
2.循环复制问题
但是,双 M 结构还有一个问题需要解决,那就是循环复制问题。
业务逻辑在节点 A 上更新了一条语句,然后再把生成的 binlog 发给节点 B,节点 B 执行完这条更新语句后也会生成 binlog。(我建议你把参数 log_slave_updates 设置为 on,表示备库执行 relay log 后生成 binlog)。
那么,如果节点 A 同时是节点 B 的备库,相当于又把节点 B 新生成的 binlog 拿过来执行了一次,然后节点 A 和 B 间,会不断地循环执行这个更新语句,也就是循环复制了。这个要怎么解决呢?
从上面的图 6 中可以看到,MySQL 在 binlog 中记录了这个命令第一次执行时所在实例的 server id。因此,我们可以用下面的逻辑,来解决两个节点间的循环复制的问题:
-
规定两个库的 server id 必须不同,如果相同,则它们之间不能设定为主备关系;
-
一个备库接到 binlog 并在重放的过程中,生成与原 binlog 的 server id 相同的新的 binlog;
-
每个库在收到从自己的主库发过来的日志后,先判断 server id,如果跟自己的相同,表示这个日志是自己生成的,就直接丢弃这个日志。
按照这个逻辑,如果我们设置了双 M 结构,日志的执行流就会变成这样:
-
从节点 A 更新的事务,binlog 里面记的都是 A 的 server id;
-
传到节点 B 执行一次以后,节点 B 生成的 binlog 的 server id 也是 A 的 server id;
-
再传回给节点 A,A 判断到这个 server id 与自己的相同,就不会再处理这个日志。所以,死循环在这里就断掉了。
但是如果出现了以下的几种场景就会出现循环复制问题
一种场景是,在一个主库更新事务后,用命令 set global server_id=x 修改了 server_id。等日志再传回来的时候,发现 server_id 跟自己的 server_id 不同,就只能执行了。
另一种场景是,有三个节点的时候,如图 7 所示,trx1 是在节点 B 执行的,因此 binlog 上的 server_id 就是 B,binlog 传给节点 A,然后 A 和 A’搭建了双 M 结构,就会出现循环复制。
图 7 三节点循环复制
这种三节点复制的场景,做数据库迁移的时候会出现。
2.主备架构
虽然双主架构实践中可能担心数据一致性问题,但我自己认为还是可以借鉴的,比如我们可以采用这种架构
A'只做备份,不提供读写。
这样做的好处是由于A'没有读请求,一旦出现大事务或者DDL时,基本不会出现锁等待,主从延迟也是最快恢复的,当出现长时间主从延迟时,可以将A‘提供读能力,分担主库的读压力,可以在关键时刻临时解决相关问题。
还有一个好处是由于A'没有读请求,可以将A'的硬件配置和主库一样且采用全同步复制,一旦要进行主从切换,A'一定是最佳选择,可以将主从切换区间的数据损失减少得最少。
三、数据分库-读写分离
1.读写分离的意义
如果说数据分表的目的是解决大数据量查询慢的问题,那么数据分库主要解决的是高并发场景下,降低数据库实列访问压力的问题
优点
1.减轻数据库的io压力,由多个数据库分担用户的查询请求压力,而且大多数公司的业务场景都是读多写少
2.减少因为数据库读写而导致的加锁逻辑,影响数据库的读写性能,同时还减少了锁表的可能性。
3.表上加索引一般对查询有优化作用却影响写入速度,读写分离后可以单独对读库进行优化,写库上减少索引,对读写的能力都有提升,且读的提升更多一些。
缺点
1.主从数据延迟,导致业务数据无法保证强一致性
2.读写分离实现原理
读写分离的基本原理是将数据库读写操作分散到不同的节点上,下面是其基本架构图。
读写分离的基本实现是:
-
数据库服务器搭建主从集群,一主一从、一主多从都可以。
-
数据库主机负责读写操作,从机只负责读操作。
-
数据库主机通过复制将数据同步到从机,每台数据库服务器都存储了所有的业务数据。
-
业务服务器将写操作发给数据库主机,将读操作发给数据库从机。
需要注意的是,这里用的是“主从集群”,而不是“主备集群”。“从机”的“从”可以理解为“仆从”,仆从是要帮主人干活的,“从机”是需要提供读数据的功能的;而“备机”一般被认为仅仅提供备份功能,不提供访问功能。所以使用“主从”还是“主备”,是要看场景的,这两个词并不是完全等同的。
读写分离的实现逻辑并不复杂,但有两个细节点将引入设计复杂度:主从复制延迟和分配机制。
3.读写分离分配机制
1. jar包封装(推荐使用)
程序代码封装指在代码中抽象一个数据访问层(所以有的文章也称这种方式为“中间层封装”),实现读写操作分离和数据库服务器连接的管理。例如,基于 Hibernate 进行简单封装,就可以实现读写分离,基本架构是:
程序代码封装的方式具备几个特点:
-
实现简单,而且可以根据业务做较多定制化的功能。
-
每个编程语言都需要自己实现一次,无法通用,如果一个业务包含多个编程语言写的多个子系统,则重复开发的工作量比较大。
-
故障情况下,如果主从发生切换,则可能需要所有系统都修改配置并重启,在一主多从架构里,主备切换除了要把客户端流量切到备库外,还需要把从库接到新主库上。
目前开源的实现方案中,淘宝的 TDDL(Taobao Distributed Data Layer,外号: 头都大了)是比较有名的。它是一个通用数据访问层,所有功能封装在 jar 包中提供给业务代码调用。
其基本原理是一个基于集中式配置的 jdbc datasource 实现,具有主备、读写分离、动态数据库配置等功能,基本架构是:
类似的使用开源组件sharing-jdbc也可以实现数据库的读写分离控制。
2. 中间件封装(大厂才推荐用)
中间件封装指的是独立一套系统出来,实现读写操作分离和数据库服务器连接的管理。
中间件对业务服务器提供 SQL 兼容的协议,业务服务器无须自己进行读写分离。对于业务服务器来说,访问中间件和访问数据库没有区别,事实上在业务服务器看来,中间件就是一个数据库服务器。
其基本架构是:
数据库中间件的方式具备的特点是:
-
能够支持多种编程语言,因为数据库中间件对业务服务器提供的是标准 SQL 接口。
-
数据库中间件要支持完整的 SQL 语法和数据库服务器的协议(例如,MySQL 客户端和服务器的连接协议),实现比较复杂,细节特别多,很容易出现 bug,需要较长的时间才能稳定。
-
数据库中间件自己不执行真正的读写操作,但所有的数据库操作请求都要经过中间件,中间件的性能要求也很高。
-
数据库主从切换对业务服务器无感知,数据库中间件可以探测数据库服务器的主从状态。例如,向某个测试表写入一条数据,成功的就是主机,失败的就是从机。
数据库中间件的缺点:
- 使用代理加长了你的系统运行时数据库请求的调用链路,有一定的性能损失
-
代理服务本身也可能出现故障和性能瓶颈等问题,则系统全不可用
由于数据库中间件的复杂度要比程序代码封装高出一个数量级,一般情况下建议采用程序语言封装的方式,或者使用成熟的开源数据库中间件。
如果是大公司,可以投入人力去实现数据库中间件,因为这个系统一旦做好,接入的业务系统越多,节省的程序开发投入就越多,价值也越大。
目前的开源数据库中间件方案中,MySQL 官方先是提供了 MySQL Proxy,但 MySQL Proxy 一直没有正式 GA,现在 MySQL 官方推荐 MySQL Router。
MySQL Router 的主要功能有读写分离、故障自动切换、负载均衡、连接池等,其基本架构如下:
奇虎 360 公司也开源了自己的数据库中间件 Atlas,Atlas 是基于 MySQL Proxy 实现的,基本架构如下:
3. 纯手工方式
修改应用程序的 DAO 层代码,定义读写两个数据源,指定每一个数据库请求的数据源。
1.代理层实现读写分离原理
在进入Service之前,使用AOP来做出判断,是使用写库还是读库,判断依据
- 可以根据方法名判断,比如说以query、find、get等开头的就走读库,其他的走写库
- 拦截注解,这样是更细粒度的拦截如下面的方式
@Around("@annotation(readDatasource)")
public Object setReadDataSourceType(ProceedingJoinPoint pjp,ReadDatasource readDatasource) throws Throwable {
shardDataSourceAspect.before(pjp);
return pjp.proceed();
}
2.整合mybatis
用户自定义的读写控制逻辑类,需要继承org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource类,并实现protected abstract Object determineCurrentLookupKey()方法。
AbstractRoutingDataSource类选择数据源的总逻辑在determineTargetDataSource方法中,源码如下:
/**
* Retrieve the current target DataSource. Determines the
* {@link #determineCurrentLookupKey() current lookup key}, performs
* a lookup in the {@link #setTargetDataSources targetDataSources} map,
* falls back to the specified
* {@link #setDefaultTargetDataSource default target DataSource} if necessary.
* @see #determineCurrentLookupKey()
*/
protected DataSource determineTargetDataSource() {
Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
Object lookupKey = determineCurrentLookupKey();
DataSource dataSource = this.resolvedDataSources.get(lookupKey);
if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
dataSource = this.resolvedDefaultDataSource;
}
if (dataSource == null) {
throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
}
return dataSource;
}
4.读写分离主从延迟解决方案
下面的方案都会以牺牲性能或者其他功能来减少主从延迟,所以没有完全的解决方案,甚至可以进行方案的混合使用,比如,先在客户端对请求做分类,区分哪些请求可以接受过期读,而哪些请求完全不能接受过期读;然后,对于不能接受过期读的语句,再使用等 GTID 或等位点的方案。
建议部分核心功能可以从强制路由控制,这样才是真正的强一致性,但会增加主库的访问压力,所以对应的主库查询限流是很有必要的,主库是一定不能随便挂的,即使最后你做了主从自动切换那代价也是非常昂贵的。
1.强制路由主库(推荐使用)
对应一致性要求较高的读写请求,直接对主库读写。
强制走主库方案其实就是,将查询请求做分类。通常情况下,我们可以将查询请求分为这么两类:
-
对于必须要拿到最新结果的请求,强制将其发到主库上。比如,在一个交易平台上,卖家发布商品以后,马上要返回主页面,看商品是否发布成功。那么,这个请求需要拿到最新的结果,就必须走主库。
-
对于可以读到旧数据的请求,才将其发到从库上。在这个交易平台上,买家来逛商铺页面,就算晚几秒看到最新发布的商品,也是可以接受的。那么,这类请求就可以走从库。
你可能会说,这个方案是不是有点畏难和取巧的意思,但其实这个方案是用得最多的。
当然,这个方案最大的问题在于,有时候你会碰到“所有查询都不能是过期读”的需求,比如一些金融类的业务。这样的话,你就要放弃读写分离,所有读写压力都在主库,等同于放弃了扩展性。
因此接下来,我们来讨论的话题是:可以支持读写分离的场景下,有哪些解决过期读的方案,并分析各个方案的优缺点。
2.读取入库之前的数据(推荐使用)
将要准备入库的数据,先不提交事务,如设置在上下文内存中,读的时候读内存而不是读数据库已经插入的数据,且后面如果涉及到插入的场景同之前的数据控制一个事务中。
这样是一个好的习惯,读内存不仅能提升性能同时一旦之前没有做主从同步的切换到主从架构模式后,代码也是0改动的。
3.引入缓存作为中间态
数据库的写操作,先写数据库,再写cache,但是有效期很短,就比主从延时的时间略微长一点。然后读请求的时候,先读缓存,缓存存在则直接返回。假如缓存不存在(这时主从同步已经完成),再读数据库。
引用这种方案还可以减少数据库的访问压力,对于一些热点数据,可以参考使用这种方案。
但这种开发模式代码的复杂度增高,一般不推荐使用。
4.Sleep 方案
主库更新后,读从库之前先 sleep 一下。具体的方案就是,类似于执行一条 select sleep(1) 命令。
其实和引入缓存作为中间态有一些类似
这个方案的假设是,大多数情况下主备延迟在 1 秒之内,做一个 sleep 可以有很大概率拿到最新的数据。
这个方案给你的第一感觉,很可能是不靠谱儿,应该不会有人用吧?并且,你还可能会说,直接在发起查询时先执行一条 sleep 语句,用户体验很不友好啊。
但,这个思路确实可以在一定程度上解决问题。为了看起来更靠谱儿,我们可以换一种方式。
以卖家发布商品为例,商品发布后,用 Ajax(Asynchronous JavaScript + XML,异步 JavaScript 和 XML)直接把客户端输入的内容作为“新的商品”显示在页面上,而不是真正地去数据库做查询。
这样,卖家就可以通过这个显示,来确认产品已经发布成功了。等到卖家再刷新页面,去查看商品的时候,其实已经过了一段时间,也就达到了 sleep 的目的,进而也就解决了过期读的问题。
也就是说,这个 sleep 方案确实解决了类似场景下的过期读问题。但,从严格意义上来说,这个方案存在的问题就是不精确。这个不精确包含了两层意思:
-
如果这个查询请求本来 0.5 秒就可以在从库上拿到正确结果,也会等 1 秒;
-
如果延迟超过 1 秒,还是会出现过期读。
看到这里,你是不是有一种“你是不是在逗我”的感觉,这个改进方案虽然可以解决类似 Ajax 场景下的过期读问题,但还是怎么看都不靠谱儿。
5.判断主备无延迟方案
这种方案可以作为一个降级方案,即如果没有主备延迟,则查备库,有则查主库。则在一定程度能降低查询主库的访问压力,但判断是否主备无延迟是一个非常底层的操作,一般建议由专业的DBA团队抽象成中间件供业务团队使用和统一维护。
要确保备库无延迟,通常有三种做法。
我们知道 show slave status 结果里的 seconds_behind_master 参数的值,可以用来衡量主备延迟时间的长短。
所以第一种确保主备无延迟的方法是,每次从库执行查询请求前,先判断 seconds_behind_master 是否已经等于 0。如果还不等于 0 ,那就必须等到这个参数变为 0 才能执行查询请求。
seconds_behind_master 的单位是秒,如果你觉得精度不够的话,还可以采用对比位点和 GTID 的方法来确保主备无延迟,也就是我们接下来要说的第二和第三种方法。
如图 3 所示,是一个 show slave status 结果的部分截图。
图 3 show slave status 结果
现在,我们就通过这个结果,来看看具体如何通过对比位点和 GTID 来确保主备无延迟。
第二种方法,对比位点确保主备无延迟:
- Master_Log_File 和 Read_Master_Log_Pos,表示的是读到的主库的最新位点;
- Relay_Master_Log_File 和 Exec_Master_Log_Pos,表示的是备库执行的最新位点。
如果 Master_Log_File 和 Relay_Master_Log_File、Read_Master_Log_Pos 和 Exec_Master_Log_Pos 这两组值完全相同,就表示接收到的日志已经同步完成。
第三种方法,对比 GTID 集合确保主备无延迟:
- Auto_Position=1 ,表示这对主备关系使用了 GTID 协议。
- Retrieved_Gtid_Set,是备库收到的所有日志的 GTID 集合;
- Executed_Gtid_Set,是备库所有已经执行完成的 GTID 集合。
如果这两个集合相同,也表示备库接收到的日志都已经同步完成。
可见,对比位点和对比 GTID 这两种方法,都要比判断 seconds_behind_master 是否为 0 更准确。
在执行查询请求之前,先判断从库是否同步完成的方法,相比于 sleep 方案,准确度确实提升了不少,但还是没有达到“精确”的程度。
为什么这么说呢?
我们现在一起来回顾下,一个事务的 binlog 在主备库之间的状态:
-
主库执行完成,写入 binlog,并反馈给客户端;
-
binlog 被从主库发送给备库,备库收到;
-
在备库执行 binlog 完成。
我们上面判断主备无延迟的逻辑,是“备库收到的日志都执行完成了”。但是,从 binlog 在主备之间状态的分析中,不难看出还有一部分日志,处于客户端已经收到提交确认,而备库还没收到日志的状态。
如图 4 所示就是这样的一个状态。
图 4 备库还没收到 trx3
这时,主库上执行完成了三个事务 trx1、trx2 和 trx3,其中:
-
trx1 和 trx2 已经传到从库,并且已经执行完成了;
-
trx3 在主库执行完成,并且已经回复给客户端,但是还没有传到从库中。
如果这时候你在从库 B 上执行查询请求,按照我们上面的逻辑,从库认为已经没有同步延迟,但还是查不到 trx3 的。严格地说,就是出现了过期读。
那么,这个问题有没有办法解决呢
1.配合 semi-sync方案
要解决这个问题,就要引入半同步复制,也就是 semi-sync replication。
semi-sync 做了这样的设计:
-
事务提交的时候,主库把 binlog 发给从库;
-
从库收到 binlog 以后,发回给主库一个 ack,表示收到了;
-
主库收到这个 ack 以后,才能给客户端返回“事务完成”的确认。
也就是说,如果启用了 semi-sync,就表示所有给客户端发送过确认的事务,都确保了备库已经收到了这个日志。
有同学问到:如果主库掉电的时候,有些 binlog 还来不及发给从库,会不会导致系统数据丢失?
答案是,如果使用的是普通的异步复制模式,就可能会丢失,但 semi-sync 就可以解决这个问题。
这样,semi-sync 配合前面关于位点的判断,就能够确定在从库上执行的查询请求,可以避免过期读。
但是,semi-sync+ 位点判断的方案,只对一主一备的场景是成立的。在一主多从场景中,主库只要等到一个从库的 ack,就开始给客户端返回确认。这时,在从库上执行查询请求,就有两种情况:
-
如果查询是落在这个响应了 ack 的从库上,是能够确保读到最新数据;
-
但如果是查询落到其他从库上,它们可能还没有收到最新的日志,就会产生过期读的问题。
其实,判断同步位点的方案还有另外一个潜在的问题,即:如果在业务更新的高峰期,主库的位点或者 GTID 集合更新很快,那么上面的两个位点等值判断就会一直不成立,很可能出现从库上迟迟无法响应查询请求的情况。
实际上,回到我们最初的业务逻辑里,当发起一个查询请求以后,我们要得到准确的结果,其实并不需要等到“主备完全同步”。
为什么这么说呢?我们来看一下这个时序图。
图 5 主备持续延迟一个事务
图 5 所示,就是等待位点方案的一个 bad case。
图中备库 B 下的虚线框,分别表示 relaylog 和 binlog 中的事务。可以看到,图 5 中从状态 1 到状态 4,一直处于延迟一个事务的状态。
备库 B 一直到状态 4 都和主库 A 存在延迟,如果用上面必须等到无延迟才能查询的方案,select 语句直到状态 4 都不能被执行。
但是,其实客户端是在发完 trx1 更新后发起的 select 语句,我们只需要确保 trx1 已经执行完成就可以执行 select 语句了。也就是说,如果在状态 3 执行查询请求,得到的就是预期结果了。
到这里,我们小结一下,semi-sync 配合判断主备无延迟的方案,存在两个问题:
-
一主多从的时候,在某些从库执行查询请求会存在过期读的现象;
-
在持续延迟的情况下,可能出现过度等待的问题。
接下来,我要和你介绍的等主库位点方案,就可以解决这两个问题。
2.等主库位点方案
要理解等主库位点方案,我需要先和你介绍一条命令:
|
这条命令的逻辑如下:
-
它是在从库执行的;
-
参数 file 和 pos 指的是主库上的文件名和位置;
-
timeout 可选,设置为正整数 N 表示这个函数最多等待 N 秒。
这个命令正常返回的结果是一个正整数 M,表示从命令开始执行,到应用完 file 和 pos 表示的 binlog 位置,执行了多少事务。
当然,除了正常返回一个正整数 M 外,这条命令还会返回一些其他结果,包括:
-
如果执行期间,备库同步线程发生异常,则返回 NULL;
-
如果等待超过 N 秒,就返回 -1;
-
如果刚开始执行的时候,就发现已经执行过这个位置了,则返回 0。
对于图 5 中先执行 trx1,再执行一个查询请求的逻辑,要保证能够查到正确的数据,我们可以使用这个逻辑:
-
trx1 事务更新完成后,马上执行 show master status 得到当前主库执行到的 File 和 Position;
-
选定一个从库执行查询语句;
-
在从库上执行 select master_pos_wait(File, Position, 1);
-
如果返回值是 >=0 的正整数,则在这个从库执行查询语句;
-
否则,到主库执行查询语句。
我把上面这个流程画出来。
图 6 master_pos_wait 方案
这里我们假设,这条 select 查询最多在从库上等待 1 秒。那么,如果 1 秒内 master_pos_wait 返回一个大于等于 0 的整数,就确保了从库上执行的这个查询结果一定包含了 trx1 的数据。
步骤 5 到主库执行查询语句,是这类方案常用的退化机制。因为从库的延迟时间不可控,不能无限等待,所以如果等待超时,就应该放弃,然后到主库去查。
你可能会说,如果所有的从库都延迟超过 1 秒了,那查询压力不就都跑到主库上了吗?确实是这样。
但是,按照我们设定不允许过期读的要求,就只有两种选择,一种是超时放弃,一种是转到主库查询。具体怎么选择,就需要业务开发同学做好限流策略了。
3.等GTID方案
如果你的数据库开启了 GTID 模式,对应的也有等待 GTID 的方案。
MySQL 中同样提供了一个类似的命令:
|
这条命令的逻辑是:
-
等待,直到这个库执行的事务中包含传入的 gtid_set,返回 0;
-
超时返回 1。
在前面等位点的方案中,我们执行完事务后,还要主动去主库执行 show master status。而 MySQL 5.7.6 版本开始,允许在执行完更新类事务后,把这个事务的 GTID 返回给客户端,这样等 GTID 的方案就可以减少一次查询。
这时,等 GTID 的执行流程就变成了:
-
trx1 事务更新完成后,从返回包直接获取这个事务的 GTID,记为 gtid1;
-
选定一个从库执行查询语句;
-
在从库上执行 select wait_for_executed_gtid_set(gtid1, 1);
-
如果返回值是 0,则在这个从库执行查询语句;
-
否则,到主库执行查询语句。
跟等主库位点的方案一样,等待超时后是否直接到主库查询,需要业务开发同学来做限流考虑。
我把这个流程图画出来。
图 7 wait_for_executed_gtid_set 方案
在上面的第一步中,trx1 事务更新完成后,从返回包直接获取这个事务的 GTID。问题是,怎么能够让 MySQL 在执行事务后,返回包中带上 GTID 呢?
你只需要将参数 session_track_gtids 设置为 OWN_GTID,然后通过 API 接口 mysql_session_track_get_first 从返回包解析出 GTID 的值即可。
参考资料
1.极客时间《MySQL实战45讲》
2.《MySQL技术内幕:InnoDB存储引擎(第2版)》