Kafka3.0.0教程 一（从入门到调优，深入全面）

[转载自](https://blog.csdn.net/happyjacob/article/details/124578729#comments_21981242)

文章目录

• 第 1 章 Kafka 概述
• • 1.1 定义
  • 1.2 消息队列
  • • 1.2.1 传统消息队列的应用场景
    • 1.2.2 消息队列的两种模式
  • 1.3 Kafka 基础架构
• 第 2 章 Kafka 快速入门
• • 2.1 安装部署
  • • 2.1.1 集群规划
    • 2.1.2 zookeeper集群部署
    • 2.1.3 kafka集群部署
    • 2.1.4 集群启停脚本
  • 2.2 Kafka 命令行操作
  • • 2.2.1 主题命令行操作
    • 2.2.2 生产者命令行操作
    • 2.2.3 消费者命令行操作
• 第 3 章 Kafka 生产者
• • 3.1 生产者消息发送流程
  • • 3.1.1 发送原理
    • 3.1.2 生产者重要参数列表
  • 3.2 异步发送 API
  • • 3.2.1 普通异步发送
    • 3.2.2 带回调函数的异步发送
  • 3.3 同步发送 API
  • 3.4 生产者分区
  • • 3.4.1 分区好处
    • 3.4.2 生产者发送消息的分区策略
    • • 3.4.2.1 常见的分区策略
      • 3.4.2.2 案例1--指定partition
      • 3.4.2.3 案例2--指定key值
    • 3.4.3 自定义分区器
  • 3.5 生产经验——生产者如何提高吞吐
  • 3.6 生产经验——数据可靠性（ack 应答原理）
  • 3.7 生产经验——数据去重
  • • 3.7.1 数据传递语义
    • 3.7.2 幂等性
    • • 3.7.2.1 幂等性原理
      • 3.7.2.2 如何使用幂等性
    • 3.7.3 生产者事务
  • 3.8 生产经验——数据有序
  • 3.9 生产经验——数据乱序
• 第 4 章 Kafka Broker
• • 4.1 Kafka Broker 工作流程
  • • 4.1.1 Zookeeper 存储的 Kafka 信息
    • 4.1.2 Kafka Broker 总体工作流程
    • 4.1.3 Broker 重要参数
  • 4.2 生产经验——节点服役和退役
  • • 4.2.1 服役新节点
    • • 4.2.1.1 新节点准备
      • 4.2.1.2 执行负载均衡操作
    • 4.2.2 退役旧节点
  • 4.3 Kafka 副本
  • • 4.3.1 副本基本信息
    • 4.3.2 Leader 选举流程
    • 4.3.3 Leader 和 Follower 故障处理细节
    • • 4.3.3.1 Follower故障
      • 4.3.3.2 Leader故障
    • 4.3.5 生产经验——手动调整分区副本存储
    • 4.3.6 生产经验——Leader Partition 负载平衡
    • 4.3.7 生产经验——增加副本因子
  • 4.4 文件存储
  • • 4.4.1 文件存储机制
    • • 4.4.1.1 Topic 数据的存储机制
      • 4.4.1.2 Topic 数据存储在什么位置？
      • 4.4.1.3 index 文件和 log 文件详解
      • 4.4.2 文件清理策略
      • 4.4.2.1 delete 日志删除：将过期数据删除
      • 4.4.2.2 compact 日志压缩
  • 4.5 高效读写数据
• 第 5 章 Kafka 消费者
• • 5.1 Kafka 消费方式
  • 5.2 Kafka 消费者工作流程
  • • 5.2.1 消费者总体工作流程
    • 5.2.2 消费者组原理
    • • 5.2.2.1 消费者组
      • 5.2.2.2 消费者组初始化流程
      • 5.2.2.3 消费者组详细消费流程
    • 5.2.3 消费者重要参数
  • 5.3 消费者 API
  • • 5.3.1 独立消费者案例（订阅主题）
    • 5.3.2 独立消费者案例（订阅分区）
    • 5.3.3 消费者组案例
  • 5.4 生产经验——分区的分配以及再平衡
  • • 5.4.1 Range 以及再平衡
    • • 5.4.1.1 Range 分区策略原理
      • 5.4.1.2 Range 分区分配策略案例
      • 5.4.1.2.3 Range 分区分配再平衡案例
    • 5.4.2 RoundRobin 以及再平衡
    • • 5.4.2.1 RoundRobin 分区策略原理
      • 5.4.2.2 RoundRobin 分区分配策略案例
      • 5.4.2.3 RoundRobin 分区分配再平衡案例
    • 5.4.3 Sticky 以及再平衡
    • • 5.4.3.1 Sticky 分区原理
      • 5.4.3.2 Sticky 分区分配再平衡案例
  • 5.5 offset 位移
  • • 5.5.1 offset 的默认维护位置
    • 5.5.2 自动提交 offset
    • 5.5.3 手动提交 offset
    • 5.5.4 指定 Offset 消费
    • 5.5.5 指定时间消费
    • 5.5.6 漏消费和重复消费
  • 5.6 生产经验——消费者事务
  • 5.7 生产经验——数据积压（消费者如何提高吞吐量）
• 第 6 章 Kafka-Kraft 模式
• • 6.1 Kafka-Kraft 架构
  • 6.2 Kafka-Kraft 集群部署
  • 6.3 Kafka-Kraft 集群启动停止脚本

第 1 章 Kafka 概述

1.1 定义

Kafka传统定义：Kafka是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域。

发布/订阅：消息的发布者不会将消息直接发送给特定的订阅者，而是将发布的消息分为不同的类别，订阅者只接收感兴趣的消息。

Kafka 最新定义：Kafka是一个开源的分布式事件流平台（Event Streaming Platform），被数千家公司用于高性能数据管道、流分析、数据集成和关键任务应用。

1.2 消息队列

目前企业中比较常见的消息队列产品主要有Kafka、ActiveMQ、RabbitMQ、RocketMQ等。

在大数据场景主要采用Kafka作为消息队列。在JavaEE开发中主要采用ActiveMQ、RabbitMQ、RocketMQ。

1.2.1 传统消息队列的应用场景

传统的消息队列的主要应用场景包括：缓存/消峰、解耦和异步通信。

• 缓冲/消峰：有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。

• 解耦：允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。

• 异步通信：允许用户把一个消息放入队列，但并不立即处理它，然后在需要的时候再去处理它们。

1.2.2 消息队列的两种模式

1）点对点模式

• 消费者主动拉取数据，消息收到后清除消息

2）发布/订阅模式

• 可以有多个topic主题（浏览、点赞、收藏、评论等）

• 消费者消费数据之后，不删除数据

• 每个消费者相互独立，都可以消费到数据

1.3 Kafka 基础架构

1. 为方便扩展，并提高吞吐量，一个topic分为多个partition

2. 配合分区的设计，提出消费者组的概念，组内每个消费者并行消费

3. 为提高可用性，为每个partition增加若干副本

4. ZK中记录谁是leader，Kafka2.8.0 以后也可以配置不采用ZK

第 2 章 Kafka 快速入门

2.1 安装部署

2.1.1 集群规划

节点0	节点1	节点2
zk	zk	zk
kafka	kafka	kafka
192.168.228.147	192.168.228.148	192.168.228.149

这里使用的是虚拟机创建集群，首先克隆两个虚拟机出来，步骤如下：

1、将虚拟机关机（不能挂起，必须关机）

2、右击你的虚拟机，选择 管理 > 克隆，克隆两个虚拟机出来

3、打开其中一个虚拟机，我这里用的是 Ubuntu 18.04.1，设置 -> 网络 -> 有线连接 -> IPv4，将IPv4方式改为手动，填一下地址，子网掩码，网关，重启有效Ubuntu。三个虚拟机分别设置三个不同的ip，这样的设置防止DHCP自动给我们分配的ip是变化的

注意：修改ip地址之前三个虚拟机不能同时启动，因为ip地址是相同的，第二个虚拟机会无法启动，改完ip就可以了。

2.1.2 zookeeper集群部署

先将zookeeper的集群部署起来

1）官方下载地址：https://zookeeper.apache.org/releases.html

我这里下载的是3.7.0的版本，文件名为：apache-zookeeper-3.7.0-bin.tar.gz

2）在/usr/local/ 下创建目录kakfa，将apache-zookeeper-3.7.0-bin.tar.gz放在/usr/local/kafka 下，解压

tar -zxvf apache-zookeeper-3.7.0-bin.tar.gz

 
 
>

3）创建目录 /usr/local/kafka/zkdata

root@ubuntu:/usr/local/kafka# mkdir zkdata

 
 

4）在每个节点的zkdata目录下面创建文件myid

/usr/local/kafka/zkdata # echo 1 > myid
/usr/local/kafka/zkdata # echo 2 > myid
/usr/local/kafka/zkdata # echo 3 > myid

 
 

5）重命名 conf中的文件zoo_sample.cfg -> zoo.cfg

6）修改配置文件zoo.cfg

修改两个地方，dataDir 和 server.1、server.2、server.3

# zookeeper时间配置中的基本单位（毫秒）
tickTime=2000
# 允许fo1lower初始化连接到leader最大时长，它表示tickTime时间倍数，即：initLimit*tickTime
initLimit=10
# 允许fo1lower与1eader数据同步最大时长，它表示tickTime时间倍数
syncLimit=5
# zookeper 数据存储目录及日志保存目录（如果没有指明dataLogDir，则日志也保存在这个文件中）
dataDir=/usr/local/kafka/zkdata
# 对客户端提供的端口号
clientPort=2181
# 对客户端提供的端口号
#maxClientCnxns=60
# 2001为集群通信端口，3001为集群选举端口
server.1=192.168.228.147:2001:3001
server.2=192.168.228.148:2001:3001
server.3=192.168.228.149:2001:3001

 
 

 
 

  
  
 
 

三个节点的zookeeper都这么操作

7）关闭防火墙：systemctl stop firewalld，systemctl disable firewalld

Zookeeper服务器的操作命令

启动zk服务器：

bin/zkServer.sh start ./conf/zoo.cfg

 
 

查看zk服务器状态：

查看zk服务器状态：

bin/zkServer.sh status ./conf/zoo.cfg

 
 

停止zk服务器：

/bin/zkServer.sh stop ./conf/zoo.cfg

 
 

2.1.3 kafka集群部署

1）官方下载地址：http://kafka.apache.org/downloads.html

2）创建目录 /usr/local/kafka/kafka_logs

root@ubuntu:/usr/local/kafka# mkdir kafka_logs/

 
 

3）在目录 /usr/local/kafka/ 下解压安装包

tar -zxvf kafka_2.12-3.0.0.tgz

 
 

4）进入到/usr/local/kafka/kafka_2.12-3.0.0/config 目录，修改配置文件内容

需要修改broker.id，listeners，log.dirs，zookeeper.connect四个参数

# broker 的全局唯一编号，不能重复，只能是数字。
broker.id=0
# kafka监听的ip，端口
listeners=PLAINTEXT://192.168.228.147:9092
# 处理网络请求的线程数量
num.network.threads=3
# 用来处理磁盘 IO 的线程数量
num.io.threads=8
# 发送套接字的缓冲区大小
socket.send.buffer.bytes=102400
#接收套接字的缓冲区大小
socket.receive.buffer.bytes=102400
#请求套接字的缓冲区大小
socket.request.max.bytes=104857600
############################# Log Basics #############################
# kafka 数据存放的路径，可以配置多个磁盘路径，路径与路径之间可以用","分隔
log.dirs=/usr/local/kafka/kafka_logs
# topic在当前broker上的分区个数
num.partitions=1
# 用来恢复和清理data下数据的线程数量
num.recovery.threads.per.data.dir=1
############################# Internal Topic Settings  #############################
# 每个topic创建时的副本数，默认是1个副本
offsets.topic.replication.factor=1
############################# Log Retention Policy #############################
# segment文件保留的最长时间，超时将被删除
log.retention.hours=168
# 每个segment文件的大小，默认最大1G
log.segment.bytes=1073741824
# 检查过期数据的时间，默认5分钟检查一次是否数据过期
log.retention.check.interval.ms=300000
############################# Zookeeper #############################
#配置连接 Zookeeper 集群地址（在zk根目录下创建/kafka，方便管理）
zookeeper.connect=192.168.228.147:2181,192.168.228.148:2181,192.168.228.149:2181/kafka

 
 

 
 

  
  
 
 

5）到另外两个节点上修改配置文件/usr/local/kafka/kafka_2.12-3.0.0/config/server.properties中的broker.id 三个节点分别设置为1，2（注意：broker.id 不得重复，整个集群中唯一。）

修改listeners中kafka监听的ip使用本节点的ip，三节点使用的分别是，192.168.228.147，192.168.228.148，192.168.228.149

6）启动集群

（1）先启动 Zookeeper 集群，然后启动 Kafka，三个 节点上依次启动zookeeper

/bin/zkServer.sh start ./conf/zoo.cfg

 
 

（2）依次在三个节点上启动 Kafka

bin/kafka-server-start.sh -daemon config/server.properties

 
 

7）关闭集群

bin/kafka-server-stop.sh

 
 

注意：停止 Kafka 集群时，一定要等 Kafka 所有节点进程全部停止后再停止 Zookeeper 集群。因为 Zookeeper 集群当中记录着 Kafka 集群相关信息，Zookeeper 集群一旦先停止，Kafka 集群就没有办法再获取停止进程的信息，只能手动杀死 Kafka 进程了。

2.1.4 集群启停脚本

借助工具sshpass，实现一个脚本管理多节点的kafka，安装sshpass步骤如下：

1 wget http://sourceforge.net/projects/sshpass/files/sshpass/1.05/sshpass-1.05.tar.gz
2 tar -zxvf sshpass-1.05.tar.gz
3 ./configure
4 make
5 sudo make install

脚本如下所示：

• kf.sh

#! /bin/bash
passwd=password

case KaTeX parse error: Expected '}', got 'EOF' at end of input: …oken variable">i Kafka-------“
sshpass -p $passwd</span><spanclass="tokenfunction">ssh</span>-p<spanclass="tokennumber">22</span>root@<spanclass="tokenvariable">$i /usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-server-start.sh -daemon /usr/local/kafka/kafka_2.12-3.0.0/config/server.properties
done
};;
“stop”){
for i in 192.168.228.147 192.168.228.148 192.168.228.149
do
echo ” --------停止 $i</span>Kafka-------"</span>sshpass-p<spanclass="tokenvariable">$passwd ssh -p 22 root@$i /usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-server-stop.sh
done
};;
esac

启动集群命令

# sh kf.sh start
 --------启动 192.168.228.147 Kafka-------
 --------启动 192.168.228.148 Kafka-------
 --------启动 192.168.228.149 Kafka-------

 
 

停止集群命令

# sh kf.sh stop

 
 

2.2 Kafka 命令行操作

Kafka 基础架构

2.2.1 主题命令行操作

1）查看操作主题命令参数

$ bin/kafka-topics.sh

 
 

 
 
1

参数	描述
–bootstrap-server <String: server toconnect to>	连接的 Kafka Broker 主机名称和端口号
–topic <String: topic>	操作的 topic 名称
–create	创建主题
–delete	删除主题
–alter	修改主题
–list	查看所有主题
–describe	查看主题详细描述
–partitions <Integer: # of partitions>	设置分区数
–replication-factor<Integer: replication factor>	设置分区副本
–config <String: name=value>	更新系统默认的配置

2）查看当前服务器中的所有 topic

bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --describe

 
 

 
 
1

3）创建 first topic

bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --create --partitions 3 --replication-factor 3 --topic first

 
 

 
 
1

选项说明：

–topic 定义 topic 名
–replication-factor 定义副本数
–partitions 定义分区数

4）查看 first 主题的详情

bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --describe --topic first

 
 

5）修改分区数（注意：分区数只能增加，不能减少）

bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --alter --topic first --partitions 3

 
 

6）删除 topic

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --delete --topic first

 
 

2.2.2 生产者命令行操作

1）查看操作生产者命令参数

$ bin/kafka-console-producer.sh

 
 

参数	描述
–bootstrap-server <String: server toconnect to>	连接的 Kafka Broker 主机名称和端口号
–topic <String: topic>	操作的 topic 名称

2）发送消息

bin/kafka-console-producer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic first
>hello world
>skx

 
 

2.2.3 消费者命令行操作

1）查看操作消费者命令参数

$ bin/kafka-console-consumer.sh

 
 

 
 
1

参数	描述
–bootstrap-server <String: server toconnect to>	连接的 Kafka Broker 主机名称和端口号
–topic <String: topic>	操作的 topic 名称
–from-beginning	从头开始消费
–group <String: consumer group id>	指定消费者组名称

2）消费消息

（1）消费 first 主题中的数据。

bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic first

 
 

 
 
1

（2）把主题中所有的数据都读取出来（包括历史数据）。

bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic first --from-beginning

 
 

 
 
1

第 3 章 Kafka 生产者

3.1 生产者消息发送流程

3.1.1 发送原理

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

3.1.2 生产者重要参数列表

参数名称	描述
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	当消息发送出现错误的时候，系统会重发消息。retrie表示重试次数。默认是 int 最大值，2147483647。 如果设置了重试，还想保证消息的有序性，需要设置MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1 否则在重试此失败消息的时候，其他的消息可能发送成功了
retry.backoff.ms	两次重试之间的时间间隔，默认是 100ms
enable.idempotence	是否开启幂等性，默认 true，开启幂等性。
compression.type	生产者发送的所有数据的压缩方式。默认是 none，就是不压缩。 支持压缩类型：none、gzip、snappy、lz4 和 zstd。

3.2 异步发送 API

3.2.1 普通异步发送

• java客户端代码

1）需求：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker

2）代码编写

（1）创建工程 kafka
（2）导入依赖

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>3.0.0</version>
        </dependency>
    </dependencies>

 
 

 
 
1
2
3
4
5
6
7

（3）创建包名：package com.skx.kafka.producer;
（4）编写不带回调函数的 API 代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducer {
    public static void main(String[] args) throws InterruptedException {
        // 1、创建kafka生产者的配置对象
        Properties properties = new Properties();
        // 2、给kafka配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149: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());
        // 3、创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 4、调用send方法，发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "skx" + i));
        }
        // 5、关闭资源
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①在任意一个kafka节点上开启 Kafka 消费者。

②在 IDEA 中执行代码，观察 hadoop102 控制台中是否接收到消息。

# /usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092 --topic first
skx0
skx1
skx2
skx3
skx4

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode)
for i in range(5):
    producer.send('first', 'skx' + str(i))
producer.close()

 
 

3.2.2 带回调函数的异步发送

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

• java客户端代码

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

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerCallback {
    public static void main(String[] args) throws InterruptedException {
        // 1、创建kafka生产者的配置对象
        Properties properties = new Properties();
        // 2、给kafka配置对象 添加配置信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        // key,value序列化（必须）:
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 3、创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 4、调用send方法，发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "skx" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println("主题:" + metadata.topic() + "->" + "分区:" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
            // 延迟一会会看到数据发往不同分区
            Thread.sleep(2);
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①在 hadoop102 上开启 Kafka 消费者。

②在 IDEA 中执行代码，观察控制台中是否接收到消息。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092 --topic first
skx3
skx4
skx0
skx1
skx2

 
 

③在 IDEA 控制台观察回调信息。

主题:first->分区:0
主题:first->分区:0
主题:first->分区:0
主题:first->分区:2
主题:first->分区:2

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode)
def on_send_success(record_metadata):
    print("主题:%s->分区:%s, offset:%s" % (record_metadata.topic, record_metadata.partition, record_metadata.offset))
def on_send_error(excp):
    print('I am an errback:%s', excp)
    # handle exception
for i in range(5):
    producer.send('first', 'skx' + str(i)).add_callback(on_send_success).add_errback(on_send_error)
producer.close()

 
 

 
 

  
  
 
 

在 IDEA 控制台观察回调信息。

主题:first->分区:1, offset:11
主题:first->分区:0, offset:7
主题:first->分区:0, offset:8
主题:first->分区:0, offset:9
主题:first->分区:0, offset:10

 
 

3.3 同步发送 API

只需在异步发送的基础上，再调用一下 get()方法即可。

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
public class CustomProducerSync {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();
        // 2. 给 kafka 配置对象添加配置信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149: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());
        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 4. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            // 异步发送 默认
            // kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i));
            // 同步发送
            kafkaProducer.send(new ProducerRecord<>("first", "Hello" + i)).get();
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①在任意一个kafka节点上开启 Kafka 消费者。
②在 IDEA 中执行代码，观察 hadoop102 控制台中是否接收到消息。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092 --topic first
Hello0
Hello1
Hello2
Hello3
Hello4

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode)
for i in range(5):
    # 同步发送，直到超时
    producer.send('first', 'Hello' + str(i)).get(timeout=10)
producer.close()

 
 

3.4 生产者分区

3.4.1 分区好处

（1）便于合理使用存储资源，每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块一块数据存储在多台Broker上。合理控制分区的任务，可以实现负载均衡的效果。
（2）提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据。

3.4.2 生产者发送消息的分区策略

3.4.2.1 常见的分区策略

在IDEA中全局查找（ctrl +n）ProducerRecord类，在类中可以看到如下构造方法：

1. 指明partition的情况下，直接将指明的值作为partition值；例如partition=0，所有数据写入分区0

2. 没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值；例如：key1的hash值=5， key2的hash值=6 ，topic的partition数=2，那么key1 对应的value1写入1号分区，key2对应的value2写入0号分区。

3. 既没有partition值又没有key值的情况下，Kafka采用Sticky Partition（黏性分区器），会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch已满或者已完成，Kafka再随机一个分区进行使用（和上一次的分区不同）。
   例如：第一次随机选择0号分区，等0号分区当前批次满了（默认16k）或者linger.ms设置的时间到， Kafka再随机一个分区进
   行使用（如果还是0会继续随机）。

   备注：kafka-python中没有指定partition和key，分区是随机的

3.4.2.2 案例1–指定partition

将数据发往指定 partition 的情况下，例如，将所有数据发往分区 1 中。

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerCallbackPartitions {
    public static void main(String[] args) {
        // 1、创建kafka生产者的配置对象
        Properties properties = new Properties();
        // 2、给kafka配置对象添加配置信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        // 3、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());
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 5; i++) {
            // 数据发送到1号分区，key为空
            kafkaProducer.send(new ProducerRecord<>("first", 1, "", "Hello " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("主题:" + recordMetadata.topic() + "->" + "分区:" + recordMetadata.partition());
                    } else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①在任意一个kafka节点上开启 Kafka 消费者。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic first
Hello 0
Hello 1
Hello 2
Hello 3
Hello 4

 
 

②在 IDEA 中执行代码，观察控制台中是否接收到消息。

③在 IDEA 控制台观察回调信息。

主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode)
def on_send_success(record_metadata):
    print("主题:%s->分区:%s, offset:%s" % (record_metadata.topic, record_metadata.partition, record_metadata.offset))
def on_send_error(excp):
    print('I am an errback:%s', excp)
    # handle exception
for i in range(5):
    # 指明发给分区1
    producer.send('first', 'Hello ' + str(i), partition=1).add_callback(on_send_success).add_errback(on_send_error)
producer.close()

 
 

 
 

  
  
 
 

3.4.2.3 案例2–指定key值

没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行余得到 partition 值。

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerCallbackPartitions {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 5; i++) {
            // 依次指定 key 值为 a,b,f ，数据 key 的 hash 值与 3 个分区求余，
            //分别发往 1、2、0
            kafkaProducer.send(new ProducerRecord<>("first", "a", "Hello " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("主题:" + recordMetadata.topic() + "->" + "分区:" + recordMetadata.partition());
                    } else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①key="a"时，在控制台查看结果。

主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1

 
 

②key="b"时，在控制台查看结果。

主题:first->分区:2
主题:first->分区:2
主题:first->分区:2
主题:first->分区:2
主题:first->分区:2

 
 

③key="f"时，在控制台查看结果。

主题:first->分区:0
主题:first->分区:0
主题:first->分区:0
主题:first->分区:0
主题:first->分区:0

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         key_serializer=str.encode,
                         value_serializer=str.encode)
def on_send_success(record_metadata):
    print("主题:%s->分区:%s, offset:%s" % (record_metadata.topic, record_metadata.partition, record_metadata.offset))
def on_send_error(excp):
    print('I am an errback:%s', excp)
    # handle exception
for i in range(5):
    # 依次指定 key 值为 a,b,f ，数据 key 的 hash 值与 3 个分区求余，
    # 分别发往 1、2、0
    producer.send('first', 'Hello ' + str(i), key="a").add_callback(on_send_success).add_errback(on_send_error)
producer.close()

 
 

 
 

  
  
 
 

3.4.3 自定义分区器

如果研发人员可以根据企业需求，自己重新实现分区器。
1）需求
例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，
不包含 atguigu，就发往 1 号分区。
2）实现步骤
（1）定义类实现 Partitioner 接口。
（2）重写 partition()方法。

java客户端代码

• MyPartitioner.java

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;
/**
 * 1. 实现接口 Partitioner
 * 2. 实现 3 个方法:partition,close,configure
 * 3. 编写 partition 方法,返回分区号
 */
public class MyPartitioner implements Partitioner {
    /**
     * 返回信息对应的分区
     *
     * @param topic      主题
     * @param key        消息的 key
     * @param keyBytes   消息的 key 序列化后的字节数组
     * @param value      消息的 value
     * @param valueBytes 消息的 value 序列化后的字节数组
     * @param cluster    集群元数据可以查看分区信息
     * @return
     */
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 获取消息
        String msgValue = value.toString();
        // 创建partition
        int partition;
        if (msgValue.contains("skx")) {
            partition = 0;
        } else {
            partition = 1;
        }
        return partition;
    }
    @Override
    public void close() {
    }
    @Override
    public void configure(Map<String, ?> map) {
    }
}

 
 

 
 

  
  
 
 

• CustomProducerCallbackPartitions.java

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerCallbackPartitions {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 添加自定义的分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 5; i++) {
            // value 中有关键字skx，发往分区0，没有关键字skx，发往分区1
            kafkaProducer.send(new ProducerRecord<>("first", "skx " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("主题:" + recordMetadata.topic() + "->" + "分区:" + recordMetadata.partition());
                    } else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
from kafka.partitioner.default import DefaultPartitioner
class MyPartitioner(DefaultPartitioner):
    @classmethod
    def __call__(cls, key, all_partitions, available):
        """
        Get the partition corresponding to key
        :param key: partitioning key
        :param all_partitions: list of all partitions sorted by partition ID
        :param available: list of available partitions in no particular order
        :return: one of the values from all_partitions or available
        """
        if b"skx" in key:
            return 0
        return 1
# 自定义分区器MyPartitioner
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         key_serializer=str.encode,
                         value_serializer=str.encode,
                         partitioner=MyPartitioner())
def on_send_success(record_metadata):
    print("主题:%s->分区:%s, offset:%s" % (record_metadata.topic, record_metadata.partition, record_metadata.offset))
def on_send_error(excp):
    print('I am an errback:%s', excp)
    # handle exception
for i in range(5):
    # 若key中包含skx，发往分区0，否则发往分区1
    producer.send('first', 'Hello ' + str(i), key="skx").add_callback(on_send_success).add_errback(on_send_error)
producer.close()

 
 

 
 

  
  
 
 

3.5 生产经验——生产者如何提高吞吐

• batch.size：批次大小，默认16k
• linger.ms：等待时间，修改为5-100ms
• compression.type：压缩snappy
• RecordAccumulator：缓冲区大小，修改为64m

代码案例

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerParameters {
    public static void main(String[] args) throws InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        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，改为5ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 5);
        // RecordAccumulator：缓冲区大小，默认 32M：buffer.memory
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 64 * 1024 * 1024L);
        // compression.type：压缩，默认 none，可配置值 gzip、snappy、lz4 和 zstd
        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "Hello " + i));
        }
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

测试：
①在任意一个kafka节点上开启 Kafka 消费者。

②在 IDEA 中执行代码，观察控制台中是否接收到消息。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic first
Hello 0
Hello 1
Hello 2
Hello 3
Hello 4

 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
# batch_size：批次大小，默认16k
# linger_ms：等待时间，修改为5-100ms
# buffer_memory：缓冲区大小，修改为64m
# compression_type：压缩snappy
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode,
                         batch_size=16384,
                         linger_ms=5,
                         buffer_memory=64 * 1024 * 1024,
                         compression_type='gzip')
for i in range(5):
    producer.send('first', 'Hello ' + str(i))
producer.close()

 
 

 
 

  
  
 
 

3.6 生产经验——数据可靠性（ack 应答原理）

问题：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超时，(leader:0, isr:0,1)。这样就不用等长期联系不上或者已经故障的节点。

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

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

可靠性总结：
acks=0，生产者发送过来数据就不管了，可靠性差，效率高；
acks=1，生产者发送过来数据Leader应答，可靠性中等，效率中等；
acks=-1，生产者发送过来数据Leader和ISR队列里面所有Follwer应答，可靠性高，效率低；
在生产环境中，acks=0很少使用；acks=1，一般用于传输普通日志，允许丢个别数据；acks=-1，一般用于传输和钱相关的数据，对可靠性要求比较高的场景。

数据重复分析：

acks=-1（all）：生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。如果Leader收到后，Follower1已同步，Follower2未同步完，Leader挂了，Follower1变成Leader，并且接收了消息。客户端未收到ack，以为发送失败，再次发送，导致现在的Leader接收了两次消息，重复了。具体如何解决数据重复？下回分解。

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerAck {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 设置 acks, 2.x默认是1，3.0.0默认是all
        properties.put(ProducerConfig.ACKS_CONFIG, "all");
        // 重试次数 retries，默认是 int 最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "Hello" + i));
        }
        kafkaProducer.close();
    }
}

 
 

 
 

  
  
 
 

• python客户端代码（kafka-python 2.0.2）

from kafka import KafkaProducer
# 设置 acks 为 all, 默认是1
# 设置重试次数 retries为3，默认是 0，注意，这里的默认值和java客户端是不同的
producer = KafkaProducer(bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"],
                         value_serializer=str.encode,
                         acks="all",
                         retries=3)
for i in range(5):
    producer.send('first', 'Hello' + str(i))
producer.close()

 
 

注意：java客户端（kafka-clients 3.0.0）和python客户端（kafka-python 2.0.2）对 ack 和 retries 默认值不同

kafka-clients：默认ack=“all”，retries=2147483647

kafka-python：默认aack=1，retries=0

3.7 生产经验——数据去重

3.7.1 数据传递语义

• 至少一次（At Least Once）= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2
• 最多一次（At Most Once）= ACK级别设置为0

总结：
At Least Once可以保证数据不丢失，但是不能保证数据不重复；
At Most Once可以保证数据不重复，但是不能保证数据不丢失。

• 精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务。

3.7.2 幂等性

3.7.2.1 幂等性原理

幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。
精确一次（Exactly Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。

重复数据的判断标准：具有 <PID, Partition, SeqNumber> 相同主键的消息提交时，Broker只会持久化一条。其中PID是Kafka每次重启都会分配一个新的；Partition 表示分区号；Sequence Number是单调自增的。

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

3.7.2.2 如何使用幂等性

java客戶端：开启参数 enable.idempotence 默认为 true，false 关闭。
python客戶端：kafka-python不支持开启开启幂等性。

3.7.3 生产者事务

幂等性只能保证的是在单分区单会话内不重复，开启幂等性能保证客户端重启也能保证仅一次发送。

1）Kafka 事务原理

说明：开启事务，必须开启幂等性。

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

2）Kafka 的事务一共有如下 5 个 API

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

 
 

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

• java客户端代码

package com.skx.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class CustomProducerTransactions {
    public static void main(String[] args) throws InterruptedException {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 1、设置事务 id（必须），事务 id 任意起名
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 2、初始化事务
        kafkaProducer.initTransactions();
        // 3、开启事务
        kafkaProducer.beginTransaction();
        try {
            for (int i = 0; i < 5; i++) {
                kafkaProducer.send(new ProducerRecord<>("first", "Hello " + i));
                // 4、提交事务
            }
//            int k = 1 / 0;//构造异常，可以发现事务不能提交，消息未发送
            kafkaProducer.commitTransaction();
        } catch (Exception e) {
            // 5、终止事务
            kafkaProducer.abortTransaction();
        } finally {
            kafkaProducer.close();
        }
    }
}

 
 

 
 

  
  
 
 

kafka-python 2.0.2中没找到支持事务的功能

3.8 生产经验——数据有序

单分区内，有序（有条件的，详见下节）；多分区，分区与分区间无序；

3.9 生产经验——数据乱序

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

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

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

（1）未开启幂等性

max.in.flight.requests.per.connection需要设置为1。

（2）开启幂等性
max.in.flight.requests.per.connection需要设置小于等于5。

原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据，故无论如何，都可以保证最近5个request的数据都是有序的。

第 4 章 Kafka Broker

4.1 Kafka Broker 工作流程

4.1.1 Zookeeper 存储的 Kafka 信息

启动 Zookeeper 客户端，通过 ls 命令可以查看 kafka 相关信息。

# bin/zkCli.sh
[zk: localhost:2181(CONNECTED) 1] ls /kafka 
[admin, brokers, cluster, config, consumers, controller, controller_epoch, feature, isr_change_notification, latest_producer_id_block, log_dir_event_notification]

 
 

 
 
1
2
3

在zookeeper的服务端存储的Kafka相关信息：

1. /kafka/brokers/ids [0,1,2] 记录有哪些服务器
2. /kafka/brokers/topics/first/partitions/0/state
   {“leader”:1 ,“isr”:[1,0,2] } 记录谁是Leader，有哪些服务器可用
3. /kafka/controller {“brokerid”:0} 辅助选举Leader

4.1.2 Kafka Broker 总体工作流程

模拟 Kafka 上下线，Zookeeper 中数据变化

（1）查看/kafka/brokers/ids 路径上的节点。

[zk: localhost:2181(CONNECTED) 2] ls /kafka/brokers/ids 
[0, 1, 2]

 
 

（2）查看/kafka/controller 路径上的数据。

[zk: localhost:2181(CONNECTED) 3] get /kafka/controller
{"version":1,"brokerid":0,"timestamp":"1651496005332"}

 
 

（3）查看/kafka/brokers/topics/first/partitions/0/state 路径上的数据。

[zk: localhost:2181(CONNECTED) 4] get /kafka/brokers/topics/first/partitions/0/state
{"controller_epoch":6,"leader":2,"version":1,"leader_epoch":8,"isr":[1,2,0]}

 
 

（4）停止节点2上的 kafka

# 停止节点2上的 kafka
/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-server-stop.sh

 
 

（5）再次查看/kafka/brokers/ids 路径上的节点

[zk: localhost:2181(CONNECTED) 5] ls /kafka/brokers/ids 
[0, 1]

 
 

（6）再次查看/kafka/controller 路径上的数据。

[zk: localhost:2181(CONNECTED) 6] get /kafka/controller
{"version":1,"brokerid":0,"timestamp":"1651496005332"}

 
 

 
 
1
2

（7）再次查看/kafka/brokers/topics/first/partitions/0/state 路径上的数据。

[zk: localhost:2181(CONNECTED) 7] get /kafka/brokers/topics/first/partitions/0/state
{"controller_epoch":6,"leader":1,"version":1,"leader_epoch":9,"isr":[1,0]}

 
 

（8）启动节点2上的 kafka，再次观察1、2、3步骤中的内容。

4.1.3 Broker 重要参数

参数名称	描述
replica.lag.time.max.ms	ISR 中，如果 Follower 长时间未向 Leader 发送通信请求或同步数据，则该 Follower 将被踢出 ISR。该时间阈值，默认 30s。
auto.leader.rebalance.enable	默认是 true。 自动 Leader Partition 平衡。
leader.imbalance.per.broker.percentage	默认是 10%。每个 broker 允许的不平衡的 leader的比率。如果每个 broker 超过了这个值，控制器会触发 leader 的平衡。
leader.imbalance.check.interval.seconds	默认值 300 秒。检查 leader 负载是否平衡的间隔时间。
log.segment.bytes	Kafka 中 log 日志是分成一块块存储的，此配置是指 log 日志划分 成块的大小，默认值 1G。
log.index.interval.bytes	默认 4kb，kafka 里面每当写入了 4kb 大小的日志（.log），然后就往 index 文件里面记录一个索引。
log.retention.hours	Kafka 中数据保存的时间，默认 7 天。
log.retention.minutes	Kafka 中数据保存的时间，分钟级别，默认关闭。
log.retention.ms	Kafka 中数据保存的时间，毫秒级别，默认关闭。
log.retention.check.interval.ms	检查数据是否保存超时的间隔，默认是 5 分钟。
log.retention.bytes	默认等于-1，表示无穷大。超过设置的所有日志总大小，删除最早的 segment。
log.cleanup.policy	默认是 delete，表示所有数据启用删除策略；如果设置值为 compact，表示所有数据启用压缩策略。
num.io.threads	默认是 8。负责写磁盘的线程数。整个参数值要占总核数的 50%。
num.replica.fetchers	副本拉取线程数，这个参数占总核数的 50%的 1/3
num.network.threads	默认是 3。数据传输线程数，这个参数占总核数的50%的 2/3 。
log.flush.interval.messages	强制页缓存刷写到磁盘的条数，默认是 long 的最大值，9223372036854775807。一般不建议修改，交给系统自己管理。
log.flush.interval.ms	每隔多久，刷数据到磁盘，默认是 null。一般不建议修改，交给系统自己管理。

4.2 生产经验——节点服役和退役

4.2.1 服役新节点

4.2.1.1 新节点准备

1. 将节点 0 关机，并右键执行克隆操作，克隆出节点 3。

2. 开启节点3，并修改 IP 地址。设置 -> 网络 -> 有线连接 -> IPV4

3. 修改节点 3 中 kafka 的 broker.id 为 3，监听地址改为192.168.228.150。

   broker.id=3
   listeners=PLAINTEXT://192.168.228.150:9092
   
      
      
   

4. 删除节点 3 中 kafka 下的 datas 和 logs。

rm -rf /usr/local/kafka/kafka_logs/* /usr/local/kafka/kafka_2.12-3.0.0/logs/*

 
 

5. 重启节点3

6. 启动节点0、节点1、节点2上的 kafka 集群。

7. 单独启动 hadoop105 中的 kafka。

   /usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-server-start.sh -daemon /usr/local/kafka/kafka_2.12-3.0.0/config/server.properties
   
      
      
   

4.2.1.2 执行负载均衡操作

（1）创建一个要均衡的主题。

$ vim topics-to-move.json
{
	"topics": [
		{
			"topic": "first"
		}
	],
	"version": 1
}

 
 

（2）生成一个负载均衡的计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topics-to-move-json-file topics-to-move.json --broker-list "0,1,2,3" --generate
Current partition replica assignment
{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[1,0,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[0,2,1],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[2,1,0],"log_dirs":["any","any","any"]}]}
Proposed partition reassignment configuration
{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[0,1,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[1,2,3],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[2,3,0],"log_dirs":["any","any","any"]}]}

 
 

（3）创建副本存储计划（所有副本存储在 broker0、broker1、broker2、broker3 中）

$ vim increase-replication-factor.json

 
 

输入如下内容：

{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[0,1,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[1,2,3],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[2,3,0],"log_dirs":["any","any","any"]}]}

 
 

（4）执行副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --execute

 
 

（5）验证副本存储计划

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --verify
Status of partition reassignment:
Reassignment of partition first-0 is complete.
Reassignment of partition first-1 is complete.
Reassignment of partition first-2 is complete.
Clearing broker-level throttles on brokers 0,1,2,3
Clearing topic-level throttles on topic first

 
 

4.2.2 退役旧节点

1）执行负载均衡操作
先按照退役一台节点，生成执行计划，然后按照服役时操作流程执行负载均衡。
（1）创建一个要均衡的主题。

vim topics-to-move.json
{
	"topics": [
		{
			"topic": "first"
		}
	],
	"version": 1
}

 
 

（2）创建执行计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topics-to-move-json-file topics-to-move.json --broker-list "0,1,2" --generate
Current partition replica assignment
{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[0,1,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[1,2,3],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[2,3,0],"log_dirs":["any","any","any"]}]}
Proposed partition reassignment configuration
{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[2,0,1],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[0,1,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[1,2,0],"log_dirs":["any","any","any"]}]}

 
 

（3）创建副本存储计划（所有副本存储在 broker0、broker1、broker2 中）。

vim increase-replication-factor.json
{"version":1,"partitions":[{"topic":"first","partition":0,"replicas":[2,0,1],"log_dirs":["any","any","any"]},{"topic":"first","partition":1,"replicas":[0,1,2],"log_dirs":["any","any","any"]},{"topic":"first","partition":2,"replicas":[1,2,0],"log_dirs":["any","any","any"]}]}

 
 

（4）执行副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --execute

 
 

（5）验证副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --verify
Status of partition reassignment:
Reassignment of partition first-0 is complete.
Reassignment of partition first-1 is complete.
Reassignment of partition first-2 is complete.
Clearing broker-level throttles on brokers 0,1,2,3
Clearing topic-level throttles on topic first

 
 

4.3 Kafka 副本

4.3.1 副本基本信息

（1）Kafka 副本作用：提高数据可靠性。
（2）Kafka 默认副本 1 个，生产环境一般配置为 2 个，保证数据可靠性；太多副本会增加磁盘存储空间，增加网络上数据传输，降低效率。
（3）Kafka 中副本分为：Leader 和 Follower。Kafka 生产者只会把数据发往 Leader，然后 Follower 找 Leader 进行同步数据。
（4）Kafka 分区中的所有副本统称为 AR（Assigned Repllicas）。
AR = ISR + OSR
ISR，表示和 Leader 保持同步的 Follower 集合。如果 Follower 长时间未向 Leader 发送通信请求或同步数据，则该 Follower 将被踢出 ISR。该时间阈值由 replica.lag.time.max.ms参数设定，默认 30s。Leader 发生故障之后，就会从 ISR 中选举新的 Leader。
OSR，表示 Follower 与 Leader 副本同步时，延迟过多的副本。

4.3.2 Leader 选举流程

Kafka 集群中有一个 broker 的 Controller 会被选举为 Controller Leader，负责管理集群
broker 的上下线，所有 topic 的分区副本分配和 Leader 选举等工作。

Controller 的信息同步工作是依赖于 Zookeeper 的。

4.3.3 Leader 和 Follower 故障处理细节

LEO（Log End Offset）：每个副本的最后一个offset，LEO其实就是最新的offset + 1。

HW（High Watermark）：所有副本中最小的LEO 。

4.3.3.1 Follower故障

1. Follower发生故障后会被临时踢出ISR
2. 这个期间Leader和Follower继续接收数据
3. 待该Follower恢复后，Follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉，从HW开始向Leader进行同步。
4. 等该Follower的LEO大于等于该Partition的HW，即Follower追上Leader之后，就可以重新加入ISR了。

4.3.3.2 Leader故障

1. Leader发生故障之后，会从ISR中选出一个新的Leader
2. 为保证多个副本之间的数据一致性，其余的Follower会先将各自的log文件高于HW的部分截掉，然后从新的Leader同步数据。

注意：这只能保证副本之间的数据一致性，并不能保 证数据不丢失或者不重复。

4.3.5 生产经验——手动调整分区副本存储

在生产环境中，每台服务器的配置和性能不一致，但是Kafka只会根据自己的代码规则创建对应的分区副本，就会导致个别服务器存储压力较大。所有需要手动调整分区副本的存储。

需求：创建一个新的topic，4个分区，两个副本，名称为three。将该topic的所有副本都存储到broker0和broker1两台服务器上。

手动调整分区副本存储的步骤如下：
（1）创建一个新的 topic，名称为 three。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --create --partitions 4 --replication-factor 2 --topic three

（2）查看分区副本存储情况

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --describe --topic three

（3）创建副本存储计划（所有副本都指定存储在 broker0、broker1 中）。

vim increase-replication-factor.json

输入如下内容：

{
    "version": 1,
    "partitions": [{"topic": "three", "partition": 0, "replicas": [0, 1]},
                   {"topic": "three", "partition": 1, "replicas": [0, 1]},
                   {"topic": "three", "partition": 2, "replicas": [1, 0]},
                   {"topic": "three", "partition": 3, "replicas": [1, 0]}]
}

（4）执行副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --execute

（5）验证副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --verify

（6）查看分区副本存储情况。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --describe --topic three

4.3.6 生产经验——Leader Partition 负载平衡

正常情况下，Kafka本身会自动把Leader Partition均匀分散在各个机器上，来保证每台机器的读写吞吐量都是均匀的。但是如果某些broker宕机，会导致Leader Partition过于集中在其他少部分几台broker上，这会导致少数几台broker的读写请求压力过高，其他宕机的broker重启之后都是follower partition，读写请求很低，造成集群负载不均衡。

• auto.leader.rebalance.enable，默认是true。自动Leader Partition 平衡，生产环境中，leader 重选举的代价比较大，可能会带来性能影响，建议设置为 false 关闭。
• leader.imbalance.per.broker.percentage，默认是10%。每个broker允许的不平衡的leader的比率。如果每个broker超过了这个值，控制器会触发leader的平衡。
• leader.imbalance.check.interval.seconds，默认值300秒。检查leader负载是否平衡的间隔时间。

下面拿一个主题举例说明，假设集群只有一个主题如下图所示：

针对broker0节点，分区2的AR优先副本是0节点，但是0节点却不是Leader节点，所以不平衡数加1，AR副本总数是4所以broker0节点不平衡率为1/4>10%，需要再平衡。

broker2和broker3节点和broker0不平衡率一样，需要再平衡。

Broker1的不平衡数为0，不需要再平衡

4.3.7 生产经验——增加副本因子

在生产环境当中，由于某个主题的重要等级需要提升，我们考虑增加副本。副本数的
增加需要先制定计划，然后根据计划执行。

1）创建 topic

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --create --partitions 3 --replication-factor 1 --topic second

2）手动增加副本存储
（1）创建副本存储计划（所有副本都指定存储在 broker0、broker1、broker2 中）。

vim increase-replication-factor.json

输入如下内容：

{"version":1,"partitions":[{"topic":"second","partition":0,"replicas":[0,1,2]},{"topic":"second","partition":1,"replicas":[0,1,2]},{"topic":"second","partition":2,"replicas":[0,1,2]}]}

（2）执行副本存储计划。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-reassign-partitions.sh  --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --reassignment-json-file increase-replication-factor.json --execute

这样就可以增加topic seond的副本数量

调整前

Topic: second	TopicId: uGNISi4DR4aMlM75YOCl2g	PartitionCount: 3	ReplicationFactor: 1 Configs: segment.bytes=1073741824
	Topic: second	Partition: 0	Leader: 2	Replicas: 2	Isr: 2
	Topic: second	Partition: 1	Leader: 1	Replicas: 1	Isr: 1
	Topic: second	Partition: 2	Leader: 0	Replicas: 0	Isr: 0

调整后

Topic: second	TopicId: uGNISi4DR4aMlM75YOCl2g	PartitionCount: 3	ReplicationFactor: 3 Configs: segment.bytes=1073741824
	Topic: second	Partition: 0	Leader: 2	Replicas: 0,1,2	Isr: 2,0,1
	Topic: second	Partition: 1	Leader: 1	Replicas: 0,1,2	Isr: 1,2,0
	Topic: second	Partition: 2	Leader: 0	Replicas: 0,1,2	Isr: 0,1,2

4.4 文件存储

4.4.1 文件存储机制

4.4.1.1 Topic 数据的存储机制

Topic是逻辑上的概念，而partition是物理上的概念，每个partition对应于一个log文件，该log文件中存储的就是Producer生产的数据。Producer生产的数据会被不断追加到该log文件末端，为防止log文件过大导致数据定位效率低下，Kafka采取了分片和索引机制，将每个partition分为多个segment。每个segment包括：“.index”文件、“.log”文件和.timeindex等文件。这些文件位于一个文件夹下，该文件夹的命名规则为：topic名称+分区序号，例如：first-0。

4.4.1.2 Topic 数据存储在什么位置？

（1）查看任意一节点的/usr/local/kafka/kafka_logs/first-0（first-0、first-2）路径上的文件。

# ll
总用量 28
-rw-r--r--  1 root root 10485760 5月   2 20:53 00000000000000000000.index
-rw-r--r--  1 root root     1787 5月   3 10:20 00000000000000000000.log
-rw-r--r--  1 root root 10485756 5月   2 20:53 00000000000000000000.timeindex
-rw-r--r--  1 root root       10 5月   2 20:51 00000000000000000014.snapshot
-rw-r--r--  1 root root       13 5月   2 21:11 leader-epoch-checkpoint
-rw-r--r--  1 root root       43 4月  20 23:41 partition.metadata

（2）直接查看 log 日志，发现是乱码。

（3）通过工具查看 index 和 log 信息。

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files /usr/local/kafka/kafka_logs/first-0/00000000000000000000.index

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files /usr/local/kafka/kafka_logs/first-0/00000000000000000000.log
Dumping kafka_logs/first-0/00000000000000000000.log
Starting offset: 0
baseOffset: 0 lastOffset: 0 count: 1 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 2 isTransactional: false isControl: false position: 0 CreateTime: 1651482229484 size: 75 magic: 2 compresscodec: none crc: 2570799903 isvalid: true
baseOffset: 1 lastOffset: 3 count: 3 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 2 isTransactional: false isControl: false position: 75 CreateTime: 1651482318536 size: 94 magic: 2 compresscodec: none crc: 637827954 isvalid: true
...

带上 --print-data-log 表示查看消息内容。若是要查看多个log文件能够用逗号分隔

/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files /usr/local/kafka/kafka_logs/first-0/00000000000000000000.log --print-data-log

4.4.1.3 index 文件和 log 文件详解

注意：

1. index为稀疏索引，大约每往log文件写入4kb数据，会往index文件写入一条索引。参数log.index.interval.bytes默认4kb。
2. Index文件中保存的offset为相对offset，这样能确保offset的值所占空间不会过大，因此能将offset的值控制在固定大小

说明：日志存储参数配置

参数	描述
log.segment.bytes	Kafka 中 log 日志是分成一块块存储的，此配置是指 log 日志划成块的大小，默认值 1G。
log.index.interval.bytes	默认 4kb，kafka 里面每当写入了 4kb 大小的日志（.log），然后就往 index 文件里面记录一个索引。 稀疏索引。

4.4.2 文件清理策略

Kafka 中默认的日志保存时间为 7 天，可以通过调整如下参数修改保存时间。

• log.retention.hours，最低优先级小时，默认 7 天。
• log.retention.minutes，分钟。
• log.retention.ms，最高优先级毫秒。
• log.retention.check.interval.ms，负责设置检查周期，默认 5 分钟。

那么日志一旦超过了设置的时间，怎么处理呢？ Kafka 中提供的日志清理策略有 delete 和 compact 两种。

4.4.2.1 delete 日志删除：将过期数据删除

log.cleanup.policy = delete 所有数据启用删除策略

• 基于时间：默认打开。以 segment 中所有记录中的最大时间戳作为该文件时间戳。
• 基于大小：默认关闭。超过设置的所有日志总大小，删除最早的 segment。log.retention.bytes，默认等于-1，表示无穷大。

如果一个 segment 中有一部分数据过期，一部分没有过期，将不会删除。

4.4.2.2 compact 日志压缩

compact日志压缩：对于相同key的不同value值，只保留最后一个版本。

log.cleanup.policy = compact 所有数据启用压缩策略

压缩后的offset可能是不连续的，比如上图中没有6，当从这些offset消费消息时，将会拿到比这个offset大的offset对应的消息，实际上会拿到offset为7的消息，并从这个位置开始消费。

这种策略只适合特殊场景，比如消息的key是用户ID，value是用户的资料，通过这种压缩策略，整个消息集里就保存了所有用户最新的资料。

4.5 高效读写数据

1、Kafka 本身是分布式集群，可以采用分区技术，并行度高

2、数据采用稀疏索引，可以快速定位要消费的数据

3、顺序写磁盘
Kafka 的 producer 生产数据，要写入到 log 文件中，写的过程是一直追加到文件末端，为顺序写。官网有数据表明，同样的磁盘，顺序写能到 600M/s，而随机写只有 100K/s。这与磁盘的机械机构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。

4、页缓存 + 零拷贝技术

• 零拷贝：Kafka的数据加工处理操作交由Kafka生产者和Kafka消费者处理。Kafka Broker应用层不关心存储的数据，所以就不用走应用层，传输效率高。

• PageCache页缓存：Kafka重度依赖底层操作系统提供的PageCache功能。当上层有写操作时，操作系统只是将数据写入PageCache。当读操作发生时，先从PageCache中查找，如果找不到，再去磁盘中读取。实际上ageCache是把尽可能多的空闲内存都当做了磁盘缓存来使用。

参数	描述
log.flush.interval.messages	强制页缓存刷写到磁盘的条数，默认是 long 的最大值，9223372036854775807。一般不建议修改，交给系统自己管理。
log.flush.interval.ms	每隔多久，刷数据到磁盘，默认是 null。一般不建议修改，交给系统自己管理。

第 5 章 Kafka 消费者

5.1 Kafka 消费方式

Kafka 消费方式：pull（拉）模式，consumer采用从broker中主动拉取数据。

为什么没有采用push模式呢？因为由broker决定消息发送速率，很难适应所有消费者的消费速率。

pull模式不足之处是，如果Kafka没有数据，消费者可能会陷入循环中，一直返回空数据。

5.2 Kafka 消费者工作流程

5.2.1 消费者总体工作流程

5.2.2 消费者组原理

5.2.2.1 消费者组

Consumer Group（CG）：消费者组，由多个consumer组成。形成一个消费者组的条件，是所有消费者的groupid相同。

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

5.2.2.2 消费者组初始化流程

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

coordinator节点选择：首先对groupId进行hash（数字），接着对__consumer_offsets的分区数量取模，默认是50，__consumer_offsets的分区数可以通过offsets.topic.num.partitions来设置，找到分区以后，这个分区所在的broker机器就是coordinator机器。

比如说：groupId，“myconsumer_group” -> hash值（数字）-> 对50取模 -> 8__consumer_offsets 这个主题的8号分区在哪台broker上面，那一台就是coordinator 就知道这个consumer group下的所有的消费者提交offset的时候是往哪个分区去提交offset。

作为这个消费者组的老大。消费者组下的所有的消费者提交offset的时候就往这个分区去提交offset。

5.2.2.3 消费者组详细消费流程

5.2.3 消费者重要参数

参数名称	描述
bootstrap.servers	向 Kafka 集群建立初始连接用到的 host/port 列表。
key.deserializer和value.deserializer	指定接收消息的 key 和 value 的反序列化类型。一定要写全类名。
group.id	标记消费者所属的消费者组。
enable.auto.commit	默认值为 true，消费者会自动周期性地向服务器提交偏移量。
auto.commit.interval.ms	如果设置了 enable.auto.commit 的值为 true， 则该值定义了消费者偏移量向 Kafka 提交的频率，默认 5s。
auto.offset.reset	当 Kafka 中没有初始偏移量或当前偏移量在服务器中不存在（如，数据被删除了），该如何处理？ earliest：自动重置偏移量到最早的偏移量。 latest：默认，自动重置偏移量为最新的偏移量。 none：如果消费组原来的（previous）偏移量不存在，则向消费者抛异常。 anything：向消费者抛异常。
offsets.topic.num.partitions	__consumer_offsets 的分区数，默认是 50 个分区。
heartbeat.interval.ms	Kafka 消费者和 coordinator 之间的心跳时间，默认 3s。该条目的值必须小于 session.timeout.ms ，也不应该高于session.timeout.ms 的 1/3。
session.timeout.ms	Kafka 消费者和 coordinator 之间连接超时时间，默认 45s。超过该值，该消费者被移除，消费者组执行再平衡。
max.poll.interval.ms	消费者处理消息的最大时长，默认是 5 分钟。超过该值，该消费者被移除，消费者组执行再平衡。
fetch.min.bytes	默认 1 个字节。消费者获取服务器端一批消息最小的字节数。
fetch.max.wait.ms	默认 500ms。如果没有从服务器端获取到一批数据的最小字节数。该时间到，仍然会返回数据。
fetch.max.bytes	默认 Default: 52428800（50 m）。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值（50m）仍然可以拉取回来这批数据，因此，这不是一个绝对最大值。一批次的大小受 message.max.bytes （broker config）or max.message.bytes （topic config）影响。
max.poll.records	一次 poll 拉取数据返回消息的最大条数，默认是 500 条。