Kafka 消费者

消费方式

pull(拉)模式:

  • consumer采用从broker中主动拉取数据。Kafka采用这种方式。
  • pull模式不足之处是,如果Kafka没有数据,消费者可能会陷入循环中,一直返回空数据。

push(推)模式:

  • Kafka没有采用这种方式,因为由broker 决定消息发送速率,很难适应所有消费者的消费速率。例如推送的速度是50m/s, Consumer1、Consumer2就来不及处理消息。

image-20220506165214629

消费者工作流程

1)消费者总体工作流程

image-20220506165330797

2)消费者组

Consumer Group(CG):消费者组,由多个consumer组成。形成一个消费者组的条件,是所有消费者的groupid相同。

  • 消费者组内每个消费者负责消费不同分区的数据,一个分区只能由一个组内的消费者消费。
  • 消费者组之间互不影响。所有的消费者都属于某个消费者组,即消费者组是逻辑上的一个订阅者。

image-20220506165624240

  • 如果向消费组中添加更多的消费者,超过 主题分区数量,则有一部分消费者就会闲置,不会接收任何消息。

image-20220506165729004

3)消费者组初始化流程

coordinator:辅助实现消费者组的初始化和分区的分配。

  • coordinator节点选择=groupid的nashcode值%50(_consumer_offsets的分区数量)_
  • 例如:groupid的hashcodef值=1,1%50=1,那么_consumer_offsets主题的1号分区,在哪个broker上,就选择这个节点的coordinator 作为这个消费者组的老大。消费者组下的所有的消费者提交offset的时候就往这个分区去提交offset。

image-20220506165927636

⚠️触发再平衡的两个条件:

  • 每个消费者都会和coordinator保持心跳(默认3s),一旦超时 (session.timeout.ms=45s),该消费者会被移除,并触发再平衡;
  • 或者消费者处理消息的时间过长(超过max.poll.interval.ms5分钟),也会触发再平衡

4)消费流程

  1. 创建COnsumerNetworkClient,接收消费者的消费请求sendFetches
  2. ConsumerNetworkClient通过send方法拉去broker中的消息,broker也有相应onSuccess回调方法
  3. 把拉去的消息放入completedFetches队列,消费者会按批次拉取数据
  4. 反序列化/拦截器/处理数据

image-20220506180242291

消费者API

独立消费者(订阅主题)

需求:创建一个独立消费者,消费 first 主题中数据。

image-20220506183248510

代码:⚠️在消费者 API 代码中必须配置消费者组 id。命令行启动消费者不填写消费者组 id 会被自动填写随机的消费者组 id。

/**
 * 独立消费者案例(订阅主题)
 *
 * @author zhongye
 * @since 2022.05.06
 */
public class CustomConsumer {
  public static void main(String[] args) {
    //0 配置
    Properties properties = new Properties();

    //连接bootstrap.servers
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");

    // 反序列化
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组id
    properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");

    // 1 创建一个消费者 "","hello"
    KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(properties);

    // 2 订阅主题 first
    ArrayList<String> topics = new ArrayList<>();
    topics.add("first");
    kafkaConsumer.subscribe(topics);

    // 3 消费数据
    while (true){
      ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
      for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
        System.out.println(consumerRecord);
      }
    }

  }
}

执行结果:消息由普通异步发送生产

ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 22, CreateTime = 1651833006318, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince0)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 23, CreateTime = 1651833006336, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince1)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 24, CreateTime = 1651833006336, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince2)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 25, CreateTime = 1651833006336, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince3)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 26, CreateTime = 1651833006336, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince4)

独立消费者(订阅分区)

需求:创建一个独立消费者,消费 first 主题下 0 号分区的数据(指定分区消费)。

image-20220506183331738

代码:

/**
 * 消费 first 主题下 0 号分区的数据(指定分区消费)。
 *
 * @author zhongye
 * @since 2022.05.06
 */
public class CustomConsumerPartition {
  public static void main(String[] args) {
    //0 配置
    Properties properties = new Properties();

    //连接bootstrap.servers
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");

    // 反序列化
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组id
    properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");

    // 1 创建一个消费者 "","hello"
    KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(properties);

    // 2 订阅主题对应的分区
    ArrayList<TopicPartition> topics = new ArrayList<>();
    topics.add(new TopicPartition("first",0));
    kafkaConsumer.assign(topics);

    // 3 消费数据
    while (true){
      ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
      for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
        System.out.println(consumerRecord);
      }
    }

  }
}

执行结果:如指定的分区为1,那就不会消费消息(消息由普通异步发送生产)。

ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 32, CreateTime = 1651840032039, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince0)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 33, CreateTime = 1651840032051, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince1)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 34, CreateTime = 1651840032052, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince2)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 35, CreateTime = 1651840032052, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince3)
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 0, offset = 36, CreateTime = 1651840032052, serialized key size = -1, serialized value size = 8, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = silince4)

消费者组

需求:测试同一个主题的分区数据,只能由一个消费者组中的一个消费。

image-20220506203115326

代码:复制两份独立消费者(订阅主题)即可,因为groupid相同,所以自动会组成一个消费者组

分区的分配以及再平衡

  1. 一个consumer group中有多个consumer组成,一个 topic有多个partition组成,现在的问题是,到底由哪个consumer来消费哪个 partition的数据。
  2. Kafka有四种主流的分区分配策略: Range、RoundRobin、Sticky、CooperativeSticky。
  3. 可以通过配置参数partition.assignment.strategy,修改分区的分配策略。默认策略是Range+ CooperativeSticky。Kafka可以同时使用。

image-20220506205145363

Range 以及再平衡

Range 是对每个 topic 而言的。首先对同一个 topic 里面的分区按照序号进行排序,并对消费者按照字母顺序进行排序。

  • 如现在有 7 个分区,3 个消费者,排序后的分区将会是0,1,2,3,4,5,6;消费者排序完之后将会是C0,C1,C2。通过 partitions数/consumer数 来决定每个消费者应该 消费几个分区。如果除不尽,那么前面几个消费者将会多消费 1 个分区。
  • 例如,7/3=2余1,除不尽,那么消费者C0便会多消费1个分区。8/3=2余2,除不尽,那么C0和C1分别多消费一个。

⚠️:如果只是针对1个topic而言,C0消费者多消费1 个分区影响不是很大。但是如果有N多个topc,那么针对每 个topic,消费者C0都将多消费1个分区,topic越多,C0消费的分区会比其他消费者明显多消费N个分区。容易产生数据倾斜

image-20220506231758996

Range 分区分配再平衡案例

停止掉 0 号消费者,快速重新发送消息观看结果(45s 以内,越快越好)。

  • 1 号消费者:消费到 3、4 号分区数据。
  • 2 号消费者:消费到 5、6 号分区数据。
  • 0 号消费者的任务会整体被分配到 1 号消费者或者 2 号消费者。

0 号消费者挂掉后,消费者组需要按照超时时间 45s 来判断它是否退出,所以需要等待,时间到了 45s 后,判断它真的退出就会把任务分配给其他 broker 执行。再次重新发送消息观看结果(45s 以后)。

  • 1 号消费者:消费到 0、1、2、3 号分区数据。
  • 2 号消费者:消费到 4、5、6 号分区数据。

说明:消费者 0 已经被踢出消费者组,所以重新按照 range 方式分配。

RoundRobin 以及再平衡

RoundRobin 针对集群中所有Topic而言。

RoundRobin 轮询分区策略,是把所有的 partition 和所有的 consumer 都列出来,然后按照 hashcode 进行排序,最后 通过轮询算法来分配 partition 给到各个消费者。

image-20220507153934604

RoundRobin 分区分配再平衡案例

停止掉 0 号消费者,快速重新发送消息观看结果(45s 以内,越快越好)。

  • 1 号消费者:消费到 2、5 号分区数据
  • 2 号消费者:消费到 4、1 号分区数据
  • 0 号消费者的任务会按照 RoundRobin 的方式,把数据轮询分成 0 、6 和 3 号分区数据,分别由 1 号消费者或者 2 号消费者消费。

0 号消费者挂掉后,消费者组需要按照超时时间 45s 来判断它是否退出,所以需要等待,时间到了 45s 后,判断它真的退出就会把任务分配给其他 broker 执行。 再次重新发送消息观看结果(45s 以后)。

  • 1 号消费者:消费到 0、2、4、6 号分区数据
  • 2 号消费者:消费到 1、3、5 号分区数据

说明:消费者 0 已经被踢出消费者组,所以重新按照 RoundRobin 方式分配。

Sticky 以及再平衡

粘性分区定义:可以理解为分配的结果带有“粘性的”。即在执行一次新的分配之前, 考虑上一次分配的结果,尽量少的调整分配的变动,可以节省大量的开销。

粘性分区是 Kafka 从 0.11.x 版本开始引入这种分配策略,首先会尽量均衡的放置分区 到消费者上面,在出现同一消费者组内消费者出现问题的时候,会尽量保持原有分配的分区不变化。

Sticky 分区分配再平衡案例

停止掉 0 号消费者,快速重新发送消息观看结果(45s 以内,越快越好)。

  • 1 号消费者:消费到 2、5、3 号分区数据。
  • 2 号消费者:消费到 4、6 号分区数据。
  • 0 号消费者的任务会按照粘性规则,尽可能均衡的随机分成 0 和 1 号分区数据,分别由 1 号消费者或者 2 号消费者消费。

0 号消费者挂掉后,消费者组需要按照超时时间 45s 来判断它是否退出,所以需要等待,时间到了 45s 后,判断它真的退出就会把任务分配给其他 broker 执行。 再次重新发送消息观看结果(45s 以后)。

  • 1 号消费者:消费到 2、3、5 号分区数据。
  • 2 号消费者:消费到 0、1、4、6 号分区数据。

说明:消费者 0 已经被踢出消费者组,所以重新按照粘性方式分配。

CooperativeSticky

和sticky类似只是说支持了cooperative的rebalance。

Cooperative rebalance:这种方式就是我们通过consumer group的leader把有影响的partition停止了,其它partition还在继续consumer,对有影响的partition再进行重新分配,有时为了达到最终的均衡,这个过程可能会发生好几次才最终stable,如下图所示,在第一个rebalance过程中,我们把partition3停止了,这个时候1和2还是被正常consume的。然后在第二个rebalance的过程中,partition3重新被assign给consumerC。所以这种方式相比于Eager来说,它不会出现全部停止的情况。

image-20220507154953040

offset位移

offset 的默认维护位置

__consumer_offsets 主题里面采用 key 和 value 的方式存储数据。key 是 group.id+topic+分区号,value 就是当前 offset 的值。每隔一段时间,kafka 内部会对这个 topic 进行 compact,也就是每个 group.id+topic+分区号就只保留最新数据。

image-20220507155449164

自动提交 offset

为了使我们能够专注于自己的业务逻辑,Kafka提供了自动提交offset的功能。 自动提交offset的相关参数:

  • enable.auto.commit:是否开启自动提交offset功能,默认是true
  • auto.commit.interval.ms:自动提交offset的时间间隔,默认是5s

image-20220507155641741

API配置方式

// 提交offset的时间周期1000ms,默认5s 
properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 1000);

手动提交 offset

虽然自动提交offset十分简单便利,但由于其是基于时间提交的,开发人员难以把握offset提交的时机。因此Kafka还提供了手动提交offset的API。

手动提交offset的方法有两种:分别是commitSync(同步提交)commitAsync(异步提交)。两者的相同点是,都会将本次提交的一批数据最高的偏移量提交;不同点是,同步提交阻塞当前线程,一直到提交成功,并且会自动失败重试(由不可控因素导致,也会出现提交失败);而异步提交则没有失败重试机制,故有可能提交失败。

  • commitSync(同步提交):必须等待offset提交完毕,再去消费下一批数据。
  • commitAsync(异步提交) :发送完提交offset请求后,就开始消费下一批数据了。
// 是否自动提交offset
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);

指定 offset 消费

auto.offset.reset = earliest | latest | none 默认是 latest。

当 Kafka 中没有初始偏移量(消费者组第一次消费)或服务器上不再存在当前偏移量时(例如该数据已被删除),该怎么办?

1)earliest:自动将偏移量重置为最早的偏移量,–from-beginning。

2)latest(默认值):自动将偏移量重置为最新偏移量。

3)none:如果未找到消费者组的先前偏移量,则向消费者抛出异常。

image-20220507230311329

// 订阅一个主题
ArrayList<String> topics = new ArrayList<>(); 
topics.add("first"); 
kafkaConsumer.subscribe(topics);

Set<TopicPartition> assignment= new HashSet<>();
while (assignment.size() == 0) {  // 保证分区分配方案已经制定完毕
  // 获取消费者分区分配信息(有了分区分配信息才能开始消费) 
  assignment = kafkaConsumer.assignment();
}

// 遍历所有分区,并指定 offset 从 1700 的位置开始消费 
for (TopicPartition tp: assignment) {
  //覆盖使用者将在下一次轮询(超时)中使用的提取偏移量。如果对同一分区多次调用此 API,则将在下一个 poll ()上使用最新的偏移量。
  kafkaConsumer.seek(tp, 1700);
}

指定时间消费

需求:在生产环境中,会遇到最近消费的几个小时数据异常,想重新按照时间消费。 例如要求按照时间消费前一天的数据,怎么处理?

/**
 * 指定时间消费
 *
 * @author zhongye
 * @since 2022.05.07
 */
public class CustomConsumerSeekTime {
  public static void main(String[] args) {
    //0 配置
    Properties properties = new Properties();

    //连接bootstrap.servers
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");

    // 反序列化
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组id
    properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");

    // 1 创建一个消费者 "","hello"
    KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(properties);

    // 2 定义主题 first
    ArrayList<String> topics = new ArrayList<>();
    topics.add("first");
    kafkaConsumer.subscribe(topics);

    // 指定位置进行消费
    Set<TopicPartition> assignment = kafkaConsumer.assignment();

    // 保证分区分配方案已经制定完毕
    while (assignment.size()==0){
      // 获取消费者分区分配信息(有了分区分配信息才能开始消费)
      assignment = kafkaConsumer.assignment();
    }

    // ⭐️希望把时间转换为对应的offset
    HashMap<TopicPartition, Long> topicPartitionLongHashMap = new HashMap<>();
    // 封装对应的map
    for (TopicPartition topicPartition : assignment) {
      // 指定当前时刻一天前的offset
      topicPartitionLongHashMap.put(topicPartition,System.currentTimeMillis()-1*24*3600*1000);
    }
    Map<TopicPartition, OffsetAndTimestamp> offsetsForTimes = kafkaConsumer.offsetsForTimes(topicPartitionLongHashMap);

    // 指定消费的offset
    for (TopicPartition topicPartition : assignment) {
      // 获取各分区一天前的offset
      OffsetAndTimestamp offsetAndTimestamp = offsetsForTimes.get(topicPartition);
      kafkaConsumer.seek(topicPartition,offsetAndTimestamp.offset());
    }


    // 3 消费数据
    while (true){
      ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
      for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
        System.out.println(consumerRecord);
      }
    }

  }
}

漏消费和重复消费

重复消费:已经消费了数据,但是 offset 没提交。

漏消费:先提交 offset 后消费,有可能会造成数据的漏消费。

image-20220508155811118

如果想完成Consumer端的精准一次性消费,那么需要Kafka消费端将消费过程和提交offset 过程做原子绑定。此时我们需要将Kafka的offset保存到支持事务的自定义介质(比如MySQL)。

数据积压

1)如果是Kafka消费能力不足,则可以考虑增 加Topic的分区数,并且同时提升消费组的消费者数量,消费者数=分区数。(两者缺一不可)

2)如果是下游的数据处理不及时:提高每批次拉取的数量。批次拉取数据过少(拉取数据/处理时间<生产速度), 使处理的数据小于生产的数据,也会造成数据积压。

image-20220508161128405

参数名称 描述
fetch.max.bytes 默认Default: 52428800(50m)。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值 (50m)仍然可以拉取回来这批数据,因此,这不是一个绝对最大值。一批次的大小受 message.max.bytes (broker config)or max.message.bytes (topic config)影响。
max.poll.records 一次 poll 拉取数据返回消息的最大条数,默认是 500 条