Kafka(二) - 技术栈

第 4 章 Kafka Broker

4.1 Kafka Broker 工作流程

4.1.1 Zookeeper 存储的 Kafka 信息

（1）启动 Zookeeper 客户端。

bin/zkCli.sh

（2）通过 ls 命令可以查看 kafka 相关信息。

ls /kafka

4.1.2 Kafka Broker 总体工作流程

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

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

ls /kafka/brokers/ids 
 
[0, 1, 2]

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

 get /kafka/controller
{"version":1,"brokerid":0,"timestamp":"1637292471777"}

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

get  /kafka/brokers/topics/first/partitions/0/state 
 
{"controller_epoch":24,"leader":0,"version":1,"leader_epoch":18," isr":[0,1,2]}

（4）停止 hadoop104 上的 kafka。

bin/kafka-server-stop.sh

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

ls /kafka/brokers/ids
[0, 1]

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

get /kafka/controller
{"version":1,"brokerid":0,"timestamp":"1637292471777"}

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

get /kafka/brokers/topics/first/partitions/0/state
{"controller_epoch":24,"leader":0,"version":1,"leader_epoch":18,"isr":[0,1]}

（8）启动 hadoop104 上的 kafka。

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

（9）再次观察（1）、（2）、（3）步骤中的内容。

4.1.3 Broker 重要参数

4.3 Kafka 副本

4.3.1 副本基本信息

Kafka 副本作用：提高数据可靠性。
Kafka 默认副本 1 个，生产环境一般配置为 2 个，保证数据可靠性；太多副本会增加磁盘存储空间，增加网络上数据传输，降低效率。
Kafka 中副本分为：Leader 和 Follower。Kafka 生产者只会把数据发往 Leader，然后 Follower 找 Leader 进行同步数据。
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 故障处理细节

4.3.4 分区副本分配

如果 kafka 服务器只有 4 个节点，那么设置 kafka 的分区数大于服务器台数，在 kafka 底层如何分配存储副本呢？

1）创建 16 分区，3 个副本（1）创建一个新的 topic，名称为 second。

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --create --partitions 16 --replication-factor 3 -topic second

（二）查看分区和副本情况。

[atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --describe --topic second  
Topic: second4 Partition: 0 Leader: 0 Replicas: 0,1,2 Isr: 0,1,2 
Topic: second4 Partition: 1 Leader: 1 Replicas: 1,2,3 Isr: 1,2,3 
Topic: second4 Partition: 2 Leader: 2 Replicas: 2,3,0 Isr: 2,3,0 Topic: second4 Partition: 3 Leader: 3 Replicas: 3,0,1 Isr: 3,0,1 
 
Topic: second4 Partition: 4 Leader: 0 Replicas: 0,2,3 Isr: 0,2,3 
Topic: second4 Partition: 5 Leader: 1 Replicas: 1,3,0 Isr: 1,3,0 
Topic: second4 Partition: 6 Leader: 2 Replicas: 2,0,1 Isr: 2,0,1 Topic: second4 Partition: 7 Leader: 3 Replicas: 3,1,2 Isr: 3,1,2  
Topic: second4 Partition: 8 Leader: 0 Replicas: 0,3,1 Isr: 0,3,1 
Topic: second4 Partition: 9 Leader: 1 Replicas: 1,0,2 Isr: 1,0,2 Topic: second4 Partition: 10 Leader: 2 Replicas: 2,1,3 Isr: 2,1,3 Topic: second4 Partition: 11 Leader: 3 Replicas: 3,2,0 Isr: 3,2,0  
Topic: second4 Partition: 12 Leader: 0 Replicas: 0,1,2 Isr: 0,1,2 
Topic: second4 Partition: 13 Leader: 1 Replicas: 1,2,3 Isr: 1,2,3 
Topic: second4 Partition: 14 Leader: 2 Replicas: 2,3,0 Isr: 2,3,0 
Topic: second4 Partition: 15 Leader: 3 Replicas: 3,0,1 Isr: 3,0,1

4.4 文件存储

4.4.1 文件存储机制

1）Topic 数据的存储机制

2）思考：Topic 数据到底存储在什么位置？

3）index 文件和 log 文件详解

说明：日志存储参数配置

4.4.2 文件清理策略

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

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

那么日志一旦超过了设置的时间，怎么处理呢？

Kafka 中提供的日志清理策略有 delete 和 compact 两种。

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

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

1. 1. 基于时间：默认打开。以 segment 中所有记录中的最大时间戳作为该文件时间戳。
  2. 基于大小：默认关闭。超过设置的所有日志总大小，删除最早的 segment。

log.retention.bytes，默认等于-1，表示无穷大。

思考：如果一个 segment 中有一部分数据过期，一部分没有过期，怎么处理？

2）compact 日志压缩

4.5 高效读写数据

Kafka 本身是分布式集群，可以采用分区技术，并行度高
读数据采用稀疏索引，可以快速定位要消费的数据
顺序写磁盘

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

4）页缓存 + 零拷贝技术

第 5 章 Kafka 消费者

5.1 Kafka 消费方式

5.2 Kafka 消费者工作流程

5.2.1 消费者总体工作流程

5.2.2 消费者组原理

5.2.3 消费者重要参数

5.3 消费者 API

5.3.1 独立消费者案例（订阅主题）

1）需求：创建一个独立消费者，消费 first 主题中数据。

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

2）实现步骤（1）创建包名：com.atguigu.kafka.consumer （2）编写代码

package com.atguigu.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 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, "hadoop102: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); 
            } 
        } 
    } 
}

5.3.2 独立消费者案例（订阅分区）

1）需求：创建一个独立消费者，消费 first 主题 0 号分区的数据。

2）实现步骤（1）代码编写。

package com.atguigu.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 java.time.Duration; import java.util.ArrayList; import java.util.Arrays; import java.util.Properties; 
 
public class CustomConsumerPartition { 
 
    public static void main(String[] args) { 
 
        Properties properties = new Properties(); 
         
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :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); 
            } 
        } 
    } 
}

5.3.3 消费者组案例

1）需求：测试同一个主题的分区数据，只能由一个消费者组中的一个消费。

2）案例实操（1）复制一份基础消费者的代码，在 IDEA 中同时启动，即可启动同一个消费者组中的两个消费者。

package com.atguigu.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 java.time.Duration; import java.util.ArrayList; import java.util.Properties; 
 
public class CustomConsumer1 { 
 
    public static void main(String[] args) { 
 
        // 1.创建消费者的配置对象 
        Properties properties = new Properties(); 
 
        // 2.给消费者配置对象添加参数 
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102: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); 
            } 
        } 
    } }

5.4 生产经验------分区的分配以及再平衡

5.4.1 Range 以及再平衡

1）Range 分区策略原理

3 ）Range 分区分配再平衡案例

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

号消费者：消费到 3、4 号分区数据。
号消费者：消费到 5、6 号分区数据。

0 号消费者的任务会整体被分配到 1 号消费者或者 2 号消费者。

说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。

再次重新发送消息观看结果（45s 以后）。

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

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

5.4.2 RoundRobin 以及再平衡

1）RoundRobin 分区策略原理

3）RoundRobin 分区分配再平衡案例

（一）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。

1 号消费者：消费到 2、5 号分区数据

2 号消费者：消费到 4、1 号分区数据

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

（二）再次重新发送消息观看结果（45s 以后）。

1号消费者：消费到 0、2、4、6 号分区数据

2号消费者：消费到 1、3、5 号分区数据

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

5.4.3 Sticky 以及再平衡

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

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

3）Sticky 分区分配再平衡案例

Sticky 分区分配再平衡案例

（一）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。

1号消费者：消费到 2、5、3 号分区数据。

2号消费者：消费到 4、6 号分区数据。

0 号消费者的任务会按照粘性规则，尽可能均衡的随机分成 0 和 1 号分区数据，分别由 1 号消费者或者 2 号消费者消费。

（二）再次重新发送消息观看结果（45s 以后）。

1号消费者：消费到 2、3、5 号分区数据。

2号消费者：消费到 0、1、4、6 号分区数据。

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

5.5 offset 位移

5.5.1 offset 的默认维护位置

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

5.5.2 自动提交 offset

为了使我们能够专注于自己的业务逻辑，Kafka提供了自动提交offset的功能。

自动提交offset的相关参数：

enable.auto.commit：是否开启自动提交offset功能，默认是true

auto.commit.interval.ms：自动提交offset的时间间隔，默认是5s

1）消费者自动提交 offset

package com.atguigu.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 java.util.Arrays; import java.util.Properties; 
 public class CustomConsumerAutoOffset { 
 
    public static void main(String[] args) { 
 
        // 1. 创建kafka消费者配置类 
        Properties properties = new Properties(); 
 
        // 2. 添加配置参数         // 添加连接         properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, 
"hadoop102:9092"); 
        
        // 配置序列化 必须 
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, 
"org.apache.kafka.common.serialization.StringDeserializer"); 

        
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");  
        // 配置消费者组 
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test");  
        // 是否自动提交offset         properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, true); 
        // 提交offset的时间周期1000ms，默认5s 
properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 1000); 
 
        //3. 创建kafka消费者 
	        KafkaConsumer<String, 	String> 	consumer 	= 	new 
KafkaConsumer<>(properties); 
 
        //4. 设置消费主题  形参是列表 
        consumer.subscribe(Arrays.asList("first")); 
 
        //5. 消费数据         while (true){ 
            // 读取消息 
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1)); 
 
            // 输出消息             for (ConsumerRecord<String, String> consumerRecord : 
consumerRecords) { 
                System.out.println(consumerRecord.value()); 
            } 
        } 
    } 
}

第 6 章 Kafka-Eagle 监控

Kafka-Eagle 框架可以监控 Kafka 集群的整体运行情况，在生产环境中经常使用。

6.1 MySQL 环境准备

Kafka-Eagle 的安装依赖于 MySQL，MySQL 主要用来存储可视化展示的数据。如果集群中之前安装过 MySQL 可以跨过该步。

6.2 Kafka 环境准备

详见尚硅谷PDF

6.3 Kafka-Eagle 安装

详见尚硅谷PDF

6.4 Kafka-Eagle 页面操作

1）登录页面查看监控数据

Dashboard - EFAK