Kafka 生产者

生产者消息发送流程

发送原理

在消息发送的过程中，涉及到了两个线程：main 线程和 Sender 线程。在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程通过分区器将消息发送给 RecordAccumulator， Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。

image-20220426144944892

  • batch.size：只有数据积累到batch.size之后，sender才会发送数据，默认16k
  • linger.ms：如果数据迟迟未达到batch.size,sender等待linger.ms设置的时间。到了之后就会发送数据，单位ms，默认值是0ms，表示没有延迟。

应答acks：

  • 0：生产者发送过来的数据，不需要等数据落盘应答。
  • 1：生产者发送过来的数据，Leader 收到数据后应答。
  • -1(all)：生产者发送过来的数据，Leader 和 ISR 队列 里面的所有节点收齐数据后应答。-1和 all 等价。

生产者重要参数列表

参数名称 描述
bootstrap.servers 生产者连接集群所需的 broker 地址清单。例如 hadoop102:9092,hadoop103:9092,hadoop104:9092，可以设置 1 个或者多个，中间用逗号隔开。注意这里并非需要所有的 broker 地址，因为生产者从给定的 broker 里查找到其他 broker 信息。
key.serializer 和 value.serializer 指定发送消息的 key 和 value 的序列化类型。一定要写 全类名。
buffer.memory RecordAccumulator 缓冲区总大小，默认 32m。
batch.size 缓冲区一批数据最大值，默认 16k。适当增加该值，可 以提高吞吐量，但是如果该值设置太大，会导致数据 传输延迟增加。
linger.ms 如果数据迟迟未达到 batch.size，sender 等待 linger.time 之后就会发送数据。单位 ms，默认值是 0ms，表示没 有延迟。生产环境建议该值大小为 5-100ms 之间。
acks 0：生产者发送过来的数据，不需要等数据落盘应答。 1：生产者发送过来的数据，Leader 收到数据后应答。 -1(all)：生产者发送过来的数据，Leader 和 ISR 队列 里面的所有节点收齐数据后应答。默认值是-1，-1 和 all 是等价的。
max.in.flight.requests.per.connection 允许最多没有返回 ack 的次数，默认为 5，开启幂等性 要保证该值是 1-5 的数字。
retries 当消息发送出现错误的时候，系统会重发消息。retries 表示重试次数。默认是 int 最大值，2147483647。 如果设置了重试，还想保证消息的有序性，需要设置 MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1 否则在重试此失败消息的时候，其他的消息可能发送成功了。
retry.backoff.ms 两次重试之间的时间间隔，默认是 100ms。
enable.idempotence 是否开启幂等性，默认 true，开启幂等性。
compression.type 生产者发送的所有数据的压缩方式。默认是 none，也 就是不压缩。 支持压缩类型:none、gzip、snappy、lz4 和 zstd。

异步发送 API

普通异步发送

需求:创建 Kafka 生产者，采用异步的方式(外部数据无须等到当前batch被RecordAccumulator处理完后再载入)发送到 Kafka Broker

1）创建工程，导入依赖

<dependency>
  <groupId>org.springframework.kafka</groupId>
  <artifactId>spring-kafka-test</artifactId>
  <scope>test</scope>
</dependency>

2）编写不带回调函数的 API 代码

/**
 * kafka 生产者
 *
 * @author zhongye
 * @since 2022.04.26
 */
public class CustomProducer {
  public static void main(String[] args) {
    // 0 配置
    Properties properties = new Properties();
    // 连接集群 bootstrap.servers
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");
    // 指定对应的key和value的序列化类型 key.serializer
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

    // 1 创建kafka生产者对象
    KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

    // 2 ⚠️发送数据(创建ProducerRecord时也可以指定分区)
    for (int i = 0; i < 5; i++) {
      kafkaProducer.send(new ProducerRecord<>("first","silince"+i));
    }

    // 3 关闭资源
    kafkaProducer.close();
  }
}

带回调函数的异步发送

回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元数据信息(RecordMetadata)和异常信息(Exception)，如果 Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。

⚠️：消息发送失败会自动重试，不需要我们在回调函数中手动重试。

kafkaProducer.send(new ProducerRecord<>("first", "silince" + i), new Callback() {
  @Override
  public void onCompletion(RecordMetadata recordMetadata, Exception e) {
    if (e==null){
      System.out.println("主题: "+recordMetadata.topic()+" 分区: "+recordMetadata.partition());
    }
  }

同步发送 API

同步发送(当前batch全部正常ack之后再载入下一批外部数据)只需在异步发送的基础上，再调用一下 get()方法即可。

/**
 * kafka 生产者
 *
 * @author zhongye
 * @since 2022.04.26
 */
public class CustomProducer {
  public static void main(String[] args) throws Exception {
    // 0 配置
    Properties properties = new Properties();
    // 连接集群 bootstrap.servers
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");
    // 指定对应的key和value的序列化类型 key.serializer
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

    // 1 创建kafka生产者对象
    KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

    // 2 发送数据
    for (int i = 0; i < 5; i++) {
      kafkaProducer.send(new ProducerRecord<>("first", "silince" + i)).get();
    }

    // 3 关闭资源
    kafkaProducer.close();
  }
}

分区策略

Kafka 分区

生产经验

如何提高吞吐量

  • batch.size：批次大小, 默认16k
  • linger.ms：等待时间,修改为5-100ms(太大的话会导致下一批数据的延迟过高)
  • compression.type：压缩snappy
  • RecordAccumulator：缓冲区大小,修改为64m
// 1. 创建 kafka 生产者的配置对象
Properties properties = new Properties();
// 2. 给 kafka 配置对象添加配置信息:bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
// key,value 序列化(必须):key.serializer，value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// batch.size:批次大小，默认16K 
properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
// linger.ms:等待时间，默认 0 
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
// RecordAccumulator:缓冲区大小，默认 32M:buffer.memory 
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
// compression.type:压缩，默认 none，可配置值 gzip、snappy、 lz4 和 zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");

数据可靠性

1）ACKS应答级别

  • 0:生产者发送过来的数据，不需要等数据落盘应答(可靠性差，效率高)

    image-20220428143600531

  • 1:生产者发送过来的数据，Leader收到数据后应答(可靠性中等，效率中等)

    image-20220428143612384

  • -1(all):生产者发送过来的数据，Leader和ISR队列里面 的所有节点收齐数据后应答(可靠性高，效率低;在生产环境中，acks=0很少使用;acks=1，一般用于传输普通日志，允许丢个别数据;acks=-1，一般用于传输和钱相关的数据， 对可靠性要求比较高的场景)

    image-20220428143629255

🤔 当acks=-1时，Leader收到数据，所有Follower都开始同步数据， 但有一个Follower，因为某种故障，迟迟不能与Leader进行同步，那这个问题怎么解决呢?

Leader维护了一个动态的in-sync replica set(ISR)，意为和 Leader保持同步的Follower+Leader集合(leader:0，isr:0,1,2)。

如果Follower长时间未向Leader发送通信请求或同步数据，则该Follower将被踢出ISR。该时间阈值由replica.lag.time.max.ms参数设定，默认30s。例如2超时，这ISR变为(leader:0, isr:0,1)。这样就不用等长期联系不上或者已经故障的节点。

数据可靠性分析:如果分区副本设置为1个，或者ISR里应答的最小副本数量 ( min.insync.replicas 默认为1)设置为1，和ack=1的效果是一 样的，仍然有丢数的风险(leader:0，isr:0)。

因此**数据完全可靠条件 = ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于**2

2）代码配置

// 0 配置
Properties properties = new Properties();
// 连接集群 bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");
// 指定对应的key和value的序列化类型 key.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

// acks + 重试次数
properties.put(ProducerConfig.ACKS_CONFIG,"1");
properties.put(ProducerConfig.RETRIES_CONFIG,3);

数据重复

acks: -1(all):生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。如果Leader同步数据之后，没来得及确认ack就挂掉了，则新选举的Leader则会又收到一份重复数据。

image-20220428153413825

1）数据传递语义

  • 至少一次(At Least Once)=ACK级别设置为-1+分区副本大于等于2+ISR里应答的最小副本数量大于等于2 。可以保证数据不丢失，但是不能保证数据不重复;

  • 最多一次(At Most Once)=ACK级别设置为0。可以保证数据不重复，但是不能保证数据不丢失。

  • 精确一次(Exactly Once):对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。

Kafka 0.11版本以后，引入了一项重大特性:幂等性和事务。

2）幂等性

幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。

精确一次(Exactly Once) = 幂等性 + 至少一次( ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2) 。

重复数据的判断标准：具有<PID, Partition, SeqNumber>相同主键的消息提交时，Broker只会持久化一条。

  • PID：Kafka每次重启都会分配一个新的pid
  • Partition：分区号
  • Sequence Number：序列号，单调自增

所以幂等性只能保证的是在单分区单会话内不重复。

image-20220428164642695

使用方式：开启参数 enable.idempotence 默认为 true，false 关闭。

3）生产者事务

开启事务，必须开启幂等性。Producer 在使用事务功能前，必须先 自定义一个唯一的 transactional.id。有 了 transactional.id，即使客户端挂掉了， 它重启后也能继续处理未完成的事务

image-20220428165259806

// Kafka事务API
void initTransactions(); // 1 初始化事务
void beginTransaction() throws ProducerFencedException; // 2 开启事务
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets, String consumerGroupId) throwsProducerFencedException; // 3 在事务内提交已经消费的偏移量(主要用于消费者)
void commitTransaction() throws ProducerFencedException; // 4 提交事务
void abortTransaction() throws ProducerFencedException; // 5 放弃事务(类似于回滚事务的操作)

单个 Producer，使用事务保证消息的仅一次发送

public class CustomProducerTransactions {
  public static void main(String[] args) throws InterruptedException {
    // 1. 创建 kafka 生产者的配置对象
    Properties properties = new Properties();
    // 2. 给 kafka 配置对象添加配置信息 
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092");
    // key,value 序列化
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    // 设置事务id(必须)，事务id任意起名
    properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");
    // 3. 创建 kafka 生产者对象
    KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
    // 初始化事务 
    kafkaProducer.initTransactions(); 
    // 开启事务 
    kafkaProducer.beginTransaction(); 
    try {
      // 4. 调用 send 方法,发送消息 
      for (int i = 0; i < 5; i++) {
        // 发送消息
        kafkaProducer.send(new ProducerRecord<>("first", "silince " + i));
      }
      //提交事务
      kafkaProducer.commitTransaction();
    } catch (Exception e) { 
      // 终止事务
      kafkaProducer.abortTransaction(); } finally {
      // 5. 关闭资源
      kafkaProducer.close();
    }
  }
}

数据有序

单分区内，有序(还需有其他条件); 多分区，分区与分区间无序;

image-20220428171145835

🤔单分区数据乱序问题？因为sender线程将数据发送到kafka集群的过程中存在重试机制。

1）kafka在1.x版本之前保证数据单分区有序，条件如下:

  • max.in.flight.requests.per.connection=1(不需要考虑是否开启幂等性)。

2）kafka在1.x及以后版本保证数据单分区有序，条件如下:

  • 未开启幂等性：max.in.flight.requests.per.connection(该参数指定了生产者在收到服务器响应之前可以发送多少个消息)需要设置为1
  • 开启幂等性：max.in.flight.requests.per.connection需要设置小于等于5。因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据， 故无论如何，都可以保证最近5个request的数据都是有序的(根据序列号)

image-20220428171919457