Kafka学习笔记--kafka 概述、快速入门，架构深入

我就是我 2022-10-29 09:28 261阅读 0赞

### 文章目录 ###

*  第 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 jar 包下载
         *  2.1.3 集群部署
     *  2.2 Kafka 命令行操作
 *  第 3 章 Kafka 架构深入
 *   *  3.1 Kafka 工作流程及文件存储机制
     *  3.2 Kafka 生产者
     *   *  3.2.1 分区策略
         *  3.2.2 数据可靠性保证
         *   *  1）副本数据同步策略
             *  2）ISR
             *  3）ack 应答机制
             *  4）故障处理细节
         *  3.2.3 Exactly Once 语义
     *  3.3 Kafka 消费者
     *   *  3.3.1 消费方式
         *  3.3.2 分区分配策略
         *  3.3.3 offset 的维护
         *  3.3.4 消费者组案例
     *  3.4 Kafka 高效读写
     *  3.5 Zookeeper 在 Kafka 中的作用
     *  3.6 Kafka 事务
     *   *  3.6.1 Producer 事务
         *  3.6.2 Consumer 事务

# 第 1 章 Kafka 概述 #

## 1.1 定义 ##

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

## 1.2 消息队列 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70]  
同步处理时步骤 5 可能较长时间未进行，用户长时间得不到相应。采用异步的方式，消息注册到数据库中之后，马上给用户响应，发送消息的请求写入消息队列中，等待发送消息，这样发送短信的时效性就没这么重要了。

**使用消息队列的好处**

1.  **解耦**：允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。
2.  **可恢复性**：系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。
3.  **缓冲**：有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致  
    的情况。
4.  **灵活性 & 峰值处理能力**：在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。
5.  **异步通信**：很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。

### 1.2.2 消息队列的两种模式 ###

（1）**点对点模式**（一对一，消费者主动拉取数据，消息收到后消息清除）

消息生产者生产消息发送到 Queue 中，然后消息消费者从 Queue 中取出并且消费消息。消息被消费以后，queue 中不再有存储，所以消息消费者不可能消费到已经被消费的消息。Queue 支持存在多个消费者，但是对一个消息而言，只会有一个消费者可以消费。  
![在这里插入图片描述][20210215181213554.png]

（2）**发布/订阅模式**（一对多，消费者消费数据之后不会清除消息）

消息生产者（发布）将消息发布到 topic 中，同时有多个消息消费者（订阅）消费该消息。和点对点方式不同，发布到 topic 的消息会被所有订阅者消费。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 1]

## 1.3 Kafka 基础架构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 2]

1.  **Producer**：消息生产者，就是向 kafka broker 发消息的客户端；
2.  **Consumer**：消息消费者，向 kafka broker 取消息的客户端；
3.  **Consumer Group(CG)**：消费者组，由多个 consumer 组成。 消费者组内每个消费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费；消费者组之间互不影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。同一个组的消费者之间时竞争关系，一个 partition 被一个消费者消费了，就不会被组内另一个消费者消费；
4.  **Broker**：一台 kafka 服务器就是一个 broker。一个集群由多个 broker 组成。一个 broker 可以容纳多个 topic。
5.  **Topic**：可以理解为一个队列， 生产者和消费者面向的都是一个 topic；
6.  **Partition**：为了实现扩展性，一个非常大的 topic 可以分布到多个 broker（即服务器）上，一个 topic 可以分为多个 partition，每个 partition 是一个有序的队列；分区提高 topic 并发，提高负载均衡能力；
7.  **Replica**：副本，为保证集群中的某个节点发生故障时，该节点上的 partition 数据不丢失，且 kafka 仍然能够继续工作，kafka 提供了副本机制，一个 topic 的每个分区都有若干个副本，一个 leader 和若干个 follower。
8.  **leader**：每个分区多个副本的“主”，生产者发送数据的对象，以及消费者消费数据的对象都是 leader。
9.  **follower**：每个分区多个副本中的“从”，实时从 leader 中同步数据，保持和 leader 数据的同步。leader 发生故障时，某个 follower 会成为新的 follower。

# 第 2 章 Kafka 快速入门 #

## 2.1 安装部署 ##

### 2.1.1 集群规划 ###

这里再本地 ubuntu 安装，就只装了一个节点  
安装 zookeeper-3.4.10，kafka-0.11.0

### 2.1.2 jar 包下载 ###

http://kafka.apache.org/downloads.html  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 3]

### 2.1.3 集群部署 ###

1）解压安装包

$ tar -zxvf kafka_2.11-0.11.0.0.tgz -C /opt/module/

2）修改解压后的文件名称

$ mv kafka_2.11-0.11.0.0/ kafka

3）在/opt/module/kafka 目录下创建 logs 文件夹

$ mkdir logs

4）修改配置文件

$ cd config/
    $ vim server.properties

#broker 的全局唯一编号，不能重复
    broker.id=0
    #删除 topic 功能使能
    delete.topic.enable=true
    #处理网络请求的线程数量
    num.network.threads=3
    #用来处理磁盘 IO 的现成数量
    num.io.threads=8
    #发送套接字的缓冲区大小
    socket.send.buffer.bytes=102400
    #接收套接字的缓冲区大小
    socket.receive.buffer.bytes=102400
    #请求套接字的缓冲区大小
    socket.request.max.bytes=104857600
    #kafka 运行日志存放的路径
    log.dirs=/opt/module/kafka/logs
    #topic 在当前 broker 上的分区个数
    num.partitions=1
    #用来恢复和清理 data 下数据的线程数量
    num.recovery.threads.per.data.dir=1
    #segment 文件保留的最长时间，超时将被删除
    log.retention.hours=168
    #配置连接 Zookeeper 集群地址
    zookeeper.connect=localhost:2181

该文件中需要修改的有这几个配置项，broker.id、delete.topic.enable、log.dirs、zookeeper.connect

注意：这里的配置项 log.dirs 对应的目录下存放的并不是 kafka 的日志，而是 kafka 的消息数据。

如果是以集群方式部署的，还需要再其他节点修改配置文件 config/server.properties，broker.id 不能重复，可以是 0，1，2 这种

5）启动 zookeeper

bin/zkServer.sh start

6）启动kafka

bin/kafka-server-start.sh -daemon config/server.properties
    
    -daemon：以守护进程的方式启动，不以阻塞

7）关闭 kafka 进程

bin/kafka-server-stop.sh

8）关闭zookeeper进程

bin/zkServer.sh stop

## 2.2 Kafka 命令行操作 ##

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

bin/kafka-topics.sh --zookeeper localhost:2181 --list
    bin/kafka-topics.sh --zookeeper localhost:2181 --describe

![在这里插入图片描述][20210215211312534.png]

2）创建 topic

bin/kafka-topics.sh --zookeeper localhost:2181 --create --topic first --partitions 2 --replication-factor 1
    
    选项说明：
    --topic 定义 topic 名
    --partitions 指定分区数量
    --replication-factor 指定副本数量，副本数量不能大于broker的数量

![在这里插入图片描述][2021021521135657.png]

3）删除 topic

bin/kafka-topics.sh --delete --zookeeper localhost:2181 --topic first

![在这里插入图片描述][20210215211516450.png]  
我们已经将配置项 delete.topic.enable 设为 True，这条删除语句会将 first topic 删除，否则将不会生效。

4）发送消息

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic first

5）消费消息

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic first
    
    bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic first --from-beginning

6）查看某个 topic 的详情

bin/kafka-topics.sh --zookeeper localhost:2181 --describe --topic first

![在这里插入图片描述][20210215213033222.png]

7）修改分区数

bin/kafka-topics.sh --zookeeper localhost:2181 --alter --topic first --partitions 3

将 partitions 数量改为 3 个

# 第 3 章 Kafka 架构深入 #

## 3.1 Kafka 工作流程及文件存储机制 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 4]  
Kafka 中消息是以 topic 进行分类的，生产者生产消息，消费者消费消息，都是面向 topic 的。

topic 是逻辑上的概念，而 partition 是物理上的概念，每个 partition 对应于一个 log 文件，该 log 文件中存储的就是 producer 生产的数据。Producer 生产的数据会被不断追加到该log 文件末端，且每条数据都有自己的 offset。消费者组中的每个消费者，都会实时记录自己消费到了哪个 offset，以便出错恢复时，从上次的位置继续消费。

文件目录中每个 partition 对应一个文件夹，没有 topic 对应的文件夹，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 6]  
由于生产者生产的消息会不断追加到 log 文件末尾，为防止 log 文件过大导致数据定位效率低下，Kafka 采取了分片和索引机制，将每个 partition 分为多个 segment。每个 segment 对应两个文件——“.index”文件和“.log”文件。这些文件位于一个文件夹下，该文件夹的命名规则为：topic 名称+分区序号。例如，first 这个 topic 有三个分区，则其对应的文件夹为 first-0,first-1,first-2。

00000000000000000000.index
    00000000000000000000.log
    00000000000000170410.index
    00000000000000170410.log
    00000000000000239430.index
    00000000000000239430.log

index 和 log 文件以当前 segment 的第一条消息的 offset 命名。下图为 index 文件和 log 文件的结构示意图。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 7]  
“.index”文件存储大量的索引信息，“.log”文件存储大量的数据，索引文件中的元数据指向对应数据文件中 message 的物理偏移地址。

**手动模拟一遍如果索引消息**：

指定一个偏移量，如果在该 partition 中快速找到改偏移量 offset 对应的消息内容呢，假设找 offset = 3 的消息，首先需要找到该消息在哪个 .log 文件中，这个简单，.log 和 .index 文件是以该文件中第一条消息的偏移量进行命令的，二分法可以快速定位到在对应的 .log 和 .index 文件，假设该文件夹下文件为 00000000000000000000.index，00000000000000000000.log，00000000000000000006.index，00000000000000000006.log，可以得到消息在 00000000000000000000.log 中，索引信息在 00000000000000000000.index 中，Message-0，Message-1等每条消息的大小虽然不是固定的，但是在 .index 文件中，消息编号和消息的地址大小的固定的，根据第一条消息编号为1，找编号为 3 的消息，可以在 .index 文件中快速跳转到编号为 3 的位置，从而取出 offset = 3 的消息的地址为 756，直接在文件 00000000000000000000.log 中找地址为 756 的位置就找到了offset = 3 的消息。

## 3.2 Kafka 生产者 ##

### 3.2.1 分区策略 ###

**1) 分区的原因**

1.  方便在集群中扩展，每个 Partition 可以通过调整以适应它所在的机器，而一个 topic又可以有多个 Partition 组成，因此整个集群就可以适应任意大小的数据了；
2.  可以提高并发，因为可以以 Partition 为单位读写了。

**2) 分区的原则**

我们需要将 producer 发送的数据封装成一个 ProducerRecord 对象。![在这里插入图片描述][2021021522115650.png]

1.  指明 partition 的情况下，直接将指明的值直接作为 partiton 值；
2.  没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值；
3.  既没有 partition 值又没有 key 值的情况下，第一次调用时随机生成一个整数（后面每次调用在这个整数上自增），将这个值与 topic 可用的 partition 总数取余得到 partition 值，也就是常说的 round-robin 算法。

### 3.2.2 数据可靠性保证 ###

为保证 producer 发送的数据，能可靠的发送到指定的 topic，topic 的每个 partition 收到 producer 发送的数据后，都需要向 producer 发送 ack（acknowledgement 确认收到），如果 producer 收到 ack，就会进行下一轮的发送，否则重新发送数据。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 8]  
**何时发送 ack？**

*  确保有 follower 与 leader 同步完成，leader 再发送 ack，这样才能保证 leader 挂掉之后，能在 follower 中选举出新的 leader。

**多少个 follower 同步完成之后发送 ack？**

*  方案 1：半数以上的 follower 同步完成，即可发送 ack 继续发送重新发送
 *  方案 2：全部的 follower 同步完成，才可以发送 ack

#### 1）副本数据同步策略 ####

<table> 
 <thead> 
  <tr> 
   <th>方案</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>半数以上完成同步， 就发送 ack</td> 
   <td>延迟低</td> 
   <td>选举新的 leader 时，容忍 n 台节点的故障，需要 2n+1 个副本</td> 
  </tr> 
  <tr> 
   <td>全部完成同步，才发送ack</td> 
   <td>选举新的 leader 时， 容忍 n 台节点的故障，需要 n+1 个副本</td> 
   <td>延迟高</td> 
  </tr> 
 </tbody> 
</table>

> 为了保证数据可靠，则至少要保证由一台机器上的数据是完整的，所以  
> 方案1：一共 2n+1 个节点，半数以上完成同步，则至少 n+1 个节点完成同步，挂了 n 个节点，至少有 1 个节点的数据是完整的  
> 方案2：全部同步完成，一个 n+1 个节点，挂了 n 个，还有 1 个节点数据是完整的

Kafka 选择了第二种方案，原因如下：

1.  同样为了容忍 n 台节点的故障，第一种方案需要 2n+1 个副本，而第二种方案只需要 n+1 个副本，而 Kafka 的每个分区都有大量的数据，第一种方案会造成大量数据的冗余。
2.  虽然第二种方案的网络延迟会比较高，但网络延迟对 Kafka 的影响较小。

#### 2）ISR ####

采用第二种方案之后，设想以下情景：leader 收到数据，所有 follower 都开始同步数据，但有一个 follower，因为某种故障，迟迟不能与 leader 进行同步，那 leader 就要一直等下去，直到它完成同步，才能发送 ack。这个问题怎么解决呢？

Leader 维护了一个动态的 in-sync replica set (ISR)，意为和 leader 保持同步的 follower 集合。当 ISR 中的 follower 完成数据的同步之后，leader 就会给 follower 发送 ack。如果 follower 长时间未向 leader 同步数据 ， 则该 follower 将被踢出 ISR ， 该时间阈值由 replica.lag.time.max.ms 参数设定。Leader 发生故障之后，就会从 ISR 中选举新的 leader。

> 旧版本的 kafka 选择哪个 follower 进入 ISR 取决于两个条件，同步数据的延迟时间、follower 和 leader 相差的数据条数，新版本 kafka 移除了消息条数这个条件，因为消息可能一次发送一批消息，导致短时间消息条数 leader 和 follower 差距较大，这时所有的 follower 被移除 ISR，同步完又加入 ISR，这个信息放在 zookeeper 中，会频繁操作 ISR，频繁写 zk。

#### 3）ack 应答机制 ####

对于某些不太重要的数据，对数据的可靠性要求不是很高，能够容忍数据的少量丢失，所以没必要等 ISR 中的 follower 全部接收成功。

所以 Kafka 为用户提供了三种可靠性级别，用户根据对可靠性和延迟的要求进行权衡，选择以下的配置。

**acks 参数配置：**

*  **acks = 0**：producer 不等待 broker 的 ack，这一操作提供了一个最低的延迟，broker 一接收到还没有写入磁盘就已经返回，当 broker 故障时有可能 丢失数据；
 *  **acks = 1**：producer 等待 broker 的 ack，partition 的 leader 落盘成功后返回 ack，如果在 follower，同步成功之前 leader 故障，那么将会丢失数据；
 *  **acks = -1(all)**：producer 等待 broker 的 ack，partition 的 leader 和 follower 全部落盘成功后才返回 ack。但是如果在 follower 同步完成后，broker 发送 ack 之前，leader 发生故障，那么会造成数据重复。

acks = 1 数据丢失案例：leader 已经写数据了，返回 ack 了，follower 还没写数据，leader 挂了，生产者不会重新发送，follower 也没有数据

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 9]  
acks = -1 数据丢失情况：ISR中 的所有的 follower 都被移除了，退化到 acks=1 的情况了，这种情况很少出现。更多的情况是 acks = -1 导致数据重复。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 10]

acks = -1 数据重复情况：ISR 中的 follower 已经同步了数据，leader 还没发送 ack，leader 挂掉了，已经写数据看 follower 变成 leader，生产者已经没有写入数据，重发，导致又写了一份

#### 4）故障处理细节 ####

背景：如果 leader 已经同步数据了，follower 还没同步数据或者尚未同步完成，leader 挂了，某一个follower 变成 leader，此时原来的 leader 又活了，出现 follower 比 leader 数据多的情况，数据不一致了，如何处理？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 11]  
**LEO** ：指的是每个副本最大的 offset；  
**HW** ：指的是消费者能见到的最大的 offset ，ISR 队列中最小的 LEO。

（1）follower 故障  
follower 发生故障后会被临时踢出 ISR，待该 follower 恢复后，follower 会读取本地磁盘记录的上次的 HW，并将 log 文件高于 HW 的部分截取掉，从 HW 开始向 leader 进行同步。等该 follower 的 LEO 大于等于该 Partition 的 的 HW，即 follower 追上 leader 之后，就可以重新加入 ISR 了。  
（2）leader 故障  
leader 发生故障之后，会从 ISR 中选出一个新的 leader，之后，为保证多个副本之间的数据一致性，其余的 follower 会先将各自的 log 文件高于 HW 的部分截掉，然后从新的 leader 同步数据。

> 注意：这只能保证副本之间的数据一致性，并不能保证数据不丢失或者不重复  
> 数据重复 eg:  
> 假设生产者发消息 13-19，ISR 中有两个 follower，leader 挂了，第二 follower 同步了 13-15，然后变成 leader，由于 ISR 没同同步完生产者没收到 ack，重新发送了13-19，follower 已经同步的 13-15 就重复了

### 3.2.3 Exactly Once 语义 ###

将服务器的 ACK 级别设置为 -1，可以保证 Producer 到 Server 之间不会丢失数据，即 At Least Once 语义。相对的，将服务器 ACK 级别设置为 0，可以保证生产者每条消息只会被发送一次，即 At Most Once 语义。

At Least Once 可以保证数据不丢失，但是不能保证数据不重复；相对的，At Least Once 可以保证数据不重复，但是不能保证数据不丢失。但是，对于一些非常重要的信息，比如说交易数据，下游数据消费者要求数据既不重复也不丢失，即 Exactly Once 语义。在 0.11 版本以前的 Kafka，对此是无能为力的，只能保证数据不丢失，再在下游消费者对数据做全局去重。对于多个下游应用的情况，每个都需要单独做全局去重，这就对性能造成了很大影响。

0.11 版本的 Kafka，引入了一项重大特性：幂等性。所谓的幂等性就是指 Producer 不论向 Server 发送多少次重复数据，Server 端都只会持久化一条。幂等性结合 At Least Once 语义，就构成了 Kafka 的 Exactly Once 语义。即：

At Least Once + 幂等性 = Exactly Once

要启用幂等性，只需要将 Producer 的参数中 enable.idompotence 设置为 true 即可。Kafka 的幂等性实现其实就是将原来下游需要做的去重放在了数据上游。开启幂等性的 Producer 在初始化的时候会被分配一个 PID，发往同一 Partition 的消息会附带 Sequence Number。而 Broker 端会对 <PID, Partition, SeqNumber>做缓存，当具有相同主键的消息提交时，Broker 只会持久化一条。

但是 PID 重启就会变化，同时不同的 Partition 也具有不同主键，所以幂等性无法保证跨分区跨会话的 Exactly Once。

## 3.3 Kafka 消费者 ##

### 3.3.1 消费方式 ###

consumer 采用 pull（拉）模式从 broker 中读取数据。

push（推）模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适当的速率消费消息。

pull 模式不足之处是，如果 kafka 没有数据，消费者可能会陷入循环中，一直返回空数据。针对这一点，Kafka 的消费者在消费数据时会传入一个时长参数 timeout，如果当前没有数据可供消费，consumer 会等待一段时间之后再返回，这段时长即为 timeout。

### 3.3.2 分区分配策略 ###

一个 consumer group 中有多个 consumer，一个 topic 有多个 partition，所以必然会涉及到 partition 的分配问题，即确定那个 partition 由哪个 consumer 来消费。

Kafka 有两种分配策略，一是 RoundRobin，一是 Range。

*  **1）RoundRobin**  
    按照组类划分，将所有的 topic 的 partition 轮询分给 consumer

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 12]  
RoundRobin 将所有 topic 的 Partition 放在一起，轮询分给消费者。

缺点：可能会将消息发给给未订阅 topic 的消费者，如下所示，consumer0 订阅了 topic0、topic1，consumer1订阅了topic1、topic2；t0P0 代表 topic0 的 Partition0；RoundRobin 会将三个 topic 的 partition 放在一起进行排序，然后轮询发给 consumer，这样会导致 consumer0 会接收 topic2 的消息，consumer1 会接收 topic0 的消息。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 13]

*  **2）Range**  
    按照 topic 进行划分，将该 topic 的 partition 平均分给 consumer  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 14]  
    Range 按照 topic 的将 partition 分给 consumer，将一个 topic 中的 partition 分给订阅的 consumer，假设有 partition0-partition6 7个分区，将 0-2 分区分给 consumer0，3-4 分区分给 consumer1，5-6 分区分给 consumer2

缺点：可能会导致不同的 consumer 分配不均衡，如下所示，topic0 有三个 partition，topic1 有三个 partition；consumer0 和， consumer1 都订阅了topic0 和 topic1，Range 会导致 consumer0 分到 4 个 partition，consumer1 分到 2 个 partition。随着 topic 的增加，分配不均衡的问题会更加严重。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 15]

kafka 默认使用 Range 的方式对分区进行分配。

分区分配策略触发时机：当消费者组中的消费者数量发生变化时，就会触发分区分配策略

### 3.3.3 offset 的维护 ###

由于 consumer 在消费过程中可能会出现断电宕机等故障，consumer 恢复后，需要从故障前的位置的继续消费，所以 consumer 需要实时记录自己消费到了哪个 offset，以便故障恢复后继续消费。

group + topc + partition 唯一确定一个 offset，这样一个消费者组中一个消费者挂了，其他消费者可以接着消费，或者有新的消费者加入消费者组，可以从还没消费的位置接着消费  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 16]  
Kafka 0.9 版本之前，consumer 默认将 offset 保存在 Zookeeper 中，从 0.9 版本开始，consumer 默认将 offset 保存在 Kafka 一个内置的 topic 中，该 topic 为\_\_consumer\_offsets。

1）修改配置文件 consumer.properties，在文件末尾加一行

exclude.internal.topics=false

bin/kafka-console-consumer.sh --topic __consumer_offsets --zookeeper localhost:2181 --formatter "kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter" --consumer.config config/consumer.properties --from-beginning

如果再次消费，需要更改 consumer.properties 文件中的 group.id，同一个 group.id 不能再次消费

### 3.3.4 消费者组案例 ###

1）需求：测试同一个消费者组中的消费者，同一时刻只能有一个消费者消费。

2）案例实操

1.  修改config/consumer.properties 配置文件中的 group.id 属性为任意组名。
2.  开启两个消费者 1，2 在同一个组内

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic first --consumer.config config/consumer.properties

1.  开启两个消费者 3 在采用随机组号

bin/kafka-console-producer.sh --broklist localhost:9092 --topic first

1.  开启生产者

bin/kafka-console-producer.sh --broklist localhost:9092 --topic first

查看消息接收情况  
![在这里插入图片描述][20210216220953948.gif]

**结论**：看到消费者1，2在同一组内，采用轮询的方式接受消息，同一时刻只有一个消费者接收到消息，消费者 3 单独在一个组中，可以接收所有消息

## 3.4 Kafka 高效读写 ##

1）顺序写磁盘

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

2）零复制技术，零拷贝  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 17]  
数据不会经过用户态

## 3.5 Zookeeper 在 Kafka 中的作用 ##

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

Controller 的管理工作都是依赖于 Zookeeper 的。

以下为 partition 的 leader 选举过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 18]

## 3.6 Kafka 事务 ##

### 3.6.1 Producer 事务 ###

幂等性可以在 Producer 进程不挂的情况下保证 Exactly Once，<PID, Partition, SeqNumber> 可以确定消息是否重复，但是当 Producer 进程重启，PID 发生改变，就不能保证 Exactly Once。

为了实现跨分区跨会话的事务，需要引入一个全局唯一的 Transaction ID，并将 Producer 获得的 PID 和 Transaction ID 绑定。这样当 Producer 重启后就可以通过正在进行的 Transaction ID 获得原来的 PID。

为了管理 Transaction，Kafka 引入了一个新的组件 Transaction oordinator。Producer 就是通过和 Transaction Coordinator 交互获得 Transaction ID 对应的任务状态。Transaction Coordinator 还负责将事务所有写入 Kafka 的一个内部 Topic，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以得到恢复，从而继续进行。

### 3.6.2 Consumer 事务 ###

上述事务机制主要是从 Producer 方面考虑，对于 Consumer 而言，事务的保证就会相对较弱，尤其时无法保证 Commit 的信息被精确消费。这是由于 Consumer 可以通过 offset 访问任意信息，而且不同的 Segment File 生命周期不同，同一事务的消息可能会出现重启后被删除的情况。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70]: /images/20221024/4c22ac7dfb82446ebc07baafdf26d7d1.png
[20210215181213554.png]: /images/20221024/988056beb74649a48a8eea19e0cc4a20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 1]: /images/20221024/9b4aa089b3714a6a88e25a20204d11c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 2]: /images/20221024/ad56fe2e7e4c48eba3f5fef63b245c4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 3]: /images/20221024/469a907e3e72470c8c38b5ee4d0ef893.png
[20210215211312534.png]: /images/20221024/993481c01b8441bd998c6a562e3bda05.png
[2021021521135657.png]: /images/20221024/1bf3ed6467e546f0b9b1d3d3e9035e24.png
[20210215211516450.png]: /images/20221024/ce5c9b9d977544a4bff9bb7b5a7c91c7.png
[20210215213033222.png]: /images/20221024/af9f10f841424551bd465dc395cf2215.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 4]: /images/20221024/44119ec91b8147d2a8cd0bf54481bbd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 5]: /images/20221024/edf29f7a6c3c430d9f43897d35ec0471.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 6]: /images/20221024/8369adfab336479780bd8b26c5afd688.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 7]: /images/20221024/914c3384a57f4970bd196b114ba6c989.png
[2021021522115650.png]: /images/20221024/c7b25eb049db493db696009012226ca7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 8]: /images/20221024/5c8004d957bf494e9d47c6ccb48c6683.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 9]: /images/20221024/af0cc35d2ef34758a09f0855d254c53b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 10]: /images/20221024/328dde7221e14a138efc4dc4acfaef37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 11]: /images/20221024/53709932c1434adb9aa2a4f694af5da8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 12]: /images/20221024/d6785df9867e47f1a472ed9607b29b98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 13]: /images/20221024/4b8c5f9d6cf24faf92a079ed8fd82a43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 14]: /images/20221024/b344623706a140e38c1bbcd34b9108e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 15]: /images/20221024/a33d36015b034cba9c1f7319cf8612cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 16]: /images/20221024/dc554eb4a54a4451b325bca7a4ad77c8.png
[20210216220953948.gif]: /images/20221024/e9254ee0cd2b4e298db13af69b1a1d6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 17]: /images/20221024/eabf4425c05640829faa9f0b4efa4a11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcHB5amFjb2I_size_16_color_FFFFFF_t_70 18]: /images/20221024/d99ffaa94a974c7ab33d0ca84109c40c.png