kafka操作3

kafka消费方式

  1. pull(拉)模式:consumer采用从broker中主动拉取数据。kafka采用这种方式。pull模式的不足之处是,如果kafka没有数据,消费者可能会陷入循环中,一直返回空数据。
  2. push(推)模式:kafka没有采用这种方式,因为由broker决定消息发送速率,很难适应所有消费者的消费速率。例如推送的速度为50m/s,低于这个处理速度的consumer就来不及处理消息。

kafka消费者总体工作流程

一个消费者可以消费多个分区数据。
每个分区的数据只能由消费者组中的一个消费者消费。
每个消费者的offset由消费者提交到系统主题保存。

消费者组

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

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

消费者组初始化流程

  1. coordinator:辅助实现消费者组的初始化和分区的分配。coordinator节点选择 = groupid的hashcode值 % 50 (__consumer_offsets的分区数量),例如:groupid的hashcode值 = 1,1%50 = 1,那么__consumer_offsets主题的1号分区,在哪个broker上,就选择这个节点的coordinator作为这个消费者组的老大。消费者组下的所有的消费者提交offset的时候就往这个分区去提交offset。
- 每个consumer都发送joinGrounp请求
- 选出一个consumer作为leader
- 把要消费的topic情况发送给leader消费者
- leader会负责制定消费方案
- 把消费方案发给coordinator
- coordinator就把消费方案发给各个consumer
- 每个消费者都会和coordinator保持心跳(默认3s) ,一旦超时(session.timeout.ms=45s),该消费者会被移除,并触发再平衡;或者消费者处理消息的时间过长(max.poll.interval.ms=5分钟),也会触发再平衡

消费者组详细消费流程

consumer
Fech.min.bytes每批次最小抓取大小,默认为1字节
Fetch.max.wait.ms一批数据最小值未达到的超时时间,默认为500ms
Fetch.max.bytes每批次最大抓取大小,默认为50m
Max.poll.records一次拉取数据返回消息的最大条数,默认为500条

独立消费者案例(订阅主题)

  1. 需求:创建一个独立消费者,消费first主题中数据。注意:在消费者API代码中必须配置消费者组id。命令行 启动消费者不填写消费者组id会被自动填写随机的消费者组id。
  2. 实现步骤:首先创建com.thenema.kafka.consumer一个包,在其下面实现java代码
    消费某个主题的数据
package com.thenema.kafka.consumer;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;

/**
 * @author 29467
 * @date 2022/10/17 21:44
 */
public class CustomConsumer {
    public static void main(String[] args) {
        // 0 配置
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103: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,"testGroup");

        // 1 创建一个消费者
        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 consumerRecord:consumerRecords){
                System.out.println(consumerRecord);
            }
        }
    }
}

消费某个分区的数据

package com.thenema.kafka.consumer;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;

/**
 * @author 29467
 * @date 2022/10/17 21:44
 */
public class CustomConsumer {
    public static void main(String[] args) {
        // 0 配置
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103: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,"testGroup");

        // 1 创建一个消费者
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(properties);
        // 2 定义主题first
        ArrayList<TopicPartition> topicPartitions = new ArrayList<>();
        topicPartitions.add(new TopicPartition("first",0));
        kafkaConsumer.assign(topicPartitions);

        // 3 消费数据
        while(true){
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));

            for(ConsumerRecord consumerRecord:consumerRecords){
                System.out.println(consumerRecord);
            }
        }
    }
}

消费者组案例

  1. 需求:测试同一个主题的分区数据,只能由一个消费者组中的一个消费。
  2. 案例实操:复制一份基础消费者的代码,在idea里同时启动,即可开启同一个消费者组中的两个消费者

分区的分配以及再平衡

  1. 一个consumer group中有多个consumer组成,一个topic有多个partition组成,现在的问题是,到底由哪个consumer来消费哪个partition的数据。
  2. Kafka有四种主流的分区分配策略:Range、RoundRobin、Sticky、CooperativeSticky。可以通过配置参数partition.assignment.strategy,修改分区的分配策略。默认策略是Range + CooperativeSticky。Kafka可以同时使用多个分区分配策略。
- 每个consumer都发送JoinGroup请求
- 选出一个consumer作为leader
- 把要消费的topic情况发送给leader消费者
- leader会负责制定消费方案
- 把消费方案发送给coordinator
- coordinator就把消费方案下发给各个consumer
-  每个消费者都会和coordinator保持心跳(默认3s) ,一旦超时(session.timeout.ms=45s),该消费者会被移除,并触发再平衡;或者消费者处理消息的时间过长(max.poll.interval.ms=5分钟),也会触发再平衡

kafka操作3_第1张图片

分区分配策略之Range

  1. Range是对每个topic而言的。首先对同一个topic里面的分区按照序号进行排序,并对消费者按照字母顺序进行排序。假如现在有7个分区,3个消费者,排序后的分区是0,1,2,3,4,5,6;消费者排序完之后将会是C0,C1,C2。通过partitions数/consumer数来决定每个消费者应该消费几个分区。如果除不尽,那么前面几个消费者将会多消费1个分区。partition过多时,容易产生数据倾斜。
  2. Range分区分配策略案例
- 修改主题first为7个分区
bin/kafka-topics.sh --bootstrap-serverhadoop102:9092 --alter --topic first --partitions 7
分区数可以增加,但是不能减少
- 复制CustomConsumer类,创建CustomConsumer2,这样可以由三个消费者CustomConsumer、CustomConsumer1、CustomConsumer2组成消费者组,组名为“test”,同时启动三个消费者
- 启动CustomProducer生产者,发送300条消息,随机发送到不同的分区
- 结果为一个CustomConsumer消费0,1,2分区,另一个CustomConsumer消费3,4分区,最后一个消费5,6分区,如果一个CustomConsumer挂掉之后,其中一个CustomConsumer消费0,1,2,3分区,另外一个消费4,5,6分区

分区分配策略之RoundRobin

  1. RoundRobin针对集群中所有Topic而言。RoundRobin轮询分区策略,是把所有的partition和所有的consumer都列出来,然后按照hashcode进行排序,最后通过轮询算法来分配partition给到各个消费者。
  2. 依次在CustomConsumer、CustomConsumer1、CustomConsumer2三个消费者代码中修改分区分配策略为RoundRobin。
properties.put (ConsumerConfig. PARTITION _ASSIGNMENT_ STRATEGY_CONFIG, "org.apache.kafka.clients.consumer.RoundRobinAssignor");
  1. 重启三个消费者,重复发送消息的步骤,观看分区结果。
  2. 结果为CustomConsumer消费0,3,6,CustomConsumer消费1,4,CustomConsumer消费2,5
  3. 挂掉一个后,其中一个CustomConsumer消费0,1,4,6,另外一个消费3,2,5。
  4. 重启后,其中一个CustomConsumer消费0,2,4,6,另外一个消费1,3,5。

Sticky以及再平衡

粘性分区定义:可以理解为分配结果带有“粘性的”。即在执行一次新的分配之前,考虑上一次分配的结果,尽量少的调整分配的变动,可以节省大量的开销。
粘性分区是kafka从0.11.x版本开始引入这种分配策略,首先会尽量均衡的放置分区到消费者上面,在出现同一消费者组内消费者出现问题的时候,会尽量保持原有分配的分区不变化。

  1. 需求:设置主题为first,7个分区;准备三个消费者,采用粘性分区策略,并进行消费,观察消费分配情况。然后在停止其中一个消费者,再次观察消费分配情况。
  2. 步骤
- 修改分区分配策略为粘性。注意:3个消费者都应该注释掉,之后重启3个消费者,如果出现报错,全部停止等会再重启,或者修改为全新的消费者组。
ArrayList startegys = new ArrayList<>();
startegys.add("org.apache.kafka.clients.consumer.Stickyassignor");
pproperties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG,startegys);
- 使用同样的生产者发送500条消息。可以看到会尽量保持分区的个数近似划分分区。

offset的默认维护位置

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

  1. 思想:__consumer_offsets为kafka中的topic,那就可以通过消费者进行消费
  2. 在配置文件config/consumer.properties中添加配置exclude.internal.topics=false,默认是true,表示不能消费系统主题。为了查看该系统的主题数据,所以该参数修改为false。
  3. 采用命令行方式,创建一个新的topic
bin/kafka-topics.sh --bootstrap-server hadoop101:9092 --create --topic thenema --partitions 2 replication-factor 2
  1. 启动生产者,往thenema生产数据
bin/kafka-console-producer.sh --topic thenema --bootstrap-server hadoop101:9092
  1. 确定消费者消费thenema数据
bin/kafka-console-consumer.sh --bootstarp-server hadoop101:9092 --topic thenema --group test
注意:指定消费者组名称,更好的观察数据存储位置(key是group.id+topic+分区号)
  1. 查看消费者消费主题__consumer_offsets

自动提交offset

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

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

手动提交offset

虽然自动提交offset十分简单便利,但由于其是基于时间提交的,开发人员难以把握offset提交的时机,因此kafka还提供了手动提交offset的api。
手动提交offset的方法有两种:分别是commitSync(同步提交)和commitAsync(异步提交)。两者的相同点是,都会将本次提交的偏移量提交;不通电是,同步提交阻塞当前线程,一直到提交成功,并且会自动失败重试(由不可控因素导致,也会出现提交失败);而异步提交则没有失败重试机制,故有可能提交失败。

  • commitSync(同步提交):必须等待offset提交完毕,再去消费下一批数据
  • commitAsync(异步提交):发送完提交offset请求后,就开始消费下一批数据了
  1. 同步提交offset,由于同步提交offset有失败重试机制,故更加可靠,但是由于一直等待提交结果,提交的效率比较低。以下为同步提交offset的示例。
// 同步提交	
kafkaConsumer.commitSync();
// 异步提交
kafkaConsumer.commitAsync()

指定offset消费

auto.offset.reset = earliest | latest | none 默认为latest
当kafka中没有初始偏移量(消费者组第一次消费)或服务器上不再存在当前偏移量时(例如该数据已被删除),该怎么办

  1. earlier:自动将偏移量重置为最早的偏移量,–from-beginning。
  2. latest(默认值):自动将偏移量重置为最新偏移量。
  3. none:如果未找到消费者组的先前偏移量,则向消费者抛出异常。
  4. 任意指定offset位移开始消费
    参考java代码
package com.thenema.kafka.consumer;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Set;

/**
 * @author 29467
 * @date 2022/10/18 17:47
 */
public class CustomConsumerSeek {
    public static void main(String[] args) {
        // 配置信息
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103: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,"test2");
        // 创建消费者
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(properties);
        // 订阅主题
        ArrayList<String> topics = new ArrayList<>();
        topics.add("first");
        kafkaConsumer.subscribe(topics);

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

        // 保证分区分配方案已经制定完毕
        while(assignment.size()==0){
            kafkaConsumer.poll(Duration.ofSeconds(1));
            assignment = kafkaConsumer.assignment();
        }

        //指定消费的offset
        for(TopicPartition topicPartition:assignment){
            kafkaConsumer.seek(topicPartition,100);
        }

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

    }
}

指定时间消费

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

// 希望把时间转换为对应的offset
HashMap<TopicPartition, Long> topicPartitionLongHashMap = new HashMap<>();
// 封装对应集合
for(TopicPartition topicPartition : assignment){
	topicPartitionLongHashMap.put(topicPartition,System.currentTimeMillis() - 1 * 24 * 3600 * 1000);
}
Map<TopicPartition, OffsetAndTimestamp> topicPartitionOffsetAndTimestampMap = kafkaConsumer.offsetsForTimes(topicPartitionLongHashMap);

重复消费与漏消费

  1. 场景1:重复消费。自动提交offset引起。
- Consumer每5s提交offset
- 如果提交offset后的2s,consumer挂了
- 再次重启consumer,则从上一次提交的offset处继续消费,导致重复消费
  1. 场景1:漏消费。设置offset为手动提交,当offset被提交时,数据还在内存中未落盘,此时刚好消费者在线程中被kill掉,那么offset已经提交,但是数据未处理,导致这部分内存中的数据丢失。

消费者事务

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

数据积压(消费者如何提高吞吐量)

  1. 如果是kafka消费能力不足,则可以考虑增加Topic的分区数,并且同时提升消费组的消费者数量,消费者=分区数。(两者缺一不可)
  2. 如果是下游的数据处理不及时:提高每批次拉取的数量。批次拉取数据过少(拉取数据/处理时间 < 生产速度),使处理的数据小于生产的数据,也会造成数据积压。

你可能感兴趣的:(科技,kafka,java,分布式)