kafka副本高可用机制

Kafka的每个topic都可以分为多个Partition，并且多个 partition 会均匀分布在集群的各个节点下。虽然这种方式能够有效的对数据进行分片，但是对于每个partition 来说，都是单点的，当其中一个 partition 不可用的时候，那么这部分消息就没办法消费。所以 kafka 为了提高 partition 的可靠性而提供了副本的概念（Replica）,通过副本机制来实现冗余备份。每个分区可以有多个副本，并且在副本集合中会存在一个leader 的副本，所有的读写请求都是由 leader 副本来进行处理。剩余的其他副本都做为 follower 副本，follower 副本会从 leader 副本同步消息日志。这个有点类似zookeeper 中 leader 和 follower 的概念，但是具体的实现方式还是有比较大的差异。所以我们可以认为，副本集会存在一主多从的关系。一般情况下，同一个分区的多个副本会被均匀分配到集群中的不同 broker 上，当 leader 副本所在的 broker 出现故障后，可以重新选举新的 leader 副本继续对外提供服务。通过这样的副本机制来提高 kafka 集群的可用性。

副本分配算法:

将所有 N Broker 和待分配的 i 个 Partition 排序.
将第 i 个 Partition 分配到第(i mod n)个 Broker 上.
将第 i 个 Partition 的第 j 个副本分配到第((i + j) mod n)个Broker 上.

运行如下命令创建一个带副本的主题

./kafka-topics.sh  --create  --zookeeper 192.168.11.156:2181 --replication-factor 2 --partitions 3 --
topic secondTopic

然后我们可以在/tmp/kafka-log 路径下看到对应 topic 的副本的保存信息。如下图:

在 zookeeper 服务器上，通过如下命令去获取对应分区的信息, 比如下面这个是获取 secondTopic 第 1 个分区的状态信息。

get /brokers/topics/secondTopic/partitions/1/state
 {"controller_epoch":12,"leader":0,"version":1,"leader_ep    och":0,"isr":[0,1]}

leader 表示当前分区副本中的 leader 所在的 broker 的brokerid。 下图中绿色线条的表示该分区中的 leader 节点。其他节点就为follower

副本协同机制：

概念介绍：

leader 副本：响应 clients 端读写请求的副本
follower 副本：被动地备份 leader 副本中的数据，不能响应 clients 端读写请求。
ISR 副本：包含了 leader 副本和所有与 leader 副本保持同步的 follower 副本。
LEO：日志末端位移(log end offset)，记录了该副本底层日志(log)中下一条消息的位移值。注意是下一条消息！也就是说，如果 LEO=10，那么表示该副本保存了 10 条消息， 位移值范围是[0, 9]。
HW：即上面提到的水位值。对于同一个副本对象而言，其HW 值不会大于 LEO 值。小于等于 HW 值的所有消息都被认为是“已备份”的（replicated）。

每个 Kafka 副本对象都有两个重要的属性：LEO 和HW，但是leader副本和follower副本这两个值的更新方式不同

ISR ：表示目前“可用且消息量与 leader 相差不多的副本集合，这是整个副本集合的一个子集”。怎么去定义可用和相差不多呢？ISR 集合中的副本必须满足两个条件
1. 副本所在节点必须维持着与 zookeeper 的连接
2. 副本最后一条消息的 offset 与 leader 副本的最后一条消息的 offset 之 间 的 差 值 不 能 超 过 指 定 的 阈 值(replica.lag.time.max.ms)如果该 follower 在此时间间隔内一直没有追上过 leader 的所有消息，则该 follower 就会被剔除 isr 列表。 ISR 数 据 保 存 在 Zookeeper 的/brokers/topics//partitions//state 节点中
ISR 中剔除掉队的副本有一个好处就是不必等待低效率的副本，从而提高效率。

副本数据同步过程

Producer 在发布 消 息 到 某个 Partition 时， 先 通 过ZooKeeper 找 到 该 Partition 的 Leader 【 get/brokers/topics//partitions/2/state】，然后无论该Topic 的 Replication Factor 为多少（也即该 Partition 有多少个 Replica），Producer 只将该消息发送到该Partition 的Leader。Leader会将该消息写入其本地Log。每个Follower都从 Leader pull 数据。这样，Follower 存储的数据顺序与 Leader 保持一致。Follower 在收到该消息并写入其Log 后，向 Leader 发送 ACK。一旦 Leader 收到了 ISR 中的所有 Replica 的 ACK，该消息就被认为已经 commit 了，Leader 将增加 HW( HighWatermark )并且向 Producer 发送ACK。

初始状态下，leader 和 follower 的 HW 和 LEO 都是 0，leader 副本会保存 remote LEO，表示所有 follower LEO，也会被初始化为 0，这个时候，producer 没有发送消息。follower 会不断向 leader 发送 FETCH 请求，但是因为没有数据，这个请求会被 leader 阻塞，当在指定的时间之后会 强 制 完 成 请 求 ， 这 个 时 间 配 置 是(replica.fetch.wait.max.ms)，如果在指定时间内 producer有消息发送过来，那么 kafka 会唤醒 fetch 请求，让 leader继续处理

这里会分两种情况，第一种是 leader 处理完 producer 请求之后，follower 发送一个 fetch 请求过来、第二种是follower 阻塞在 leader 指定时间之内，leader 副本收到producer 的请求。这两种情况下处理方式是不一样的。
第一种：follower 的 fetch 请求是当 leader 接收到新消息的情况（不阻塞的情况）,如下图：

leader 副本收到producer的请求，会做几件事情
1. 把消息追加到 log 文件，同时更新 leader 副本的 LEO
2. 尝试更新 leader HW 值。这个时候由于 follower 副本还 没有发送 fetch 请求，那么 leader 的 remote LEO 仍然是 0。leader 会比较自己的 LEO 以及 remote LEO 的值发现最小值是 0，与 HW 的值相同，所以不会更新 HW

follower fetch 消息

follower 发送 fetch 请求，leader 副本的处理逻辑是:
1. 读取 log 数据、更新 remote LEO=0(follower 还没有写入这条消息，这个值是根据 follower 的 fetch 请求中的offset 来确定的)
2. 尝试更新 HW，因为这个时候 LEO 和 remoteLEO 还是不一致，所以仍然是 HW=0
3. 把消息内容和当前分区的 HW 值发送给 follower
副本follower 副本收到 response 以后副本follower 副本收到 response 以后
1. 将消息写入到本地 log，同时更新 follower 的 LEO
2. 更新 follower HW，本地的 LEO 和 leader 返回的 HW进行比较取小的值，所以仍然是 0

第一次交互结束以后，HW 仍然还是 0，这个值会在下一次 follower 发起 fetch 请求时被更新，如下：

leader 收到follower第二次请求以后
1. 读取 log 数据
2. 更新 remote LEO=1， 因为这次 fetch 携带的 offset 是1
3. 更新当前分区的 HW，这个时候 leader LEO 和 remote 更新当前分区的 HW，这个时候 leader LEO 和 remoteLEO 都是 1，所以 HW 的值也更新为 1
4. 把数据和当前分区的 HW 值返回给 follower 副本，这个时候如果没有数据，则返回为空

follower 副本收到 response 以后
1. 如果有数据则写本地日志，并且更新 LEO
2. 更新 follower 的 HW 值

到目前为止，数据的同步就完成了，意味着消费端能够消费 offset=0 这条消息。

第二种：follower 的 h fetch 请求是直接从 阻塞过程中触发
当 leader 收到producer的请求以后会唤醒处于阻塞的fetch 请求。后续处理过程和上边一致
1. leader 将消息写入本地日志，更新 Leader 的 LEO
2. 唤醒 follower 的 fetch 请求
3. 更新 HW

数据丢失的问题

当min.insync.replicas=1 （设定 ISR 中的最小副本数是多少，默认值为 1）的时候。当且仅当 acks 参数设置为-1（表示需要所有【isr中的】副本确认）时，此参数才生效. 表达的含义是，至少需要多少个副本同步才能表示消息是提交的。一旦消息被写入 leader 端 log 即被认为是“已提交”，而延迟一轮 FETCH 更新 HW 值的设计，使得 follower HW值是异步延迟更新的，倘若在这个过程中leader发生变更，那么成为新 leader 的 follower 的 HW 值就有可能是过期的，使得 clients 端认为是未成功提交的消息被删除。详细过程如下图：

数据丢失的解决方案

在 kafka0.11.0.0 版本以后，提供了一个新的解决方案，使用 leader epoch 来解决这个问题，leader epoch 实际上是一对(epoch,offset), epoch 表示 leader 的版本号，从 0开始，当 leader 变更过 1 次时 epoch 就会+1，而 offset 则对应于该 epoch 版本的 leader 写入第一条消息的位移。比如说(0,0) ; (1,50); 表示第一个 leader 从 offset=0 开始写消息，一共写了 50 条，第二个 leader 版本号是 1，从 50 条处开始写消息。这个信息保存在对应分区的本地磁盘文件中，文 件 名 为 ： /tml/kafka-log/topic/leader-epoch-checkpoint (leader broker 中会保存这样的一个缓存，并定期地写入到一个 checkpoint 文件中。)当 leader 写 log 时它会尝试更新整个缓存——如果这个leader 首次写消息，则会在缓存中增加一个条目；否则就不做更新。而每次副本重新成为 leader 时会查询这部分缓存，获取出对应 leader 版本的 offset

ISR 的设计原理

在所有的分布式存储中，冗余备份是一种常见的设计方式，而常用的模式有同步复制和异步复制，按照 kafka 这个副本模型来说如果采用同步复制，那么需要要求所有能工作的 Follower 副本都复制完，这条消息才会被认为提交成功，一旦有一个follower 副本出现故障，就会导致 HW 无法完成递增，消息就无法提交，消费者就获取不到消息。这种情况下，故障的Follower 副本会拖慢整个系统的性能，甚至导致系统不可用
如果采用异步复制，leader 副本收到生产者推送的消息后，就认为次消息提交成功。follower 副本则异步从 leader 副本同步。这种设计虽然避免了同步复制的问题，但是假设所有follower 副本的同步速度都比较慢他们保存的消息量远远落后于 leader 副本。而此时 leader 副本所在的 broker 突然宕机，则会重新选举新的 leader 副本，而新的 leader 副本中没有原来 leader 副本的消息。这就出现了消息的丢失。kafka 权衡了同步和异步的两种策略，采用 ISR 集合，巧妙解决了两种方案的缺陷：当 follower 副本延迟过高，leader 副本则会把该 follower 副本提出 ISR 集合，消息依然可以快速提交。当 leader 副本所在的 broker 突然宕机，会优先将 ISR 集合中follower 副本选举为 leader，新 leader 副本包含了 HW 之前的全部消息，这样就避免了消息的丢失。

如何处理所有的 Replica 不工作的情况

在 ISR 中至少有一个 follower 时，Kafka 可以确保已经commit 的数据不丢失，但如果某个 Partition 的所有Replica 都宕机了，就无法保证数据不丢失了。两种处理策略：

1. 等待 ISR 中的任一个 Replica“活”过来，并且选它作为Leader
2. 选择第一个“活”过来的 Replica（不一定是 ISR 中的）作为 Leader
   这就需要在可用性和一致性当中作出一个简单的折衷。如果一定要等待 ISR 中的 Replica“活”过来，那不可用的时间就可能会相对较长。而且如果 ISR 中的所有 Replica 都无法“活”过来了，或者数据都丢失了，这个 Partition 将永远不可用。选择第一个“活”过来的 Replica 作为 Leader，而这个Replica 不是 ISR 中的 Replica，那即使它并不保证已经包含了所有已 commit 的消息，它也会成为 Leader 而作为consumer 的数据源