栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

第二章 Kafka架构原理

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

第二章 Kafka架构原理

2.1 Kafka工作流程

Kafka 存储的消息是以 topic 进行分类的,生产者生产消息,消费者消费消息,都是面向 topic的。

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

2.2 Kafka 保存消息机制 2.2.1 存储方式

kafka日志文件的存储目录可以通过配置文件config/server.properties中的配置项log.dirs确定。

生产者生产的消息会不断追加到 log 文件末尾,为防止 log 文件过大导致数据定位效率低下,Kafka 采取了分片和索引机制,一个片段的默认大小为1GB,可以在config/server.properties配置文件中修改segment大小。Kafka将每个 partition 分为多个 segment。

物理上把topic分成一个或多个patition,每个patition物理上对应一个文件夹,该文件夹的命名规则为:topic 名称+分区序号。分区内(文件夹)内的日志文件分为多个Segment,且每个Log Segment包含三个主要文件

00000000000000000000.index
00000000000000000000.log
00000000000000000000.timeindex

00000000000000000128.index
00000000000000000128.log
00000000000000000128.timeindex

xxx.log:消息内容主文件,记录消息内容信息
xxx.index:偏移量索引文件,记录偏移量到消息位置的映射
xxx.timeindex:时间戳索引文件,记录时间戳到偏移量的映射
注意:分区目录下还包含两类文件,xxx.snapshot对幂等型或者事务型producer所生成的快照文件;xxx.leader-epoch-checkpoint保存了每一任leader开始写入消息时的offset,该文件会定时更新。
物理上把topic分成一个或多个patition,每个patition物理上对应一个文件夹,该文件夹的命名规则为:topic 名称+分区序号。例如,first topic 有三个分区,则其对应的文件夹为 first-0,first-1,first-2,文件夹内容如下所示

每个Log Segment都有一个基准偏移量baseOffset, 用来表示当前Log Segment中第一条消息的偏移量,日志文件和两个索引文件都是根据baseOffset命名的,文件名称固定20位整数,不够用0填充。如下所示以第二个分段00000000000000000128.log为例,00000000000000000128.log表示当前Log Segment中第一条消息偏移量为128,同时可以推断出第一个分段中的偏移量为0 - 127

2.2.2 日志格式 2.2.2.1.日志索引

日志索引有两个:偏移量索引和时间戳索引。索引文件建立偏移量(offset)/时间戳(timestamp)到物理地址之间的映射关系,方便快速定位消息所在的物理文件的位置;

kafka中使用稀疏索引的方式构造消息索引,所以索引中不保证每个消息在索引中都有对应物理地址的映射;索引记录的方式由配置参数log.index.interval.bytes指定,默认4KB。当kafka写入消息大小大于4KB时,偏移量索引文件和时间戳索引文件分别增加一个索引项,记录此刻偏移量/时间戳与消息物理地址的映射,修改此配置,可以改变索引文件中索引项的密度

2.2.2.2.日志分段的条件
  1. 当前日志分段文件的大小超过broker端参数log.segment.bytes配置值,默认1G
  2. 当前日志分段文件中消息的最大时间戳和当前系统的时间戳差值大于log.roll.ms或log.roll.hours参数配置(ms优先级更高,同时出现以ms配置值为准),默认配置后者为168,即7天
  3. 索引文件大小超过broker端参数log.index.size.max.bytes,默认10M
  4. 追加消息的偏移量与当前日志分段的BaseOffset之间差值大于Integer.MAX_VALUE
2.2.2.3.偏移量索引(.index文件)

偏移量索引即记录偏移量(offset)到消息物理位置的映射。每个索引项大小为8个字节,分为两部分:

  • relative offset:相对偏移量,即消息的绝对偏移量和基础偏移量BaseOffset的差值,占4个字节,offset本身为8个字节,这里保存相对位移可以降低索引文件的大小,上述日志分段条件4是受相对偏移量影响,最多只能保存4B差值的偏移量
  • position:物理地址,即消息在日志分段文件中对应的物理地址,占4个字节

以00000000000000000536.index为例,使用kafka自带命令kafka-dump-log可以解析日志文件

Dumping 00000000000000000536.index
offset: 588 position: 4160
offset: 640 position: 8320
offset: 692 position: 12480
offset: 744 position: 16640
offset: 796 position: 20800
offset: 848 position: 24960
offset: 900 position: 29120
offset: 952 position: 33280
offset: 1004 position: 37440
offset: 1056 position: 41600

索引查找方式
kafka在查找某偏移量时使用偏移量索引,假设现在需要查找partition = 0, offset = 745的消息,其过程如下

  1. 第一步,确定日志分段,先从跳表中确定offset = 745在00000000000000000536分段中,kafka使用跳跃表缓存每个日志分段的BaseOffset,确定分段会先经过跳表查询
  2. 第二步,确定偏移量索引项,通过二分查找,确认offset = 745在744 - 796之间,kafka根据offset = 744对应的物理位置再去日志文件中查找,kafka会在索引文件中找到不大于指定偏移量的最大偏移量对应的物理位置,去日志文件中顺序查找
  3. 第三步,确定消息位置:到日志文件中后,从offset:744 position: 16640开始顺序查找,知道找到offset = 745的消息
2.2.2.4.时间戳索引(.timeindex)

时间戳索引记录时间戳(timestamp)到相对偏移量(relativeOffset)之间的映射。每个索引项大小为12个字节,包含两个部分:

  • 时间戳timestamp:当前日志分段最大的时间戳(新增时间戳索引项的那个时刻),日志分段中最大的时间戳(相当于那个时刻的快照数据),大小为8个字节
  • 相对偏移量relativeOffset: 该时间戳对应的相对偏移量
    即时间戳索引是以偏移量索引为前提的,在时间戳中确定偏移量后,必须再从偏移量索引中才能知道消息的具体位置。
2.2.3 Log Segement文件

查看segement文件00000000000000000000.log

1.0.1版本命令

bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files 00000000000000000000.log --deep-iteration --print-data-log

–deep-iteration查看日志文件中每一条信息,不加此选项为查看批消息(不显示具体每条日志内容)。

文件内容如下

  • offset:相对于该分区的记录偏移量,指的是第几条记录,比如0代表第一条记录。
  • position:表示该记录相对于当前片段文件的偏移量。
  • CreateTime:记录创建的时间。
  • isvalid:记录是否有效。
  • keysize:表示key的长度。
  • valuesize:表示value的长度
  • magic:表示本次发布kafka服务程序协议版本号。
  • compresscodec:压缩工具。
  • producerId:生产者ID(用于幂等机制)。
  • sequence:消息的序列号(用于幂等机制)。
  • payload:表示具体的消息

2.7.1版本

bin/kafka-run-class.sh kafka.tools.DumpLogSegments --files logs/test3-2/00000000000000000000.log --print-data-log

选项--print-data-log查看具体消息内容,不加此选项,为查看批消息。

批消息如下所示

baseOffset: 0 lastOffset: 1 count: 2 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 0 CreateTime: 1653893608415 size: 90 magic: 2 compresscodec: NONE crc: 789477047 isvalid: true

一条批消息(Record Batch)日志记录,包含多条的实际数据
具体消息如下所示

baseOffset: 0 lastOffset: 1 count: 2 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 0 CreateTime: 1653893608415 size: 90 magic: 2 compresscodec: NONE crc: 789477047 isvalid: true
| offset: 0 CreateTime: 1653893607501 keysize: -1 valuesize: 7 sequence: -1 headerKeys: [] payload: fdsfsdf
| offset: 1 CreateTime: 1653893608415 keysize: -1 valuesize: 7 sequence: -1 headerKeys: [] payload: sdfasdf

注意:kafka2.x版本新增了kafka-dump-log.sh脚本,该脚本实质也是调用kafka-run-class.sh脚本。

2.2.4 Kafka高效存储原因

kafka使用磁盘存储消息数据,一般情况下认为磁盘的读写速率较低。kafka在磁盘存储的前提下,可以保持高吞吐,主要原因在以下三个方面

2.2.4.1.顺序写

日志存储是基于日志文件的追加,所以在单个日志分段上日志文件的写入是顺序写入;而磁盘顺序写入的效率比内存随机写入效率更高,所以在写入效率上kafka依然可以保持高效

2.2.4.2.页缓存

页缓存是操作系统实现的磁盘缓存,使用页缓存可以减少对磁盘的I/O操作。当一个进程准备去读磁盘文件时,会首先查看页缓存是否存在,如果存在则直接读取数据并返回,否则再从磁盘获取数据,并更新到页缓存中;同样在数据写入磁盘时,也会查看对应的数据页是否在页缓存中,如果有则直接更新页缓存,没有则从磁盘中读取该页,然后写入页缓存;被写入的数据页就变成了脏页,操作系统会定时将脏页同步到磁盘中

kafka没有在进程中管理缓存,而是将缓存行为完全交给操作系统,一方面可以简化进程的处理逻辑,提高处理效率,同时可以不用考虑进程重启后的缓存丢失;另一方面,可以利用操作系统页缓存的特性,提高磁盘读写效率。

  1. 生产者通过pwrite()方法,把消息写入page_cache
  2. 消费者通过sendfile()方法,通过零拷贝的方式把消息从page cache传输到broker的Socker buffer
    所以,如果生产者和消费者的速率相差不多,那么写入和读取几乎可以通过页缓存完成,进行极少的磁盘操作,可以达到很高的吞吐量;
2.2.5 零拷贝

零拷贝是指将数据从磁盘文件中直接复制到网卡设备中,而无需经过应用程序。零拷贝技术可以减少文件被拷贝的次数,同时不用在用户态和内核态之间转换,提高文件传输效率。

假设将磁盘文件A通过网络传输给用户,在使用零拷贝前其过程如下:

  1. 用户发起read()系统调用,将磁盘文件A复制到内核空间的Read Buffer中
  2. 同时CPU控制将Read Buffer数据从内核态复制到用户态的进程内存中
  3. 进程发起write()系统调用,将用户态进程内存数据复制到内核态socket buffer中
  4. 内核态数据从Socket Buffer中复制到网卡设备,准备发送

可以看到,在使用零拷贝之前,文件经过四次复制,并两次经过用户态和内核态的切换;而文件进入用户态后基本上没有任何处理,就被直接复制到内核buffer中,可见经过用户空间的这两次复制是多余的,因此,在使用零拷贝后:

零拷贝通过DMA(Direct Memory Access)将文件复制到内核空间的Read Buffer中,随后不经过用户空间,直接复制到网卡待发送。经过零拷贝后,文件的准备过程减少了两次文件复制,并不经过用户态和内核态的转换,提高了文件发送效率。

2.2.6 日志清理

kafka日志存储在磁盘中,随着时间推移日志文件必然越来越大,kafka提供两种方式清理日志文件:

  • 日志删除:按照某种策略,删除不符合条件的日志分段
  • 日志压缩/瘦身:针对key对日志重新梳理,相同key的消息只保留最后一条,这里不是对日志文件直接进行压缩保存,而是从逻辑上删除日志文件的内容

broker参数log.cleanup.policy可设置日志清理策略,delete表示日志删除,compact为日志压缩,默认前者

2.2.6.1.日志删除

基于时间:如果日志分段中最大时间戳和当前时间的差值大于设定的保留时间,则分段需要清除。保留时间可以通过配置确定:

  • log.retention.ms/minutes/hours三个参数可指定保留时间,ms优先级最高,默认hours = 168,即保留7天
  • 基于日志大小:如果分区内日志文件总大小(非单个日志分段文件大小)超过阈值,则清理最老的日志分段,log.retention.bytes设置总大小阈值,默认为-1,表示可以无穷大
  • 基于日志起始偏移量:当日志分段的偏移量小于日志起始偏移量logStartOffset时,日志分段被删除,logStartOffset可以被管理员修改,从而指定删除某些分段

注意:因为Kafka读取特定消息的时间复杂度与Log Segment文件大小无关,所以这里删除过期文件与提高 Kafka 性能无关。

2.2.6.2.日志压缩/瘦身

日志压缩针对所有的历史消息,根据key对消息进行合并,保留相同key的最后一条消息

日志压缩适用于某些场景,必须适用kafka记录某些状态,这种情况不用记录过程,保留最终状态是可行的;但不是所有场景都适用,比如相同key的消息通过不同的字段划分不同的行为,这时合并消息就不是理想的方案了

2.2.7 offset维护

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

注意: producer不在zk中注册,消费者在zk中注册。

Kafka 0.9 版本之前,consumer 默认将 offset 保存在 Zookeeper 中,从 0.9 版本开始,consumer 默认将 offset 保存在 Kafka 内置的 topic 中,该 topic 为__consumer_offsets。

查看offset

  1. 修改配置文件 consumer.properties
exclude.internal.topics=false
  1. 读取 offset

0.11.0.0 之前版本

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

0.11.0.0 之后版本(含)

bin/kafka-console-consumer.sh --topic __consumer_offsets --
zookeeper hadoop102:2181 --formatter 
"kafka.coordinator.group.GroupMetadataManager$OffsetsMessageForm
atter" --consumer.config config/consumer.properties --from-beginning
2.3 Kafka 生产者 2.3.1 写入数据方式

Kafka Producer负责向Kafka写入数据。采用推(push)模式将消息发布到broker,每条消息都被追加(append)到分区(patition)中,属于顺序写磁盘(顺序写磁盘效率比随机写内存要高,保障kafka吞吐率)。

2.3.2 分区(Partition)策略

消息发送时都被发送到一个topic,其本质就是一个目录,而topic是由一些Partition Log(分区日志)组成,其组织结构如下图所示

每个Partition中的消息都是有序的,生产的消息被不断追加到Partition log,其中的每一个消息都被赋予了一个唯一的offset值。

分区原因

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

分区原则

  1. 指定了patition,则直接使用;
  2. 未指定patition,但指定key,将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值;
  3. patition和key都未指定,第一次调用时随机生成一个整数(后面每次调用在这个整数上自增),将这个值与 topic 可用的 partition 总数取余得到 partition 值,也就是常说的 round-robin 算法。

DefaultPartitioner类

public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
    List partitions = cluster.partitionsForTopic(topic);
    int numPartitions = partitions.size();
    if (keyBytes == null) {
        int nextValue = nextValue(topic);
        List availablePartitions = cluster.availablePartitionsForTopic(topic);
        if (availablePartitions.size() > 0) {
            int part = Utils.toPositive(nextValue) % availablePartitions.size();
            return availablePartitions.get(part).partition();
        } else {
            // no partitions are available, give a non-available partition
            return Utils.toPositive(nextValue) % numPartitions;
        }
    } else {
        // hash the keyBytes to choose a partition
        return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
    }
}
2.3.3 副本(Replication)

同一个partition可能会有多个replication。没有replication的情况下,一旦broker 宕机,其上所有 partition 的数据都不可被消费,同时producer也不能再将数据存于其上的partition。引入replication之后,同一个partition可能会有多个replication,而这时需要在这些replication之间选出一个leader,producer和consumer只与这个leader交互,其它replication作为follower从leader 中复制数据。

Replica的个数小于等于Broker的个数,也就是说,对于每个Partition而言,每个Broker上最多只会有一个Replica,因此可以使用Broker id 指定Partition的Replica

2.3.4 数据可靠性保证 2.3.4.1.副本同步策略

为保证 producer 发送的数据,能可靠的发送到指定的 topic,topic 的每个 partition 收到producer 发送的数据后,都需要向 producer 发送 ack(acknowledgement 确认收到),如果producer 收到 ack,就会进行下一轮的发送,否则重新发送数据。

副本同步策略

方案优点缺点
半数以上完成同步发送ack延迟低选举新的leader时,容忍n台节点故障,需要2n+1个副本
全部完成同步发送ack选举新的leader时,容忍n台节点故障,需要n+1个副本延迟高

Kafka 选择了第二种方案,原因如下:

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

假设有5台机器,现存在一个topic为A,它有一个分区。
全同步策略: 5台机器最多容忍4台机器故障,如果全故障那你的Kafka Cluster不就凉了? 当4台机器故障时,由于你选择的是全同步策略,所以topic A 分区下的5个副本(leader + follower)分别位于这5台机器上,那么那台没有故障的机器(也就是broker)的副本(follower,假设此时leader故障)就会成为leader继续工作。也即是全同步策略下,容忍n台节点故障,需要n+1个副本。

半数同步策略: 假设4(n)台机器发生了故障,副本数为5,由于是半数机制,所以topic A 分区下的副本数只要存在3个(leader + follower)broker就会发送ack。可是此时四台节点故障,Kafka集群里面只有三个副本,这就不能保证没故障的节点存在topic A 分区下的副本。那么副本数至少需要设置为多少?副本数应设置为9个。如果副本数为9,topic A分区下副本数量为5时broker才会发送ack,此时如果4台节点故障(假设leader故障),那台没故障的机器就会成为leader继续工作。也即是半同步策略下,容忍n台节点故障,需要2n+1个副本。

2.3.4.2.ISR

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

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

2.3.4.3.ack 应答机制

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

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

ack参数配置

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

acks=all 就可以代表数据一定不会丢失了吗?
如果Partition只有一个副本,也就是一个Leader,任何Follower都没有,也会导致数据丢失,因为ISR里就一个Leader,他接收完消息后宕机,也会导致数据丢失。所以说,这个acks=all,必须跟ISR列表里至少有2个以上的副本配合使用,起码是有一个Leader和一个Follower才可以。这样才能保证说写一条数据过去,一定是2个以上的副本都收到了才算是成功,此时任何一个副本宕机,不会导致数据丢失。

2.3.4.4.故障处理细节

LEO:指的是每个副本最大的 offset;其实就是最新的offset+1
HW:指的是消费者能见到的最大的 offset,ISR 队列中最小的 LEO。

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

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

2.3.5 Exactly Once 语义(生产者)

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

At Least Once 可以保证数据不丢失,但是不能保证数据不重复;相对的,At Most 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 端会对做缓存,当具有相同主键的消息提交时,Broker 只会持久化一条。

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

2.3.6 写入数据流程

写入步骤(宏观)

  1. producer先从zookeeper的 /brokers/topics/[topic]/partitions/[partitionId]/state节点找到该partition的leader
  2. producer将消息发送给该leader
  3. leader将消息写入本地log
  4. followers从leader pull消息,写入本地log后向leader发送ACK
  5. leader收到所有ISR中的replication的ACK后,增加HW(high watermark,最后commit 的offset)并向producer发送ACK

写入步骤(微观)

  1. 构造发送消息ProducerRecord,包含topic、key、value等信息,调用Producer API发送消息。
  2. 消息经过interceptor拦截器、serializer序列化器后,进入到partitioner进行分区,Kafka Producer提供默认的分区器,当消息存在key时,根据key的hash值选择分区,如果没有指定key,会使用轮询的方法选择分区。
  3. 确认分区后寻找分区对应的Leader副本所在的Broker。
  4. 确定好发送位置的消息进入到消息缓冲池,等待触发batch大小或者时间间隔,发送到对应的Broker,如果设置了压缩,会使用相应的压缩方法对batch进行压缩。
  5. 发送到Leader副本所在的Broker的消息,根据设置的acks值,判断成功标准,是写入Leader副本就成功还是写入Follower副本才成功。
  6. 发送到Broker的消息失败,如果设置了重试次数,对应次数进行重新发送。如果重试后还是失败,返回失败信息;发送到Broker的消息成功,返回RecoredMetadata。

消息主要有同步发送还是异步发送两种方式,异步发送不需要等待发送结果返回,同步发送使用Java的Future.get()等待返回结果。还有一种是fire and forget方式发送,发送后不再关注发送结果,不推荐使用该方式。

2.4 Kafka 消费者 2.4.1 消费方式

Kafka Consumer负责从Kafka中读取数据。Consumer通过订阅Kafka中的topic,接收topic里面的消息,并进行相关的逻辑处理。

consumer 采用 pull(拉)模式从 broker 中读取数据。

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

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

kafka提供了两套consumer API:高级Consumer API和低级Consumer API。

2.4.2 分区分配策略

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

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

2.4.3 工作流程
  1. Consumer订阅Kafka集群某个或者一组topic,更改订阅状态Subscription State,并将订阅信息保存到Metadata元数据中。
  2. poll轮询消息。
  3. 根据poll设置条数,不断fetch消息,返回到Consumer。
  4. Consumer自动或者手动commitSync。
2.4.4 消费者组

消费者是以consumer group方式工作,由一个或者多个消费者组成一个组,共同消费一个topic。每个分区在同一时间只能由group中的一个消费者读取,但是多个group可以同时消费这个partition。在图中,有一个由三个消费者组成的group,有一个消费者读取主题中的两个分区,另外两个分别读取一个分区。某个消费者读取某个分区,也可以叫做某个消费者是某个分区的拥有者。

在这种情况下,消费者可以通过水平扩展的方式同时读取大量的消息。另外,如果一个消费者失败了,那么其他的group成员会自动负载均衡读取之前失败的消费者读取的分区。

2.4.5 auto.offset.reset值含义
  • earliest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,从头开始消费
  • latest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,消费新产生的该分区下的数据
  • none:当各分区下都有已提交的offset时,从提交的offset开始消费;只要有一个分区不存在已提交的offset,则抛出异常

该参数在消费者代码中进行设置,总之,只要kafka中相同group、partition中已经有提交的offset,则都是从offset开始消费。

  1. 测试一:Topic为lsztopic7,并生产30条信息。

    创建组为“testtopi7”的consumer,将enable.auto.commit设置为false,不提交offset。依次更改auto.offset.reset的值。此时查看offset情况

    测试结果
    earliest,客户端读取30条信息,且各分区的offset从0开始消费。
    latest,客户端读取0条信息。
    none,抛出NoOffsetForPartitionException异常。

    测试结论
    新创建一个同组名的消费者时,auto.offset.reset值含义:
    earliest 没有为消费者组找到先前的offset值时,每个分区是从头开始消费的。
    none 没有为消费者组找到先前的offset值时,抛出异常

  2. 测试二:设置latest时未接收到数据,保证该消费者在启动状态,使用生产者继续生产10条数据,总数据为40条。

    测试结果
    latest 客户端取到了后生产的10条数据
    测试结论
    当创建一个新分组的消费者时,auto.offset.reset值为latest时,表示消费新的数据(从consumer创建开始,后生产的数据),之前产生的数据不消费。

  3. 测试三:在测试环境二,topic总数为40条,运行消费者程序后,消费了5条数据。即总数为40条,已消费5条,剩余35条,继续设置不同的auto.offset.reset值进行测试。

    上述图中CURRENT-OFFSET值为unknown时,表示该分区不存在已提交的offset,CURRENT-OFFSET小于LOG-END-OFFSET时,表示消费者分配到该分区后有新提交的数据,CURRENT-OFFSET等于LOG-END-OFFSET时,表示该分区数据已消费完毕。
    测试结果
    earliest 消费35条数据,即将剩余的全部数据消费完。
    none 抛出NoOffsetForPartitionException异常。

    latest 消费9条数据,都是分区3的值。
    offset:0 partition:3
    offset:1 partition:3
    offset:2 partition:3
    offset:3 partition:3
    offset:4 partition:3
    offset:5 partition:3
    offset:6 partition:3
    offset:7 partition:3
    offset:8 partition:3
    测试结论
    earliest 当分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,从头开始消费。
    latest 当分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,消费新产生的该分区下的数据。
    none 当该topic下所有分区中存在未提交的offset时,抛出异常。

  4. 测试四:在测试三的基础上,将数据消费完,再生产10条数据,确保每个分区上都有已提交的offset。此时,总数为50,已消费40,剩余10条

    测试结果
    none 消费10条信息,且各分区都是从offset开始消费
    offset:9 partition:3
    offset:10 partition:3
    offset:11 partition:3
    offset:15 partition:0
    offset:16 partition:0
    offset:17 partition:0
    offset:18 partition:0
    offset:19 partition:0
    offset:20 partition:0
    offset:5 partition:2
    测试结论
    值为none时,topic各分区都存在已提交的offset时,从offset后开始消费;只要有一个分区不存在已提交的offset,则抛出异常。

  5. 测试五:在测试四环境的基础上:总数为50,已消费40,剩余10条,创建不同组的消费者,组名为testother7

    测试结果
    earliest 消费50条数据,即将全部数据消费完。
    latest 消费0条数据。
    none 抛出异常

    测试结论
    组与组间的消费者是没有关系的。
    topic中已有分组消费数据,新建其他分组的消费者时,之前分组提交的offset对新建的分组消费不起作用。

2.5 Zookeeper在kafka中的作用

新版本越来越弱化kafka对zookeeper的依赖。

2.5.1 Broker注册

Broker在ZooKeeper中保存为一个临时节点,节点的路径是/brokers/ids/[brokerid],每个节点会保存相应broker的IP以及端口等信息。

2.5.2 Topic注册

在Kafka中,一个topic会被分成多个区并被分配到多个broker上,分区的信息以及在broker的分布情况都保存在ZooKeeper中,根节点路径为/brokers/topics,每个topic都会在topics下建立独立的子节点,每个topic节点下都会包含分区以及与broker的对应关系。

Kafka中每个Topic都会以/brokers/topics/[topic]的形式被记录,如主题login、search对应的zookeeper上的路径/brokers/topics/login和/brokers/topics/search。Broker服务器启动后,会到对应Topic节点(/brokers/topics)上注册自己记录的该Topic分区信息,同样,这个分区节点也是临时节点。

2.5.3 生产者负载均衡

由于同一个Topic消息会被分区并将其分布在多个Broker上,因此,生产者需要将消息合理地发送到这些Broker上,那么如何实现生产者的负载均衡,Kafka支持传统的四层负载均衡,也支持Zookeeper方式实现负载均衡。

  1. 四层负载均衡
    根据生产者的IP地址和端口来为其确定一个相关联的Broker。通常,一个生产者只会对应单个Broker,然后该生产者产生的消息都发往该Broker。这种方式逻辑简单,每个生产者不需要同其他broker建立额外的TCP连接,只需要和Broker维护单个TCP连接即可。但是,其无法做到真正的负载均衡,因为实际系统中的每个生产者产生的消息量及每个Broker的消息存储量都是不一样的,如果有些生产者产生的消息远多于其他生产者的话,那么会导致不同的Broker接收到的消息总数差异巨大,同时,生产者也无法实时感知到Broker的新增和删除。

  2. 使用Zookeeper进行负载均衡
    由于每个Broker启动时,都会完成Broker注册过程,生产者会通过该节点的变化来动态地感知到Broker服务器列表的变更,这样就可以实现动态的负载均衡机制

2.5.4 消费者负载均衡

消费者服务启动时,会创建一个属于消费者节点的临时节点,节点的路径为/consumers/[group_id]/ids/[consumer_id],该节点的内容是该消费者订阅的Topic信息。每个消费者会对/consumers/[group_id]/ids节点注册Watcher监听器,一旦消费者的数量增加或减少就会触发消费者的负载均衡。消费者还会对/brokers/ids节点进行监听,如果发现服务器的Broker服务器列表发生变化,也会进行消费者的负载均衡。

2.5.5 记录消费者与分区对应关系

consumer group 下有多个 Consumer(消费者)。对于每个消费者组 (Consumer Group),Kafka都会为其分配一个全局唯一的Group ID,Group 内部的所有消费者共享该 ID。订阅的topic下的每个分区只能分配给某个 group 下的一个consumer(当然该分区还可以被分配给其他group)。

同时,Kafka为每个消费者分配一个Consumer ID,通常采用"Hostname:UUID"形式表示。

在Kafka中,规定了每个消息分区只能被同组的一个消费者进行消费,因此,需要在 Zookeeper 上记录消息分区与 Consumer 之间的关系,每个消费者一旦确定了对一个消息分区的消费权力,需要将其Consumer ID 写入到 Zookeeper 对应消息分区的临时节点上,例如:
/consumers/[group_id]/owners/[topic]/[broker_id-partition_id]
其中,[broker_id-partition_id]就是一个消息分区的标识,节点内容就是该消息分区上消费者的Consumer ID。

2.5.6 消费进度Offset 记录(0.9.0.0之前)

在消费者对指定消息分区进行消费的过程中,需要定时地将分区的消费进度Offset记录到Zookeeper上,以便在该消费者进行重启或者其他消费者重新接管该消息分区后,能够从之前的进度开始继续进行消息消费。Offset在Zookeeper中由一个专门节点进行记录,其节点路径为:
/consumers/[group_id]/offsets/[topic]/[broker_id-partition_id]
节点内容就是Offset的值。

2.5.7 消费者注册

消费者在初始化启动时加入消费者分组的步骤如下

  1. 注册到消费者分组。每个消费者启动时,都会到Zookeeper的指定节点下创建一个属于自己的消费者节点,例如/consumers/[group_id]/ids/[consumer_id],完成节点创建后,消费者就会将自己订阅的Topic信息写入该临时节点。

  2. 对消费者组中的消费者的变化注册监听。每个消费者都需要关注所属消费者分组中其他消费者的变化情况,即对/consumers/[group_id]/ids节点注册子节点变化的Watcher监听,一旦发现消费者新增或减少,就触发消费者的负载均衡。

  3. 对Broker服务器变化注册监听。消费者需要对/broker/ids/[0-N]中的节点进行监听,如果发现Broker服务器列表发生变化,那么就根据具体情况来决定是否需要进行消费者负载均衡。

  4. 进行消费者负载均衡。为了让同一个Topic下不同分区的消息尽量均衡地被多个消费者消费而进行消费者与消息分区分配的过程,通常,对于一个消费者分组,如果组内的消费者发生变更或Broker服务器发生变更,会发出消费者负载均衡。

2.6 Kafka在zookeeper中的存储

在版本迭代过程中,会有一些变化。

Zookeeper在kafka中扮演了举足轻重的作用(0.9版本后offest不放在zk上,由kafka内部topic保存),kakfa的 broker、topic等相关的信息都存储在zookeeper的节点上。

2.6.1 Topic注册信息

/brokers/topics/[topic]存储topic的partitions全部信息

{
    "version": "版本编号",
    "partitions": {
        "partitionId编号": [
            同步副本组brokerId列表
        ],
        "partitionId编号": [
            同步副本组brokerId列表
        ],
        .......
    }
}

案例

{
  "version": 2,
  "partitions": {
    "1": [1,2,3],
    "0": [3,1,2]
  },
  "adding_replicas": {
  },
  "removing_replicas": {
  }
}
2.6.2 Partition状态信息

/brokers/topics/[topic]/partitions/[0...N] 其中[0…N]表示partition索引号
/brokers/topics/[topic]/partitions/[partitionId]/state存储partition状态信息

{
    "controller_epoch": 表示kafka集群中的中央控制器选举次数,
    "leader": 表示该partition选举leader的brokerId,
    "version": 版本编号默认为1,
    "leader_epoch": 该partition leader选举次数,
    "isr": [同步副本组brokerId列表]
}

示例

{
    "controller_epoch":20,
    "leader":0,
    "version":1,
    "leader_epoch":0,
    "isr":[0,1,2]
}
2.6.3 /brokers/topics/__consumer_offsets

新版kafka将消费者的消费位移信息(offset)保存在kafka内部的topic中,即__consumer_offsets 主题,并且提供了kafka-consumer-groups.sh脚本供用户查看消费者信息。

2.6.4 Broker注册信息

broker在zookeeper中注册的路径为/brokers/ids/[0...N]
每一个broker的配置文件中都须要指定一个数字类型的id(全局不可重复),此节点为临时znode(EPHEMERAL)

{
    "jmx_port": jmx端口号,
    "timestamp": kafka broker初始启动时的时间戳,
    "host": 主机名或ip地址,
    "version": 版本编号默认为1,
    "port": kafka broker的服务端端口号,由server.properties中参数port肯定
}

示例

{
    "jmx_port":1,
    "timestamp":"1452068227537",
    "host":"h1",
    "version":1,
    "port":9092
}
2.6.5 controller_epoch

该节点是持久(PERSISTENT)节点,节点中存放的是一个整型的controller_epoch值。controller_epoch用于记录控制器发生变更的次数,即记录当前的控制器是第几代控制器也称之为“控制器的纪元”。

controller_epoch的初始值为1,即集群中第一个控制器的纪元为1,当控制器发生变更时,每选出一个新的控制器就将该字段值加1。每个和控制器交互的请求都会携带上controller_epoch这个字段,如果请求的controller_epoch值小于内存中的controller_epoch值,则认为这个请求是向已经过期的控制器所发送的请求,那么这个请求会被认定为无效的请求。如果请求的controller_epoch值大于内存中的controller_epoch值,那么则说明已经有新的控制器当选了。由此可见,Kafka通过controller_epoch来保证控制器的唯一性,进而保证相关操作的一致性。

[zk: localhost:2181(CONNECTED) 24] get /controller_epoch
8
cZxid = 0x100000019
ctime = Mon Oct 11 15:32:56 CST 2021
mZxid = 0x2000001ad
mtime = Tue Oct 12 15:39:57 CST 2021
pZxid = 0x100000019
cversion = 0
dataVersion = 8
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 1
numChildren = 0
2.6.6 controller注册信息

在Kafka集群中会有一个或者多个broker,其中有一个broker会被选举为控制器(Kafka Controller),它负责管理整个集群中所有分区和副本的状态。当某个分区的leader副本出现故障时,由控制器负责为该分区选举新的leader副本。当检测到某个分区的ISR集合发生变化时,由控制器负责通知所有broker更新其元数据信息。当使用kafka-topics.sh脚本为某个topic增加分区数量时,同样还是由控制器负责分区的重新分配。

Kafka中的控制器选举的工作依赖于Zookeeper工具,成功竞选为控制器的broker会在Zookeeper中创建/controller这个临时(EPHEMERAL)节点。

存储中央控制器所在kafka broker的信息

[zk: localhost:2181(CONNECTED) 25] get /controller      
{"version":1,"brokerid":1,"timestamp":"1634024397002"}
cZxid = 0x2000001ad
ctime = Tue Oct 12 15:39:57 CST 2021
mZxid = 0x2000001ad
mtime = Tue Oct 12 15:39:57 CST 2021
pZxid = 0x2000001ad
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x1000f7ddeb1002d
dataLength = 54
numChildren = 0
2.6.7 consumer注册信息

每一个consumer都有一个惟一的ID(consumerId能够经过配置文件指定,也能够由系统生成),此id用来标记消费者信息。

/consumers/[groupId]/ids/[consumerIdString]是一个临时的znode,此节点的值请看consumerIdString产生规则

consumerId产生规则

    StringconsumerUuid = null; 
    if(config.consumerId!=null && config.consumerId){ 
        consumerUuid = consumerId; 
    }else { 
        String uuid = UUID.randomUUID() 
        consumerUuid = "%s-%d-%s".format( 
            InetAddress.getLocalHost.getHostName, System.currentTimeMillis, uuid.getMostSignificantBits().toHexString.substring(0,8)); 

       } 
    String consumerIdString = config.groupId + "_" + consumerUuid;  
{
    "version": 版本编号默认为1,
    "subscription": { //订阅topic列表
        "topic名称": consumer中topic消费者线程数
    },
    "pattern": "static",
    "timestamp": "consumer启动时的时间戳"
}

示例

{
    "version":1,
    "subscription":{
        "replicatedtopic":1
    },
    "pattern":"white_list",
    "timestamp":"1452134230082"
}
2.6.8 Consumer owner信息

/consumers/[groupId]/owners/[topic]/[partitionId] -> consumerIdString + threadId索引编号

  1. 首先进行"Consumer注册";
  2. 然后注册一个watch用来监听当前group中其他consumer的"退出"和"加入";只要此znode path下节点列表变更,都会触发此group下consumer的负载均衡。(比如一个consumer失效,那么其他consumer接管partitions)。
  3. 在"Broker 注册"节点下,注册一个watch用来监听broker的存活情况;如果broker列表变更,将会触发所有的groups下的consumer重新balance。
2.6.9 Consumer offset(0.9.0.0之前)

/consumers/[groupId]/offsets/[topic]/[partitionId] -> long (offset)

用来跟踪每个consumer目前所消费的partition中最大的offset

此znode为持久节点,可以看出offset跟group_id有关,以表明当消费者组(consumer group)中一个消费者失效,重新触发balance,其他consumer可以继续消费。

2.6.10 /cluster

/cluster/id记录着集群ID,该节点为持久数据节点

当第一台Broker启动的时候,发现/cluster/id不存在,那么它就会把自己的cluster.id配置写入zk;标记当前zk是属于哪个集群;后面其他的Broker启动的时候会去获取该数据,如果发现数据跟自己的配置不一致,则抛出异常,加入的不是同一个集群;

示例

{"version":"1","id":"bkbRDTLMQdmy7p3s8h3SnQ"}
2.6.11 /log_dir_event_notification

zk的数据中有一个节点/log_dir_event_notification/,这是一个序列号持久节点,这个节点在kafka中承担的作用是:当某个Broker上的LogDir出现异常时(比如磁盘损坏、文件读写失败、等等异常):向zk中新增一个子节点/log_dir_event_notification/log_dir_event_序列号,Controller监听到这个节点的变更之后,会向Brokers们发送LeaderAndIsrRequest请求;然后做一些副本脱机的善后操作。

2.6.12 /isr_change_notification/log_dir_event_{序列号}

当ISR列表有变更的时候,会写入这个节点Controller监听变更

2.6.13 /admin

/admin/delete_topics/[topicName]持久节点,待删除Topic
存在此节点表示当前Topic需要被删除

2.6.14 /admin/reassign_partitions 持久数据节点

如果有此节点,表示当前正在进行数据迁移,里面的数据就是正在迁移的配置

2.6.15 /brokers/seqid

/brokers/seqid全局序列号里面没有数据,主要是用了节点的dataVersion信息来当全局序列号

在kafka中的作用:自动生成BrokerId;一个集群如果特别大,配置brokerId的时候不能重复,一个个设置比较累,可以让Broker自动生成BrokerId

server.properties 配置

设置Brokerid能够自动生成 
broker.id.generation.enable=true 
设置BrokerId<0 (如果>=0则以此配置为准) 
broker.id=-1 
自动生成配置的起始值 
reserved.broker.max.id=20000 

BrokerId计算方法

brokerId = {reserved.broker.max.id} +/brokers/seqid.dataVersion

每次想要获取/brokers/seqid的dataVersion值的时候都是用 set方法,set的时候会返回version数据,并不是get;每次set这个节点数据,版本信息就会自增;所以就实现了全局自增ID了

2.7 Kafka controller详解

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

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

2.7.1 Kafka Controller选举

Kafka Controller,其实就是Kafka集群中一台Broker,它除了具有普通Broker的消息发送、消费、同步功能之外,还需承担一些额外的工作。Kafka使用公平竞选的方式来确定Controller,最先在ZooKeeper成功创建临时节点/controller的Broker会成为Controller,一般而言,Kafka集群中第一台启动的Broker会成为Controller,并将自身Broker编号等信息写入ZooKeeper临时节点/controller。

{"version":1,"brokerid":1,"timestamp":"1634024397002"}

其中version固定为1,brokerid表示该Broker编号成为controller,timestamp表示成为Controller的时间戳。在任意时刻,Kafka集群中有且只有一台Controller,每个Broker启动的时候都会去尝试读取ZooKeeper临时节点/controller的brokerid,如果读取到brokerid不为-1,则表示已有Broker竞选成为Controller。此时,当前Broker会放弃竞选Controller,并对ZooKeeper临时节点/controller注册监听器,当Controller因为某些情况导致Kafka进程停止,甚至所在的机器宕机,在规定的时间内没有发送心跳到ZooKeeper,此时ZooKeeper会将临时节点/controller删除,然后监听器会通知各个Broker进行Controller选举,第一个创建ZooKeeper临时节点/controller被认为抢占成功,成为新的Controller。

每个broker都会在内存中保存当前控制器的brokerid值,这个值可以标识为activeControllerId。

2.7.2 脑裂

随着服务的长时间运行,加上Controller相比普通Broker需承担一部分额外的工作,Controller不可避免发生Full GC,导致服务停止,如果Full GC时间很长,甚至超过Broker与ZooKeeper设置的会话时间,此时ZooKeeper会认为Controller下线,并自动删除临时节点/controller,进行新一轮的Controller选举。

选举产生新的Controller之后,ZooKeeper会通知所有Broker更新内存中的ActiveControllerId,原先发生Full GC的Controller因为停止服务收不到Controller更新通知,在Full GC过后,原先的Controller认为自身服务正常,只是假死了一段时间,甚至还认为自己是Controller,此时Kafka集群就会有两个Controller,这就是Controller脑裂问题。

为了解决Controller脑裂问题,ZooKeeper中还有一个与Controller有关的持久节点/controller_epoch,存放的是一个整数值,用于记录Controller发生变更的次数,即记录当前是第几代Controller,也称为纪元编号。Controller和普通Broker的请求都会携带controller_epoch,如果请求的controller_epoch小于ActiveControllerId,则认为这个请求是已经过期的Controller发送的无效请求,此时普通Broker,如果请求的controller_epoch大于内存中ActiveControllerId,那么说明已经有新的Controller产生,当前Broker需更新内存中的ActiveControllerId。Kafka通过controller_epoch来保证Controller的唯一性,同时防止Controller脑裂。

2.7.3 Controller职责 2.7.3.1.选举Leader和ISR

控制器从ZK的/brokers/topics加载一个topic所有分区的所有副本,从分区副本列表中选出一个作为该分区的leader,并将该分区对应所有副本置于ISR列表,其他分区类似;其他topic的所有分区也类似。

2.7.3.2.同步元数据信息

控制器从ZK的/brokers/ids以及topic下各分区leader和ISR,将这些元数据信息同步到集群每个broker。

而且通过下面所阐述的监控机制当有broker或者分区发生变更时及时更新到集群,保证集群每一台broker缓存的是最新元数据。

2.7.3.3.broker增删的监听与处理
  • broker加入的监听和处理
    控制器启动时注册一个监视器(BrokerChangeHandler)监视ZK /brokers/ids/子节点。当存在broker启动加入集群后都会在ZK /brokers/ids/增加一个子节点brokerId,控制器的监视器发现这种变化后,控制器开始执行broker加入的相关流程并更新元数据信息到集群。

  • broker崩溃的监听与处理
    当一个broker崩溃时,该broker与ZK的会话失效导致ZK会删除该子节点,控制器的监视器发现这种变化后,控制器开始执行broker删除的相关流程并更新元数据信息到集群。

2.7.3.4.topic变化监听与处理
  • topic创建的监听与处理
    控制器启动时注册一个监视器(TopicChangeHandler)监视ZK /brokers/topics/子节点。当通过脚本或者请求创建一个topic后,该topic对应的所有分区及其副本都会写入该目录下的一个子节点。控制器的监视器发现这种变化后,控制器开始执行topic创建的相关流程包括leader选举和ISR并同步元数据信息到集群;且新增一个监视器监视ZK /brokers/topics/<新增topic子节点内容>监控该topic内容变化。

  • topic删除的监听与处理
    控制器启动时注册一个监视器(TopicDeleteHandler)监视ZK /admin/delete_topics/子节点。当通过脚本或者请求删除一个topic后,该topic会写入该目录下的一个子节点。控制器的监视器发现这种变化后,控制器开始执行topic删除的相关流程包括通知该topic所有分区的所有副本停止运行;通知所有分区所有副本删除数据;删除ZK /admin/delete_topics/<待删除topic子节点>。

2.7.3.5.分区变化监听与变化处理
  • 分区重分配监听与处理
    分区重分配通过KAFKA管理员脚本执行完成一个topic下分区的副本重新分配broker。
    控制器启动时注册一个监视器监视ZK /admin/reassign_partitions/子节点。当通过脚本执行分区重分配后会在该目录增加一个子节点,子节点内容是按照一定格式构建的重分配方案,控制器的监视器发现这种变化后,控制器开始执行分区重分配相关流程,如同步元数据信息。对ZooKeeper中的/isr_change_notification节点注册ChangeNotificetionHandler,用来处理ISR变更;对ZooKeeper中的/admin/preferred-relica-election节点注册PreferredReplicaElectionHandler,用来处理优先副本的选举。

  • 分区扩展监听与处理
    当创建一个topic后,控制器会增加一个监视器监视ZK /brokers/topics/<新增topic子节点内容>防止该topic内容变化。当通过脚本执行分区扩展后会在该目录增加新的分区目录。控制器的监视器发现这种变化后,控制器开始执行分区扩展相应流程,如选举leader和ISR并同步。

2.7.3.6.自动平衡优先副本

kafka中有一个被称为**优先副本(preferred replica)**的概念。例如某个分区有3个分区副本[1,2,0],则这3个副本的优先级别分别递减,根据优先副本的概念,1会作为leader。当1节点的broker挂掉时,会启动2这个节点broker当做leader。如果开启了leader均衡机制,当broker 1重新启动后会重新成为 partition leader,优先副本就是该分区的leader副本,也被称为preferred leader。

通俗的说,优先副本是AR中的第一个副本,这个副本通常为leader。

优先副本选举就是尽可能的将每个分区的leader副本作为优先副本,从而促进集群的负载均衡,但是真正的负载均衡还得参考每个leader的数据传输负载

Kafka 默认有一个参数控制自动优先副本选举,该参数是 auto.leader.rebalance.enable,默认值为 true,即Controller默认开启定时任务控制优先副本选举,选举机制的时间间隔通过leader.imbalance.check.interval.seconds参数进行控制,默认是5分钟(300s)一次,该选举机制的衡量标准是通过“broker不平衡率”

broker不平衡率=非优先副本的leader个数/总分区数

假如该值超过leader.imbalance.per.broker.percentage,默认为10%,那么就开始进行优先副本的选举。

示例:创建一个topic分区数为3,副本因子也为3,创建结果如下所示

假设由于2号broker宕机或者其它情况导致1号分区的leader变得不可用,此时重新选举了一个leader在0-broker上,那么结果如下。

此时,0-broker不平衡率=1/3=33%

在实际生产环境中是不会开启优先副本选举的(在 conf/server.properties中修改),因为可能引起负面的性能问题,比如客户端请求阻塞,所以一般是通过监控+手动控制优先副本的方式来控制集群负载,手动控制通过如下命令实现

bin/kafka-preferred-replica-election.sh --zookeeper localhost:2181 --path-to-json-file election.json

election.json文件内容示例如下。选举操作应该避开业务高峰期进行,这个–path-to-json-file选项是可选的,但是强烈建议加上这个配置。

{
  "partitions":[
    {
      "partition":0,
      "topic":"topic-partitions"
    },
    {
      "partition":1,
      "topic":"topic-partitions"
    },
    {      
      "partition":2,
      "topic":"topic-partitions"}
  ]
}
2.7.3.7.总结

Controller就是注册一些监听器,监听事件做相应的处理,以及开启一些定时任务,做相应的处理。二者的区别在于,监听器能快速做出相应处理,比如Topic变更,这些事件的实时性要求很高,要求系统立即反应。优先副本不平衡,只是Broker读写流量不均衡,有一定程度的不平衡,对于Kafka集群来说是可以接受的,因此像分区优先副本自动平衡就可以用定时任务来处理。

2.7.4工作原理

Controller在选举成功后会读取ZooKeeper中各个节点的信息来初始化ControllerContext,并管理这些ControllerContext,比如某个Topic增加若干个分区,Controller在负责创建这些分区的同时,还要更新ControllerContext,并且需要将这些变更信息同步到普通Broker。不管是监听器触发的事件,还是定时任务触发的事件,或者是其他事件都会读取或者更新Controller中的ControllerContext,那么这样就会涉及多线程同步。如果单纯使用锁机制来控制,那么整体性能会大打折扣,实际上,Kafka在0.10之前,都是通过锁机制的方式来处理ControllerContext的多线程同步问题。在0.11后改用单线程基于事件队列的模型,将每个事件都做一层封装,然后按事件发生的先后顺序暂存到LinkedBlockingQueue中,最后使用ControllerEventThread线程按照FIFO的原则来处理各个事件,这样就可以不用锁机制解决多线程同步问题。

变更Controller,通常有以下几种方式,但是Controller上下线,需要付出的代价比较大,需要关闭原Controller各种监听器、定时任务、以及各种线程,并且新Controller上线同样开启以上资源。一般而言,除非Controller所在的机器IO、CPU、内存等资源不足,又或者频繁发生长时间Full GC,否则不应该人为变更Controller。

  1. 手动更改ZooKeeper临时/controller中brokerid,每个Broker会更新内存中的ActiveControllerId。
  2. 手动删除ZooKeeper临时节点/controller,触发一轮新的选举。
  3. 停止当前Controller Kafka进程,此时ZooKeeper会认为Controller所在的Broker宕机,ZooKeeper同样会删除临时节点/controller,触发一轮新的选举。
2.7.5 broker优雅退出

相比较broker机器直接宕机或强制kill,通过脚本关闭一个broker称为broker优雅退出。即将关闭的broker向控制器发送退出请求后一直阻塞。

控制器接收到请求后,执行leader重选举和ISR后响应broker。broker接收后退出。

这个比较特殊,不依赖ZK,直接通过broker和控制器RPC通信即可完成。

2.8 Kafka事务

Kafka 从 0.11 版本开始引入了事务支持。事务可以保证 Kafka 在 Exactly Once 语义的基础上,生产和消费可以跨分区和会话,要么全部成功,要么全部失败。

2.8.1 Producer 事务

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

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

2.8.2 Consumer 事务

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

2.9 Kafka Connect

Kafka Connect是高伸缩性、高可靠性的数据集成工具,用于处理Kafka和其他系统数据连接以及ETL操作。

2.10 Kafka Streams

Kafka Streams是对Kafka中的数据流进行逻辑处理的组件。

2.10.1 Kafka Streams特点
  1. 功能强大
    高扩展性,弹性,容错
  2. 轻量级
    无需专门的集群 ,一个库,而不是框架
  3. 完全集成
    100%的Kafka 0.10.0版本兼容,易于集成到现有的应用程序
  4. 实时性
    毫秒级延迟 ,并非微批处理
    窗口允许乱序数据
    允许迟到数据
2.10.2 为什么使用kafka stream

第一,Spark和Storm都是流式处理框架,而Kafka Stream提供的是一个基于Kafka的流式处理类库。框架要求开发者按照特定的方式去开发逻辑部分,供框架调用。开发者很难了解框架的具体运行方式,从而使得调试成本高,并且使用受限。而Kafka Stream作为流式处理类库,直接提供具体的类给开发者调用,整个应用的运行方式主要由开发者控制,方便使用和调试。

第二,虽然Cloudera与Hortonworks方便了Storm和Spark的部署,但是这些框架的部署仍然相对复杂。而Kafka Stream作为类库,可以非常方便的嵌入应用程序中,它对应用的打包和部署基本没有任何要求。

第三,就流式处理系统而言,基本都支持Kafka作为数据源。例如Storm具有专门的kafka-spout,而Spark也提供专门的spark-streaming-kafka模块。事实上,Kafka基本上是主流的流式处理系统的标准数据源。换言之,大部分流式系统中都已部署了Kafka,此时使用Kafka Stream的成本非常低。

第四,使用Storm或Spark Streaming时,需要为框架本身的进程预留资源,如Storm的supervisor和Spark on YARN的node manager。即使对于应用实例而言,框架本身也会占用部分资源,如Spark Streaming需要为shuffle和storage预留内存。但是Kafka作为类库不占用系统资源。

第五,由于Kafka本身提供数据持久化,因此Kafka Stream提供滚动部署和滚动升级以及重新计算的能力。

第六,由于Kafka Consumer Rebalance机制,Kafka Stream可以在线动态调整并行度。

2.10.3 Kafka Stream数据清洗案例

需求:实时处理单词带有”>>>”前缀的内容。例如输入”hadoop>>>spark”,最终处理成“spark”

步骤:

  1. 创建工程并添加jar包;
  2. 创建主类;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;
import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorSupplier;

import java.util.Properties;

public class KafkaStreamApplication {

    public static void main(String[] args) {
        // 输入topic
        String from = "first";

        // 输出topic
        String to = "second";

        // 构建kafka stream的配置
        Properties props = new Properties();
        props.put(StreamsConfig.APPLICATION_ID_CONFIG, "logFilter");
        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "lubin01:9092,lubin02:9092,lubin03:9093");

        StreamsConfig config = new StreamsConfig(props);

        // 构建topology
        StreamsBuilder builder = new StreamsBuilder();

        Topology topology = builder.build();

        topology.addSource("SOURCE", from).addProcessor("PROCESS", new ProcessorSupplier() {
            @Override
            public Processor get() {
                return new LogProcessor();
            }
        }, "SOURCE").addSink("SINK", to, "PROCESS");

        KafkaStreams streams = new KafkaStreams(topology, config);
        streams.start();
    }
}
  1. 具体业务处理
import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorContext;

public class LogProcessor implements Processor {

    private ProcessorContext processorContext;

    @Override
    public void init(ProcessorContext processorContext) {
        this.processorContext = processorContext;
    }

    @Override
    public void process(byte[] key, byte[] value) {
        String input = new String(value);

        // 如果包含“>>>”则只保留该标记后面的内容
        if (input.contains(">>>")) {
            input = input.split(">>>")[1].trim();
            // 输出到下一个topic
            processorContext.forward("logProcessor".getBytes(), input.getBytes());
        } else {
            processorContext.forward("logProcessor".getBytes(), "no >>>".getBytes());
        }
    }

    @Override
    public void close() {

    }
}
  1. 运行程序
  2. 启动生产者
bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic first
>hello>>>world
>h>>>root
>>>hahaha
  1. 在其它机器上启动消费者
bin/kafka-console-consumer.sh --bootstrap-server lubin01:9092 --from-beginning --topic second
world
root
Hahaha
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/937168.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号