（21）主备一致性与主备切换策略

MySQL 主备的基本原理

如图 所示就是基本的主备切换流程，是一个M-S结构（master-slave）

在状态 1 中，客户端的读写都直接访问节点 A ，而节点 B 是 A 的备库，只是将 A 的更新都同步过来，到本地执行。这样可以保持节点 B 和 A 的数据是相同的。

当需要切换的时候，就切成状态 2 。这时候客户端读写访问的都是节点 B ，而节点 A 是 B 的备库。

在状态 1 中，虽然节点 B 没有被直接访问，但是我依然建议你把节点 B （也就是备库）设置成只读（ readonly ）模式。这样做，有以下几个考虑：
1.  有时候一些运营类的查询语句会被放到备库上去查，设置为只读可以防止误操作；
2.  防止切换逻辑有 bug ，比如切换过程中出现双写，造成主备不一致；
3.  可以用 readonly 状态，来判断节点的角色。

把备库设置成只读，不影响跟主库的同步更新

因为 readonly 设置对超级 (super) 权限用户是无效的，而用于同步更新的线程，就拥有超级权限。

看 节点 A A 到 B B 这条线的内部流程是什么样的

备库 B 跟主库 A 之间维持了一个长连接。主库 A 内部有一个线程，专门用于服务备库 B 的这个长连接。一个事务日志同步的完整过程是这样的：
1.  在备库 B 上通过 change master 命令，设置主库 A 的 IP 、端口、用户名、密码，以及要从哪个位置开始请求 binlog ，这个位置包含文件名和日志偏移量。
2.  在备库 B 上执行 start slave 命令，这时候备库会启动两个线程，就是图中的 io_thread 和sql_thread 。其中 io_thread 负责与主库建立连接。
3.  主库 A 校验完用户名、密码后，开始按照备库 B 传过来的位置，从本地读取 binlog ，发给 B 。
4.  备库 B 拿到 binlog 后，写到本地文件，称为中转日志（ relay log ）。
5. sql_thread 读取中转日志，解析出日志里的命令，并执行。

循环复制问题

上面的原理中我们使用的M-S结构，但实际生产上使用比较多的是双 M 结构，如下图的主备切换流程：

节点 A 和 B之间总是互为主备关系。这样在切换的时候就不用再修改主备关系。

但是，双 M 结构还有一个问题需要解决。业务逻辑在节点 A 上更新了一条语句，然后再把生成的 binlog  发给节点 B ，节点 B 执行完这条更新语句后也会生成 binlog 。

那么，如果节点 A 同时是节点 B 的备库，相当于又把节点 B 新生成的 binlog 拿过来执行了一次，然后节点 A 和 B 间，会不断地循环执行这个更新语句，也就是循环复制了。

MySQL 在 binlog 中记录了这个命令第一次执行时所在实例的 serverid 。因此，我们可以用下面的逻辑，来解决两个节点间的循环复制的问题：
1.  规定两个库的 server id 必须不同，如果相同，则它们之间不能设定为主备关系；
2.  一个备库接到 binlog 并在重放的过程中，生成与原 binlog 的 server id 相同的新的 binlog ；
3.  每个库在收到从自己的主库发过来的日志后，先判断 server id ，如果跟自己的相同，表示这个日志是自己生成的，就直接丢弃这个日志。

按照这个逻辑，如果我们设置了双 M 结构，日志的执行流就会变成这样：
1.  从节点 A 更新的事务， binlog 里面记的都是 A 的 server id ；
2.  传到节点 B 执行一次以后，节点 B 生成的 binlog  的 server id 也是 A 的 server id ；
3.  再传回给节点 A ， A 判断到这个 server id 与自己的相同，就不会再处理这个日志。所以，死循环在这里就断掉了。

双 M 结构会出现循环复制的情况：

一种场景是，在一个主库更新事务后，用命令 set global server_id=x 强制修改了 server_id 。等日志再传回来的时候，发现 server_id 跟自己的 server_id 不同，就只能执行了。

另一种场景是，有三个节点的时候：

trx1 是在节点 B 执行的，因此 binlog 上的server_id 就是 B ， binlog 传给节点 A ，然后 A 和 A’ 搭建了双 M 结构，就会出现循环复制。

 

主备延迟

与数据同步有关的时间点主要包括以下三个：
1.  主库 A 执行完成一个事务，写入 binlog ，我们把这个时刻记为 T1;
2.  之后传给备库 B ，我们把备库 B 接收完这个 binlog 的时刻记为 T2;
3.  备库 B 执行完成这个事务，我们把这个时刻记为 T3 。

所谓主备延迟，就是同一个事务，在备库执行完成的时间和主库执行完成的时间之间的差值，也就是 T3-T1 。

在网络正常的时候，日志从主库传给备库所需的时间是很短的，即 T2-T1 的值是非常小的。也就是说，网络正常情况下，主备延迟的主要来源是备库接收完 binlog 和执行完这个事务之间的时间差。

在备库上执行 show slave status 命令，它的返回结果里面会显示seconds_behind_master ，用于表示当前备库延迟了多少秒，就是T3-T1的值。

所以说，主备延迟最直接的表现是，备库消费中转日志（ relay log ）的速度，比主库生产 binlog的速度要慢

主备延迟的来源

首先，有些部署条件下，备库所在机器的性能要比主库所在的机器性能差。

第二种常见的可能了，即备库的压力大。主库既然提供了写能力，那么备库可以提供一些读能力。由于主库直接影响业务，大家使用起来会比较克制，反而忽视了备库的压力控制。结果就是，备库上的查询耗费了大量的 CPU 资源，影响了同步速度

这种情况，我们一般可以这么处理：
1.  一主多从。除了备库外，可以多接几个从库，让这些从库来分担读的压力。这是最常用的
2.  通过 binlog 输出到外部系统，比如 Hadoop 这类系统，让外部系统提供统计类查询的能力。

这里需要说明一下，从库和备库在概念上其实差不多。为了方便描述，我把会在 HA 主备切换过程中被选成新主库的，称为备库，其他的称为从库。

这就是第三种可能了，即大事务。因为主库上必须等事务执行完成才会写入 binlog ，再传给备库。所以，如果一个主库上的语句执行 10 分钟，那这个事务很可能就会导致从库延迟 10 分钟。

一个典型的大事务场景，就是一次性地用 delete 语句删除太多数据

由于主备延迟的存在，所以在主备切换的时候，就相应的有不同的策略。

主备切换策略-可靠性优先

在双M结构下，切换流程由专门的 HA 系统来完成的，图中的SBM即为 seconds_behind_master 参数的简写。

1.  判断备库 B 现在的 seconds_behind_master ，如果小于某个值（比如 5 秒）继续下一步，否则持续重试这一步；
2.  把主库 A 改成只读状态，即把 readonly 设置为 true ；
3.  判断备库 B 的 seconds_behind_master 的值，直到这个值变成 0 为止；
4.  把备库 B 改成可读写状态，也就是把 readonly  设置为 false ；
5.  把业务请求切到备库 B 。

这个切换流程中是有不可用时间的。因为在步骤 2 之后，主库 A 和备库 B 都处于readonly 状态，也就是说这时系统处于不可写状态，直到步骤 5 完成后才能恢复。同时，步骤3可能要耗费好几秒时间，这也就是为什么步骤1要先判断，确保 seconds_behind_master 的值足够小

主备切换策略-可用性优先策略

在可靠性优先策略中存在系统的不可用时间，你也可以选择可用性优先的策略，来把这个不可用时间几乎降为 0 。

如果我强行把步骤 4 、 5 调整到最开始执行，也就是说不等主备数据同步，直接把连接切到备库B ，并且让备库 B 可以读写，那么系统几乎就没有不可用时间了。代价就是：可能出现数据不一致情况

举可用性优先流程产生数据不一致的例子，假设有一个表 t ：

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

主库和备库上都是 3 行数据，接下来，业务人员要继续在表 t 上执行两条插入语句的命令

nsert into t(c) values(4);
insert into t(c) values(5);

假设，现在主库上其他的数据表有大量的更新，导致主备延迟达到 5 秒，在插入一条 c=4 的语句后，发起了主备切换

下图为可用性策略，且 binlog_format=mixed 时的切换流程和数据结果。

现在，我们一起分析下这个切换流程：
1.  步骤 2 中，主库 A 执行完 insert 语句，插入了一行数据（ 4,4 ），之后使用可用性策略开始进行主备切换。不等主备数据同步，直接把连接切到备库B ，并且让备库 B 可以读写
2.  步骤 3 中，主备切换完成。由于主备之间有 5 秒的延迟，也就是说备库B执行完中转日志的事务后与主库执行完该事务差了5秒，

所以在这5秒内，备库 B 还没来得及应用 “ 插入 c=4” 这个中转日志，就开始接收客户端 “ 插入 c=5” 的命令。
3.  步骤 4 中，备库 B 插入了一行数据（ 4,5 ），并且把这个 binlog 发给主库 A 。
4.  步骤 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) 这两行数据，都不会被对方执行。

使用 row 格式的 binlog 时，数据不一致的问题更容易被发现。大多数情况下，我都建议你使用可靠性优先策略。毕竟对数据服务来说的话，数据的可靠性一般还是要优于可用性的