文章目录 第 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 异步发送 API3.2.1 普通异步发送3.2.2 带回调函数的异步发送 3.3 同步发送 API3.4 生产者分区3.4.1 分区好处3.4.2 生产者发送消息的分区策略3.4.2.1 常见的分区策略3.4.2.2 案例1--指定partition3.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 Broker4.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 消费者 API5.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 自动提交 offset5.5.3 手动提交 offset5.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 基础架构为方便扩展，并提高吞吐量，一个topic分为多个partition
配合分区的设计，提出消费者组的概念，组内每个消费者并行消费
为提高可用性，为每个partition增加若干副本
ZK中记录谁是leader，Kafka2.8.0 以后也可以配置不采用ZK
第 2 章 Kafka 快速入门 2.1 安装部署 2.1.1 集群规划这里使用的是虚拟机创建集群，首先克隆两个虚拟机出来，步骤如下：
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.gz3）创建目录 /usr/local/kafka/zkdata
root@ubuntu:/usr/local/kafka# mkdir zkdata4）在每个节点的zkdata目录下面创建文件myid
/usr/local/kafka/zkdata # echo 1 > myid /usr/local/kafka/zkdata # echo 2 > myid /usr/local/kafka/zkdata # echo 3 > myid5）重命名 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.tgz4）进入到/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/kafka5）到另外两个节点上修改配置文件/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.properties7）关闭集群
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 $1 in "start"){ for i in 192.168.228.147 192.168.228.148 192.168.228.149 do echo " --------启动 $i Kafka-------" sshpass -p $passwd ssh -p 22 root@$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 Kafka-------" sshpass -p $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.sh2）查看当前服务器中的所有 topic
bin/kafka-topics.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --describe3）创建 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选项说明：
–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 first5）修改分区数（注意：分区数只能增加，不能减少）
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 36）删除 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.sh2）发送消息
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.sh2）消费消息
（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（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 第 3 章 Kafka 生产者 3.1 生产者消息发送流程 3.1.1 发送原理在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。
3.1.2 生产者重要参数列表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>（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类，在类中可以看到如下构造方法：
指明partition的情况下，直接将指明的值作为partition值；例如partition=0，所有数据写入分区0
没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值；例如：key1的hash值=5， key2的hash值=6 ，topic的partition数=2，那么key1 对应的value1写入1号分区，key2对应的value2写入0号分区。
既没有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：批次大小，默认16klinger.ms：等待时间，修改为5-100mscompression.type：压缩snappyRecordAccumulator：缓冲区大小，修改为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]在zookeeper的服务端存储的Kafka相关信息：
/kafka/brokers/ids [0,1,2] 记录有哪些服务器/kafka/brokers/topics/first/partitions/0/state {“leader”:1 ,“isr”:[1,0,2] } 记录谁是Leader，有哪些服务器可用/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"}（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 重要参数将节点 0 关机，并右键执行克隆操作，克隆出节点 3。
开启节点3，并修改 IP 地址。设置 -> 网络 -> 有线连接 -> IPV4
修改节点 3 中 kafka 的 broker.id 为 3，监听地址改为192.168.228.150。
broker.id=3 listeners=PLAINTEXT://192.168.228.150:9092删除节点 3 中 kafka 下的 datas 和 logs。
rm -rf /usr/local/kafka/kafka_logs/* /usr/local/kafka/kafka_2.12-3.0.0/logs/*重启节点3
启动节点0、节点1、节点2上的 kafka 集群。
单独启动 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故障 Follower发生故障后会被临时踢出ISR这个期间Leader和Follower继续接收数据待该Follower恢复后，Follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉，从HW开始向Leader进行同步。等该Follower的LEO大于等于该Partition的HW，即Follower追上Leader之后，就可以重新加入ISR了。 4.3.3.2 Leader故障 Leader发生故障之后，会从ISR中选出一个新的Leader为保证多个副本之间的数据一致性，其余的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 second2）手动增加副本存储 （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 文件详解注意：
index为稀疏索引，大约每往log文件写入4kb数据，会往index文件写入一条索引。参数log.index.interval.bytes默认4kb。Index文件中保存的offset为相对offset，这样能确保offset的值所占空间不会过大，因此能将offset的值控制在固定大小说明：日志存储参数配置
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是把尽可能多的空闲内存都当做了磁盘缓存来使用。
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 消费者重要参数1）需求：创建一个独立消费者，消费 first 主题中数据。
注意：在消费者 API 代码中必须配置消费者组 id。命令行启动消费者不填写消费者组 id 会被自动填写随机的消费者组 id。
2）实现步骤
创建包名：com.skx.kafka.consumer编写代码 java客户端代码 package com.skx.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; public class CustomConsumer { public static void main(String[] args) { // 1、创建消费者的配置对象 Properties properties = new Properties(); // 2、给消费者配置对象添加参数 properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092"); // 配置序列化，必须 properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 配置消费者组（组名任意起）必须 properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test"); // 创建消费者对象 KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties); // 注册要消费的主题（可以消费多个主题） ArrayList<String> topics = new ArrayList<>(); topics.add("first"); kafkaConsumer.subscribe(topics); // 拉取数据打印 while (true) { // 设置1s中消费一批数据 ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1)); // 打印消费到的数据 for (ConsumerRecord<String, String> consumerRecord : consumerRecords) { System.out.println(consumerRecord); } } } }3）测试
在 IDEA 中执行消费者程序。
在 Kafka 集群控制台，创建 Kafka 生产者，并输入数据。
/usr/local/kafka/kafka_2.12-3.0.0/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在 IDEA 控制台观察接收到的数据。
ConsumerRecord(topic = first, partition = 1, leaderEpoch = 8, offset = 71, CreateTime = 1651574087216, serialized key size = -1, serialized value size = 5, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = hello) python客户端代码（kafka-python 2.0.2） from kafka import KafkaConsumer import time consumer = KafkaConsumer(group_id="test-2", bootstrap_servers=["192.168.228.147:9092"]) consumer.subscribe(topics=['first']) while True: msg = consumer.poll(timeout_ms=3) print(msg) time.sleep(2)在 IDEA 控制台观察接收到的数据。
{} {TopicPartition(topic='first', partition=1): [ConsumerRecord(topic='first', partition=1, offset=2, timestamp=1651590859638, timestamp_type=0, key=None, value=b'abc', headers=[], checksum=None, serialized_key_size=-1, serialized_value_size=3, serialized_header_size=-1)]} {} ... 5.3.2 独立消费者案例（订阅分区）1）需求：创建一个独立消费者，消费 first 主题 0 号分区的数据。
java客户端代码
2）实现步骤 （1）代码编写
package com.skx.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; public class CustomConsumerPartition { public static void main(String[] args) { Properties properties = new Properties(); properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092"); properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 配置消费者组 properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test"); KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(properties); // 消费某个主题的某个分区的数据 ArrayList<TopicPartition> topicPartitions = new ArrayList<>(); topicPartitions.add(new TopicPartition("first", 0)); kafkaConsumer.assign(topicPartitions); while (true) { ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1)); for (ConsumerRecord<String, String> consumerRecord : consumerRecords) { System.out.println(consumerRecord); } } } }3）测试 （1）在 IDEA 中执行消费者程序。 （2）在 IDEA 中执行生产者程序 CustomProducerCallback()在控制台观察生成几个 0 号分区的数据。
主题:first->分区:0 主题:first->分区:0 主题:first->分区:0 主题:first->分区:1 主题:first->分区:1（3）在 IDEA 控制台，观察接收到的数据，只能消费到 0 号分区数据表示正确。
ConsumerRecord(topic = first, partition = 0, leaderEpoch = 4, offset = 2, CreateTime = 1651592123472, serialized key size = -1, serialized value size = 4, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = skx0) ConsumerRecord(topic = first, partition = 0, leaderEpoch = 4, offset = 3, CreateTime = 1651592123485, serialized key size = -1, serialized value size = 4, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = skx1) ConsumerRecord(topic = first, partition = 0, leaderEpoch = 4, offset = 4, CreateTime = 1651592123487, serialized key size = -1, serialized value size = 4, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = skx2)python客户端代码（kafka-python 2.0.2）
# encoding=utf-8 import time from kafka import KafkaConsumer from kafka import TopicPartition consumer = KafkaConsumer(group_id="test-1", bootstrap_servers=["192.168.228.147:9092", "192.168.228.148:9092", "192.168.228.1479:9092"]) tps = [TopicPartition('first', 1)] consumer.assign(tps) while True: records = consumer.poll(timeout_ms=3) print(records) time.sleep(3) {TopicPartition(topic='first', partition=1): [ConsumerRecord(topic='first', partition=1, offset=8, timestamp=1651592878273, timestamp_type=0, key=None, value=b'skx0', headers=[], checksum=None, serialized_key_size=-1, serialized_value_size=4, serialized_header_size=-1), ConsumerRecord(topic='first', partition=1, offset=9, timestamp=1651592878287, timestamp_type=0, key=None, value=b'skx1', headers=[], checksum=None, serialized_key_size=-1, serialized_value_size=4, serialized_header_size=-1), ConsumerRecord(topic='first', partition=1, offset=10, timestamp=1651592878296, timestamp_type=0, key=None, value=b'skx4', headers=[], checksum=None, serialized_key_size=-1, serialized_value_size=4, serialized_header_size=-1)]} 5.3.3 消费者组案例1）需求：测试同一个主题的分区数据，只能由一个消费者组中的一个消费。
2）案例实操 （1）复制一份基础消费者的代码，在 IDEA 中同时启动，即可启动同一个消费者组中 的两个消费者。
（2）启动代码中的生产者发送消息，在 IDEA 控制台即可看到两个消费者在消费不同分区的数据（如果只发生到一个分区，可以在发送时增加延迟代码 Thread.sleep(2);）。
5.4 生产经验——分区的分配以及再平衡1、一个consumer group中有多个consumer组成，一个 topic有多个partition组成，现在的问题是，到底由哪个consumer来消费哪个 partition的数据。
2、Kafka有四种主流的分区分配策略： Range、RoundRobin、Sticky、CooperativeSticky。 可以通过配置参数partition.assignment.strategy，修改分区的分配策略。默认策略是Range + CooperativeSticky。Kafka可以同时使用 多个分区分配策略。
5.4.1 Range 以及再平衡 5.4.1.1 Range 分区策略原理Range 是对每个 topic 而言的。
首先对同一个 topic 里面的分区按照序号进行排序，并对消费者按照字母顺序进行排序。
假如现在有 7 个分区，3 个消费者，排序后的分区将会是0,1,2,3,4,5,6；消费者排序完之后将会是C0,C1,C2。例如，7/3 = 2 余 1 ，除不尽，那么 消费者 C0 便会多消费 1 个分区。 8/3=2余2，除不尽，那么C0和C1分别多消费一个。
通过 partitions数/consumer数 来决定每个消费者应该消费几个分区。如果除不尽，那么前面几个消费者将会多消费 1 个分区。分区分配策略之Range
注意：如果只是针对 1 个 topic 而言，C0消费者多消费1个分区影响不是很大。但是如果有 N 多个 topic，那么针对每个 topic，消费者 C0都将多消费 1 个分区，topic越多，C0消费的分区会比其他消费者明显多消费 N 个分区。容易产生数据倾斜！
5.4.1.2 Range 分区分配策略案例（1）修改主题 first 为 7 个分区。
/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 --alter --topic first --partitions 7注意：分区数可以增加，但是不能减少。 （2）复制 CustomConsumer 类，创建 CustomConsumer2。这样可以由三个消费者CustomConsumer、CustomConsumer1、CustomConsumer2 组成消费者组，组名都为“test”，同时启动 3 个消费者。
（3）启动 CustomProducer 生产者，发送 50 条消息，随机发送到不同的分区。
（4）观看 3 个消费者分别消费哪些分区的数据。
5.4.1.2.3 Range 分区分配再平衡案例（1）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。 1 号消费者：消费到 3、4 号分区数据。 2 号消费者：消费到 5、6 号分区数据。 0 号消费者的任务会整体被分配到 1 号消费者或者 2 号消费者。 说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 1 号消费者：消费到 0、1、2、3 号分区数据。 2 号消费者：消费到 4、5、6 号分区数据。 说明：消费者 0 已经被踢出消费者组，所以重新按照 range 方式分配。
5.4.2 RoundRobin 以及再平衡 5.4.2.1 RoundRobin 分区策略原理RoundRobin 针对集群中所有Topic而言。
RoundRobin 轮询分区策略，是把所有的 partition 和所有的consumer 都列出来，然后按照 hashcode 进行排序，最后通过轮询算法来分配 partition 给到各个消费者。
5.4.2.2 RoundRobin 分区分配策略案例（1）依次在 CustomConsumer、CustomConsumer1、CustomConsumer2 三个消费者代码中修改分区分配策略为 RoundRobin。
// 消费者组采用RoundRobin分区分配 properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, RoundRobinAssignor.class.getName());（2）重启 3 个消费者，重复发送消息的步骤，观看分区结果。
5.4.2.3 RoundRobin 分区分配再平衡案例（1）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。 1 号消费者：消费到 2、5 号分区数据 2 号消费者：消费到 4、1 号分区数据 0 号消费者的任务会按照 RoundRobin 的方式，把数据轮询分成 0 、6 和 3 号分区数据，分别由 1 号消费者或者 2 号消费者消费。 说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 1 号消费者：消费到 0、2、4、6 号分区数据 2 号消费者：消费到 1、3、5 号分区数据 说明：消费者 0 已经被踢出消费者组，所以重新按照 RoundRobin 方式分配。
5.4.3 Sticky 以及再平衡 5.4.3.1 Sticky 分区原理粘性分区定义：可以理解为分配的结果带有“粘性的”。即在执行一次新的分配之前，考虑上一次分配的结果，尽量少的调整分配的变动，可以节省大量的开销。
粘性分区是 Kafka 从 0.11.x 版本开始引入这种分配策略，首先会尽量均衡的放置分区到消费者上面，在出现同一消费者组内消费者出现问题的时候，会尽量保持原有分配的分区不变化。
1）需求 设置主题为 first，7 个分区；准备 3 个消费者，采用粘性分区策略，并进行消费，观察消费分配情况。然后再停止其中一个消费者，再次观察消费分配情况。
2）步骤 （1）修改分区分配策略为粘性。
ArrayList<String> startegys = new ArrayList<>(); startegys.add(StickyAssignor.class.getName()); properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, startegys);注意：3 个消费者都应该注释掉，之后重启 3 个消费者，如果出现报错，全部停止等会再重启，或者修改为全新的消费者组。
（2）使用同样的生产者发送 50 条消息。
5.4.3.2 Sticky 分区分配再平衡案例（1）停止掉 2 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。
0 号消费者：消费到 0、1、2 号分区数据。 1 号消费者：消费到 4、5 号分区数据。 2 号消费者的任务会按照粘性规则，尽可能均衡的随机分成 3 和 6 号分区数据，分别由 0 号消费者或者 1 号消费者消费。 说明：2 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 0 号消费者：消费到 0、1、2、6 号分区数据。 1 号消费者：消费到 3、4、5 号分区数据。 说明：消费者 2 已经被踢出消费者组，所以重新按照粘性方式分配。
5.5 offset 位移 5.5.1 offset 的默认维护位置__consumer_offsets 主题里面采用 key 和 value 的方式存储数据。key 是 group.id+topic+分区号，value 就是当前 offset 的值。每隔一段时间，kafka 内部会对这个 topic 进行compact，也就是每个 group.id+topic+分区号就保留最新数据。
消费 offset 案例 （0）思想：__consumer_offsets 为 Kafka 中的 topic，那就可以通过消费者进行消费。
（1）在配置文件 config/consumer.properties 中添加配置 exclude.internal.topics=false，默认是 true，表示不能消费系统主题。为了查看该系统主题数据，所以该参数修改为 false。
（2）启动生产者往 topic second 生产数据。
/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-producer.sh --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --topic second（3）启动消费者消费 second 数据。
/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 second --group test注意：指定消费者组名称，更好观察数据存储位置（key 是 group.id+topic+分区号）。
（4）查看消费者消费主题__consumer_offsets。
/usr/local/kafka/kafka_2.12-3.0.0/bin/kafka-console-consumer.sh --topic __consumer_offsets --bootstrap-server 192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092 --consumer.config /usr/local/kafka/kafka_2.12-3.0.0/config/consumer.properties --formatter "kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter" --from-beginning [test,second,2]::OffsetAndMetadata(offset=0, leaderEpoch=Optional.empty, metadata=, commitTimestamp=1651632918151, expireTimestamp=None) [test,second,0]::OffsetAndMetadata(offset=1, leaderEpoch=Optional[16], metadata=, commitTimestamp=1651632918151, expireTimestamp=None) [test,second,1]::OffsetAndMetadata(offset=2, leaderEpoch=Optional[16], metadata=, commitTimestamp=1651632918151, expireTimestamp=None) 5.5.2 自动提交 offset为了使我们能够专注于自己的业务逻辑，Kafka提供了自动提交offset的功能。
自动提交offset的相关参数：
虽然自动提交offset十分简单便利，但由于其是基于时间提交的，开发人员难以把握offset提交的时机。因此Kafka还提供了手动提交offset的API。
手动提交offset的方法有两种：分别是commitSync（同步提交）和commitAsync（异步提交）。两者的相同点是，都会将本次提交的一批数据最高的偏移量提交；不同点是，同步提交阻塞当前线程，一直到提交成功，并且会自动失败重试（由不可控因素导致，也会出现提交失败）；而异步提交则没有失败重试机制，故有可能提交失败。
commitSync（同步提交）：必须等待offset提交完毕，再去消费下一批数据。commitAsync（异步提交） ：发送完提交offset请求后，就开始消费下一批数据了。1）同步提交 offset 由于同步提交 offset 有失败重试机制，故更加可靠，但是由于一直等待提交结果，提交的效率比较低。
2）异步提交 offset 虽然同步提交 offset 更可靠一些，但是由于其会阻塞当前线程，直到提交成功。因吞吐量会受到很大的影响。因此更多的情况下，会选用异步提交 offset 的方式。
package com.skx.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.Arrays; import java.util.Properties; public class CustomConsumerByHandSync { public static void main(String[] args) { Properties properties = new Properties(); properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092"); properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 配置消费者组 properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test"); // 配置是否自动提交offset properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false); KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(properties); consumer.subscribe(Arrays.asList("first")); while (true) { ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1)); for (ConsumerRecord<String, String> consumerRecord : consumerRecords) { System.out.println(consumerRecord.value()); } // 同步提交 offset consumer.commitAsync(); // 异步提交 offset // consumer.commitSync(); } } } 5.5.4 指定 Offset 消费 earliest：自动将偏移量重置为最早的偏移量，–from-beginning。latest（默认值）：自动将偏移量重置为最新偏移量。none：如果未找到消费者组的先前偏移量，则向消费者抛出异常。任意指定 offset 位移开始消费
package com.skx.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 sun.awt.windows.WPrinterJob; import java.time.Duration; import java.util.ArrayList; import java.util.HashSet; import java.util.Properties; import java.util.Set; public class CustomConsumerSeek { public static void main(String[] args) { Properties properties = new Properties(); properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092"); properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test"); KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties); // 订阅一个主题 ArrayList<String> topics = new ArrayList<>(); topics.add("first"); kafkaConsumer.subscribe(topics); Set<TopicPartition> assignment = new HashSet<>(); while (assignment.size() == 0) { kafkaConsumer.poll(Duration.ofSeconds(1)); // 获取消费者分区分配信息（有了分区分配信息才能开始消费）,分区方案指定需要时间 assignment = kafkaConsumer.assignment(); } // 遍历所有分区，并指定 offset 从 50 的位置开始消费 for (TopicPartition tp : assignment) { kafkaConsumer.seek(tp, 50); } // 消费该主题数据 while (true) { ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1)); for (ConsumerRecord<String, String> consumerRecord : consumerRecords) { System.out.println(consumerRecord); } } } } 5.5.5 指定时间消费需求：在生产环境中，会遇到最近消费的几个小时数据异常，想重新按照时间消费。例如要求按照时间消费前一天的数据，怎么处理？
package com.skx.kafka.consumer; import org.apache.kafka.clients.consumer.*; import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.serialization.StringDeserializer; import java.time.Duration; import java.util.*; public class CustomConsumerForTime { public static void main(String[] args) { Properties properties = new Properties(); properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.228.147:9092,192.168.228.148:9092,192.168.228.149:9092"); properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test"); // 创建一个消费者 KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties); // 订阅一个主题 ArrayList<String> topics = new ArrayList<>(); topics.add("first"); kafkaConsumer.subscribe(topics); Set<TopicPartition> assignment = new HashSet<>(); while (assignment.size() == 0) { kafkaConsumer.poll(Duration.ofSeconds(1)); // 获取消费者分区分配信息（有了分区分配信息才能开始消费）,分区方案指定需要时间 assignment = kafkaConsumer.assignment(); } HashMap<TopicPartition, Long> timestampToSearch = new HashMap<>(); // 封装集合存储，每个分区对应一天前的数据 for (TopicPartition topicPartition : assignment) { timestampToSearch.put(topicPartition, System.currentTimeMillis() - 1 * 24 * 3600 * 1000); } // 获取从 1 天前开始消费的每个分区的 offset Map<TopicPartition, OffsetAndTimestamp> offsets = kafkaConsumer.offsetsForTimes(timestampToSearch); // 遍历每个分区，对每个分区设置消费时间。 for (TopicPartition topicPartition : assignment) { OffsetAndTimestamp offsetAndTimestamp = offsets.get(topicPartition); // 根据时间指定开始消费的位置 if (offsetAndTimestamp != null) { kafkaConsumer.seek(topicPartition, offsetAndTimestamp.offset()); } } // 消费该主题数据 while (true) { ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1)); for (ConsumerRecord<String, String> consumerRecord : consumerRecords) { System.out.println(consumerRecord); } } } } 5.5.6 漏消费和重复消费重复消费：已经消费了数据，但是 offset 没提交。
漏消费：先提交 offset 后消费，有可能会造成数据的漏消费。
5.6 生产经验——消费者事务如果想完成Consumer端的精准一次性消费，那么需要Kafka消费端将消费过程和提交offset过程做原子绑定。此时我们需要将Kafka的offset保存到支持事务的自定义介质（比如MySQL）。
5.7 生产经验——数据积压（消费者如何提高吞吐量）场景1：如果是Kafka消费能力不足，则可以考虑增加Topic的分区数，并且同时提升消费组的消费者数量，消费者数 = 分区数。（两者缺一不可）
场景2：如果是下游的数据处理不及时：提高每批次拉取的数量。批次拉取数据过少（拉取数据/处理时间 < 生产速度），使处理的数据小于生产的数据，也会造成数据积压。
左图为 Kafka 现有架构，元数据在 zookeeper 中，运行时动态选举 controller，由controller 进行 Kafka 集群管理。右图为 kraft 模式架构（实验性），不再依赖 zookeeper 集群，而是用三台 controller 节点代替 zookeeper，元数据保存在 controller 中，由 controller 直接进行 Kafka 集群管理。
这样做的好处有以下几个：
Kafka 不再依赖外部框架，而是能够独立运行；
controller 管理集群时，不再需要从 zookeeper 中先读取数据，集群性能上升；由于不依赖 zookeeper，集群扩展时不再受到 zookeeper 读写能力限制；controller 不再动态选举，而是由配置文件规定。这样我们可以有针对性的加强controller 节点的配置，而不是像以前一样对随机 controller 节点的高负载束手无策。 6.2 Kafka-Kraft 集群部署1）再次解压一份 kafka 安装包到目录/usr/local/kafka，重命名为kafka_kraft
2）在节点1上修改/usr/local/kafka/kafka_kraft/config/kraft/server.properties配置文件
#kafka 的角色（controller 相当于主机、broker 节点相当于从机，主机类似 zk 功能） process.roles=broker,controller #节点 ID node.id=1 #全 Controller 列表 controller.quorum.voters=1@192.168.228.147:9093,2@192.168.228.148:9093,3@192.168.228.149:9093 #不同服务器绑定的端口 listeners=PLAINTEXT://:9092,CONTROLLER://:9093 # broker 服务协议别名 inter.broker.listener.name=PLAINTEXT # broker 对外暴露的地址 advertised.listeners=PLAINTEXT://192.168.228.147:9092 # controller 服务协议别名 controller.listener.names=CONTROLLER # 协议别名到安全协议的映射 listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL # kafka 数据存储目录 log.dirs=/usr/local/kafka/kafka_kraft/kafka_logs3）节点2，节点3相同的操作
在节点2和节点3上需要对node.id相应改变，值需要和controller.quorum.voters对应。
在节点2和节点3上需要根据各自的主机ip，修改相应的advertised.Listeners地址。
4）初始化集群数据目录 （1）首先生成存储目录唯一 ID。
/usr/local/kafka/kafka_kraft/bin/kafka-storage.sh random-uuid mHm4I8YRQoKZp1iD7ucyNw（2）用该 ID 格式化 kafka 存储目录（三台节点）。
/usr/local/kafka/kafka_kraft/bin/kafka-storage.sh format -t mHm4I8YRQoKZp1iD7ucyNw -c /usr/local/kafka/kafka_kraft/config/kraft/server.properties5）启动 kafka 集群
分别字三个节点执行启动脚本，拉起kafka
/usr/local/kafka/kafka_kraft/bin/kafka-server-start.sh -daemon /usr/local/kafka/kafka_kraft/config/kraft/server.properties6）停止 kafka 集群
/usr/local/kafka/kafka_kraft/bin/kafka-server-stop.sh 6.3 Kafka-Kraft 集群启动停止脚本 #! /bin/bash passwd=xxxxxx case $1 in "start"){ for i in 192.168.228.147 192.168.228.148 192.168.228.149 do echo " --------启动 $i Kafka-------" sshpass -p $passwd ssh -p 22 root@$i /usr/local/kafka/kafka_kraft/bin/kafka-server-start.sh -daemon /usr/local/kafka/kafka_kraft/config/kraft/server.properties done };; "stop"){ for i in 192.168.228.147 192.168.228.148 192.168.228.149 do echo " --------停止 $i Kafka-------" sshpass -p $passwd ssh -p 22 root@$i /usr/local/kafka/kafka_kraft/bin/kafka-server-stop.sh done };; esac3）启动集群命令
sh kf_kraft.sh start4）停止集群命令
sh kf_kraft.sh stop
 1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，会注明原创字样,如未注明都非原创，如有侵权请联系删除！；3.作者投稿可能会经我们编辑修改或补充；4.本站不提供任何储存功能只提供收集或者投稿人的网盘链接。 |
