Kafka 可靠传输

目录

• 1. 消息不丢失
  • 1.1. 存储阶段
    • 1.1.1. 副本机制
      • 1.1.1.1. 副本数
      • 1.1.1.2. 不完全的选主
      • 1.1.1.3. 最少同步副本
  • 1.2. 生产阶段
    • 1.2.1. ACK
    • 1.2.2. 重试
    • 1.2.3. 错误处理
  • 1.3. 消费阶段
    • 1.3.1. 消费者的可靠性配置
    • 1.3.2. 显式提交偏移量
• 2. 重复消息
  • 2.1. 幂等性保证
    • 2.1.1. 生产过程中的幂等性
    • 2.1.2. 消费过程中的幂等性
      • • 2.1.2.1 利用数据库的唯一约束实现幂等
        • 2.1.2.2 为更新的数据设置前置条件
          • 2.1.2.2.1. CAS 操作
          • 2.1.2.2.2. 为数据设置版本号
        • 2.1.2.3. 记录并检查操作
• 3. 消息的有序性
  • 3.1. 方案一：单 Partition
  • 3.2. 方案二：同一个 key 的消息发送给指定 Partition
• 4. 消息积压
• 5. 验证系统可靠性
• 6. 最佳实践
  • 6.1. 生产者
  • 6.2. 服务器（Kafka Broker）
  • 6.3. 消费者

1. 消息不丢失

如何保证消息的可靠性传输，或者说，如何保证消息不丢失？这对于任何 MQ 都是核心问题。

一条消息从生产到消费，可以划分三个阶段：

• 生产阶段：Producer 创建消息，并通过网络发送给 Broker。

• 存储阶段：Broker 收到消息并存储，如果是集群，还要同步副本给其他 Broker。

• 消费阶段：Consumer 向 Broker 请求消息，Broker 通过网络传输给 Consumer。

这三个阶段都可能丢失数据，所以要保证消息丢失，就需要任意一环都保证可靠。

1.1. 存储阶段

存储阶段指的是 Kafka Server，也就是 Broker 如何保证消息不丢失。

一句话概括，Kafka 只对“已提交”的消息（committed message）做有限度的持久化保证。

上面的话可以解读为：

• 已提交：当 Kafka 的若干个 Broker 成功地接收到一条消息并写入到日志文件后，才被认为是已提交的；

  为什么是若干个 Broker 呢？

  这取决于你对“已提交”的定义，你可以选择只要 Leader 成功保存该消息就算是已提交，也可以是令所有 Broker 都成功保存该消息才算是已提交。

  不论哪种情况，Kafka 只对已提交的消息做持久化保证这件事情是不变的。

• 持久化：Kafka 的数据存储在磁盘上，所以，只要写入成功，天然就是持久化的；

• 至少有一个 Broker 是存活的；

  只要这个条件成立，Kafka 就能保证你的这条消息永远不会丢失。

• 消费者只能读取已提交的消息。

1.1.1. 副本机制

Kafka 的副本机制是 kafka 可靠性保证的核心。

Kafka 的主题被分为多个分区，分区是基本的数据块。每个分区可以有多个副本，有一个是 Leader（主副本），其他是 Follower（从副本）。所有数据都直接发送给 Leader，或者直接从 Leader 读取事件。Follower 只需要与 Leader 保持同步，并及时复制最新的数据。当 Leader 宕机时，从 Follower 中选举一个成为新的 Leader。

Broker 有 3 个配置参数会影响 Kafka 消息存储的可靠性。

1.1.1.1. 副本数

replication.factor 的作用是设置每个分区的副本数。replication.factor 是主题级别配置； default.replication.factor 是 broker 级别配置。

副本数越多，数据可靠性越高；但由于副本数增多，也会增加同步副本的开销，可能会降低集群的可用性。

一般情况下，每个分区的副本数建议设为 3，这也是 Kafka 的默认值。

1.1.1.2. 不完全的选主

unclean.leader.election.enable 用于控制是否支持不同步的副本参与选举 Leader。unclean.leader.election.enable 是 broker 级别（实际上是集群范围内）配置，默认值为 true。

• 如果设为 true，代表着允许不同步的副本成为主副本（即不完全的选举），那么将面临丢失消息的风险；

• 如果设为 false，就要等待原先的主副本重新上线，从而降低了可用性。

1.1.1.3. 最少同步副本

min.insync.replicas 控制的是消息至少要被写入到多少个副本才算是“已提交”。min.insync.replicas 是主题级别和 broker 级别配置。

• 减小 min.insync.replicas 的值，一定程度上增加了系统的可用性，允许 kafka 出现更多的副本 broker crash 并且服务正常运行，但是降低了数据可靠性，可能会丢数据；

• 增大 min.insync.replicas 的值，一定程度上增加了数据的可靠性，允许一些broker crash掉，且不会丢失数据（只要再次选举的 leader 是从 ISR 中选举的就行），但是降低了系统的可用性，会允许更少的 broker crash。

如果要确保已经提交的数据被已写入不止一个副本，就需要把最小同步副本的设置为大一点的值。

注意：要确保 replication.factor > min.insync.replicas。如果两者相等，那么只要有一个副本挂机，整个分区就无法正常工作了。我们不仅要改善消息的持久性，防止数据丢失，还要在不降低可用性的基础上完成。推荐设置成 replication.factor = min.insync.replicas + 1。

当 acks = all 时，最少同步副本数建议配置为： \(1 \lt min.insync.replicas \le replication.factor\) 。

一个典型的场景是：创建一个副本数为 3 的主题，将 min.insync.replicas 设置为 2，并且生产者的应答设置为 all，即：

• replication.factor=3

• min.insync.replicas=2

• acks=all

1.2. 生产阶段

在生产消息阶段，消息队列一般通过请求确认机制，来保证消息的可靠传递，Kafka 也不例外。

Kafka 生产者 中提到了，Kafka 有三种发送方式：同步、异步、异步回调。

同步方式能保证消息不丢失，但性能太差；异步方式发送消息，通常会立即返回，但消息可能丢失。

解决生产者丢失消息的方案：

生产者使用带有回调通知的发送 API，即 producer.send(msg, callback) 发送消息，callback（回调）能准确地告诉你消息是否真的提交成功了，一旦出现消息提交失败的情况，就可以有针对性地进行处理。

• 如果是因为那些瞬时错误，那么仅仅让 Producer 重试就可以了；

• 如果是消息不合格造成的，那么可以调整消息格式后再次发送。

然后，需要基于以下几点来保证 Kafka 生产者的可靠性：

1.2.1. ACK

生产者可选的确认模式有三种：acks=0、acks=1、acks=all。

• acks=0、acks=1 都有丢失数据的风险。

• acks=all 意味着会等待所有同步副本都收到消息。

  结合 min.insync.replicas ，就可以决定在得到确认响应前，至少有多少副本能够收到消息。这是最保险的做法，但也会降低吞吐量。

1.2.2. 重试

如果 broker 返回的错误可以通过重试来解决，生产者会自动处理这些错误。

• 可重试错误

  如：LEADER_NOT_AVAILABLE，主副本不可用，可能过一段时间，集群就会选举出新的主副本，重试可以解决问题。

• 不可重试错误

  如：INVALID_CONFIG，即使重试，也无法改变配置选项，重试没有意义。

需要注意的是：有时可能因为网络问题导致没有收到确认，但实际上消息已经写入成功。生产者会认为出现临时故障，重试发送消息，这样就会出现重复记录，所以，尽可能在业务上保证幂等性。

将 Producer 端的 retries 参数设置为一个较大的值。出现网络瞬时抖动时，如果消息可能发送失败，此时，配置了 retries > 0 的 Producer 能够自动重试消息发送，避免消息丢失。

1.2.3. 错误处理

开发者需要自行处理的错误：

• 不可重试的 broker 错误，如：消息大小错误、认证错误等；

• 消息发送前发生的错误，如：序列化错误；

• 生产者达到重试次数上限，或消息占用的内存达到上限时发生的错误。

1.3. 消费阶段

前文已经提到，消费者只能读取已提交的消息。这就保证了消费者接收到消息时已经具备了数据一致性。

消费者唯一要做的是确保哪些消息是已经读取过的，哪些是没有读取过的（通过提交偏移量给 Broker 来确认）。如果消费者提交了偏移量却未能处理完消息，那么就有可能造成消息丢失，这也是消费者丢失消息的主要原因。

1.3.1. 消费者的可靠性配置

• group.id：如果希望消费者可以看到主题的所有消息，那么需要为它们设置唯一的 group.id。

• auto.offset.reset 有两个选项：

  • earliest：消费者会从分区的开始位置读取数据

  • latest：消费者会从分区末尾位置读取数据

• enable.auto.commit：消费者是否自动提交偏移量。

  如果 enable.auto.commit 设为 true，处理流程更简单，但无法保证重复处理消息，它会周期性地提交 Offsets，其中，auto.commit.interval.ms 是自动提交的频率，默认每 5 秒提交一次。

1.3.2. 显式提交偏移量

如果 enable.auto.commit 设为 true，即自动提交，就无需考虑提交偏移量的问题。

如果 enable.auto.commit 设为 false，即选择手动提交偏移量，需要考虑以下问题：

• 必须在处理完消息后，再发送确认（提交偏移量）。

• 提交频率是性能和重复消息数之间的权衡

• 分区再均衡

• 消费可能需要重试机制

• 超时处理

• 消费者可能需要维护消费状态，如：处理完消息后，记录在数据库中。

• 幂等性设计

  • 写数据库：根据主键判断记录是否存在

  • 写 Redis：set 操作天然具有幂等性

  • 复杂的逻辑处理，则可以在消息中加入全局 ID

2. 重复消息

在 MQTT 协议中，给出了三种传递消息时能够提供的服务质量标准，这三种服务质量从低到高依次是：

• At most once：至多一次。消息在传递时，最多会被送达一次；

  没什么消息可靠性保证，允许丢消息。一般都是一些对消息可靠性要求不太高的监控场景使用，比如每分钟上报一次机房温度数据，可以接受数据少量丢失。

• At least once: 至少一次。消息在传递时，至少会被送达一次；

  不允许丢消息，但是允许有少量重复消息出现；

• Exactly once：恰好一次。

  消息在传递时，只会被送达一次，不允许丢失也不允许重复，这个是最高的等级。

绝大部分消息队列提供的服务质量都是 At least once，包括 RocketMQ、RabbitMQ 和 Kafka 都是这样。也就是说，消息队列很难保证消息不重复。

2.1. 幂等性保证

消息在生产和消费的过程中都可能会产生重复，所以，我们需要在生产过程和消费过程中增加消息幂等性的保证，这样就可以认为从“最终结果上来看”消息实际上是只被消费了一次的。

2.1.1. 生产过程中的幂等性

在消息生产过程中，在 Kafka 0.11 版本和 Pulsar 中都支持“producer idempotency”的特性，即生产过程的幂等性，这种特性保证消息虽然可能在生产端产生重复，但是，最终在消息队列存储时只会存储一份。

启用生产者幂等，涉及的配置如下：

• enable.idempotence=true：启用生产者幂等；

• message.send.max.retries=xx：发送失败重试次数；

• acks=all：确保所有的 ISR 都收到消息才应答；

它的实现原理是给每一个生产者一个唯一的 ID，并且为生产的每一条消息赋予一个唯一 ID，消息队列的服务端会存储 < 生产者 ID，最后一条消息 ID> 的映射。当某一个生产者产生新的消息时，消息队列服务端会比对消息 ID 是否与存储的最后一条 ID 一致，如果一致就认为是重复的消息，服务端会自动丢弃。

2.1.2. 消费过程中的幂等性

一般解决重复消息的办法是，在消费端，保证消费消息的操作具备幂等性。常用的实现幂等操作的方法如下：

2.1.2.1 利用数据库的唯一约束实现幂等

在通用层面，我们可以在消息被生产的时候，使用发号器给它生成一个全局唯一的消息 ID，消息被处理之后，把这个 ID 存储在数据库中，在处理下一条消息之前，先从数据库里面查询这个全局 ID 是否被消费过，如果被消费过就放弃消费。

利用数据库的唯一约束实现幂等的方式：

• 关系型数据库：可以使用 INSERT IF NOT EXIST 语句防止重复；

• 非关系型数据库：如，Redis 可以使用 SETNX 等命令来防止重复；

  例如，SET name "larry" NX EX 60。

通过数据库的唯一约束 + 分布式 ID 保证即使消息被重复投递，也只会被消费一次。

2.1.2.2 为更新的数据设置前置条件

2.1.2.2.1. CAS 操作

CAS 操作：如果满足条件就更新数据，否则拒绝更新数据，在更新数据的时候，同时变更前置条件中需要判断的数据。

例如，更新一条数据状态：

upddate t_order set count=xx, state = 2 where state = 1

这样，重复执行这个操作时，由于第一次更新数据的时候已经变更了前置条件中需要判断的数据，不满足前置条件，则不会重复执行更新数据操作。

2.1.2.2.2. 为数据设置版本号

当我们要更新的数据不是数值，或者，我们要做一个比较复杂的更新操作怎么办？用什么作为前置判断条件呢？

更加通用的方法是：给数据增加一个版本号属性。每次更数据前，比较当前数据的版本号是否和消息中的版本号一致，如果不一致就拒绝更新数据，更新数据的同时将版本号 +1，一样可以实现幂等更新。

例如，更新一条数据：

update stock set num=$num_new, version=$version_new where id=$id and version=$version_old

使用版本号机制可以解决 CAS 操作中可能出现的 ABA 问题。

2.1.2.3. 记录并检查操作

还有一种通用性最强，适用范围最广的实现幂等性方法：记录并检查操作，也称为“Token 机制或者 GUID（全局唯一 ID）机制”。

实现的思路特别简单：在执行数据更新操作之前，先检查一下是否执行过这个更新操作。

具体的实现方法是：

• 在发送消息时，给每条消息指定一个全局唯一的 ID；

• 在消费消息时，先根据这个 ID 检查这条消息是否有被消费过，如果没有消费过，才更新数据，然后将消费状态置为已消费。

需要注意第二个步骤，“检查消费状态，然后更新数据并且设置消费状态”中，三个操作必须作为一组操作保证原子性，才能真正实现幂等，否则就会出现 Bug。这一组操作可以通过分布式事务或分布式锁来保证其原子性。

3. 消息的有序性

某些场景下，可能会要求按序发送消息。

3.1. 方案一：单 Partition

Kafka 每一个 Partition 只能隶属于消费者群组中的一个 Consumer，换句话说，每个 Partition 只能被一个 Consumer 消费。所以，如果 Topic 是单 Partition，自然是有序的。

方案分析

• 优点：简单粗暴。开发者什么也不用做。

• 缺点：Kafka 基于 Partition 实现其高并发能力，如果使用单 Partition，会严重限制 Kafka 的吞吐量。

结论：作为分布式消息引擎，限制并发能力，显然等同于自废武功，所以，这个方案几乎是不可接受的。

3.2. 方案二：同一个 key 的消息发送给指定 Partition

• 生产者端显示指定 key 发往一个指定的 Partition，就可以保证同一个 key 在这个 Partition 中是有序的；

• 接下来，消费者端为每个 key 设定一个缓存队列，然后让一个独立线程负责消费指定 key 的队列，这就保证了消费消息也是有序的。

4. 消息积压

• 先修复消费者，然后停掉当前所有消费者。

• 新建 Topic，扩大分区，以提高并发处理能力。

• 创建临时消费者程序，并部署在多节点上，扩大消费处理能力。

• 最后处理完积压消息后，恢复原先部署架构。

5. 验证系统可靠性

建议从 3 个层面验证系统的可靠性：

• 配置验证

• 应用验证

  • 客户端和服务器断开连接

  • 选举

  • 依次重启 broker

  • 依次重启生产者

  • 依次重启消费者

• 监控可靠性

  • 对于生产者来说，最重要的两个指标是消息的 error-rate 和 retry-rate。如果这两个指标上升，说明系统出了问题；

  • 对于消费者来说，最重要的指标是 consumer-lag，该指标表明了消费者的处理速度与最近提交到分区里的偏移量之间还有多少差距。

6. 最佳实践

6.1. 生产者

• 不要使用 producer.send(msg)，而要使用 producer.send(msg, callback)。记住，一定要使用带有回调通知的 send 方法；

• 设置 acks = all。acks 是 Producer 的一个参数，代表了你对“已提交”消息的定义。如果设置成 all，则表明所有副本 Broker 都要接收到消息，该消息才算是“已提交”。这是最高等级的“已提交”定义；

• 设置 retries 为一个较大的值。这里的 retries 同样是 Producer 的参数，对应前面提到的 Producer 自动重试。当出现网络的瞬时抖动时，消息发送可能会失败，此时配置了 retries > 0 的 Producer 能够自动重试消息发送，避免消息丢失。

6.2. 服务器（Kafka Broker）

• 设置 unclean.leader.election.enable = false。这是 Broker 端的参数，它控制的是哪些 Broker 有资格竞选分区的 Leader。如果一个 Broker 落后原先的 Leader 太多，那么它一旦成为新的 Leader，必然会造成消息的丢失。故一般都要将该参数设置成 false，即不允许这种情况的发生；

• 设置 replication.factor >= 3。这也是 Broker 端的参数。其实这里想表述的是，最好将消息多保存几份，毕竟目前防止消息丢失的主要机制就是冗余；

• 设置 min.insync.replicas > 1。这依然是 Broker 端参数，控制的是消息至少要被写入到多少个副本才算是“已提交”。设置成大于 1 可以提升消息持久性。在实际环境中千万不要使用默认值 1；

• 确保 replication.factor > min.insync.replicas。如果两者相等，那么只要有一个副本挂机，整个分区就无法正常工作了。我们不仅要改善消息的持久性，防止数据丢失，还要在不降低可用性的基础上完成。推荐设置成 replication.factor = min.insync.replicas + 1。

6.3. 消费者

确保消息消费完成再提交。Consumer 端有个参数 enable.auto.commit，最好把它设置成 false，并采用手动提交位移的方式。就像前面说的，这对于单 Consumer 多线程处理的场景而言是至关重要的。

---

参考：

• Kafka 可靠传输