美文网首页程序员
万字修行!消息中间件架构体系:Kafka研究,从入门到深入

万字修行!消息中间件架构体系:Kafka研究,从入门到深入

作者: 996小迁 | 来源:发表于2021-01-19 15:42 被阅读0次

    前言

    Kafka 是一款分布式消息发布和订阅系统,具有高性能、高吞吐量的特点而被广泛应用与大数据传输场景。它是由 LinkedIn 公司开发,使用 Scala 语言编写,之后成为 Apache 基金会的一个顶级项目。kafka 提供了类似 JMS 的特性,但是在设计和实现上是完全不同的,而且他也不是 JMS 规范的实现。

    Kafka简介

    kafka产生背景

    kafka 作为一个消息系统,早起设计的目的是用作 LinkedIn 的活动流(Activity Stream)和运营数据处理管道(Pipeline)。活动流数据是所有的网站对用户的使用情况做分析的时候要用到的最常规的部分,活动数据包括页面的访问量(PV)、被查看内容方面的信息以及搜索内容。这种数据通常的处理方式是先把各种活动以日志的形式写入某种文件,然后周期性的对这些文件进行统计分析。运营数据指的是服务器的性能数据(CPU、IO 使用率、请求时间、服务日志等)。

    Kafka应用场景

    由于 kafka 具有更好的吞吐量、内置分区、冗余及容错性的优点(kafka 每秒可以处理几十万消息),让 kafka 成为了一个很好的大规模消息处理应用的解决方案。

    日志收集:日志收集方面,有很多比较优秀的产品,比如 Apache Flume,很多公司使用kafka 代理日志聚合。

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    `

    kafka架构

    一个典型的 kafka 集群包含若干 Producer(可以是应用节点产生的消息,也可以是通过Flume 收集日志产生的事件),若干个 Broker(kafka 支持水平扩展)、若干个 Consumer Group,以及一个 zookeeper 集群。kafka 通过 zookeeper 管理集群配置及服务协同。

    Producer 使用 push 模式将消息发布到 broker,consumer 通过监听使用 pull 模式从broker 订阅并消费消息。多个 broker 协同工作,producer 和 consumer 部署在各个业务逻辑中。三者通过zookeeper 管理协调请求和转发。这样就组成了一个高性能的分布式消息发布和订阅系统。图上有一个细节是和其他 mq 中间件不同的点,producer 发送消息到 broker的过程是 push,而 consumer 从 broker 消费消息的过程是 pull,主动去拉数据。而不是 broker 把数据主动发送给 consumer

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    名词解释:

    Topic:Kafka将消息分门别类,每一类的消息称之为一个主题(Topic)。

    Producer:发布消息的对象称之为主题生产者(Kafka topic producer)

    Consumer:订阅消息并处理发布的消息的对象称之为主题消费者(consumers)

    Broker:已发布的消息保存在一组服务器中,称之为Kafka集群。集群中的每一个服务器都是一个代理(Broker)。 消费者可以订阅一个或多个主题(topic),并从Broker拉数据,从而消费这些已发布的消息。

    Topic和Log:Topic是发布的消息的类别名,一个topic可以有零个,一个或多个消费者订阅该主题的消息。对于每个topic,Kafka集群都会维护一个分区log,就像下图中所示:

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    每一个分区都是一个顺序的、不可变的消息队列, 并且可以持续的添加。分区中的消息都被分了一个序列号,称之为偏移量(offset),在每个分区中此偏移量都是唯一的。

    Kafka集群保持所有的消息,直到它们过期(无论消息是否被消费)。可以看到这种设计对消费者来说操作自如,一个消费者的操作不会影响其它消费者对此log的处理。

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    分布式:Log的分区被分布到集群中的多个服务器上。每个服务器处理它分到的分区。 根据配置每个分区还可以复制到其它服务器作为备份容错。 每个分区有一个leader,零或多个follower。Leader处理此分区的所有的读写请求,而follower被动的复制数据。 这样可以平衡负载,避免所有的请求都只让一台或者某几台服务器处理。

    生产者:生产者往某个Topic上发布消息。生产者也负责选择发布到Topic上的哪一个分区。最简单的方式从分区列表中轮流选择。也可以根据某种算法依照权重选择分区。开发者负责如何选择分区的算法。

    消费者:通常来讲,消息模型可以分为两种, 队列和发布-订阅式。 队列的处理方式是 一组消费者从服务器读取消息,一条消息只有其中的一个消费者来处理。在发布-订阅模型中,消息被广播给所有的消费者,接收到消息的消费者都可以处理此消息。Kafka为这两种模型提供了单一的消费者抽象模型: 消费者组 (consumer group)。 消费者用一个消费者组名标记自己。 一个发布在Topic上消息被分发给此消费者组中的一个消费者。 每个组包含数目不等的消费者, 一个组内多个消费者可以用来扩展性能和容错。正如下图所示:

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    2个kafka集群托管4个分区(P0-P3),2个消费者组,消费组A有2个消费者实例,消费组B有4个。

    Docker搭建kafka

    下载以下三个镜像

    docker pull wurstmeister/zookeeper
    docker pull wurstmeister/kafka
    docker pull sheepkiller/kafka-manager
    

    kafka-manager是kafka的可视化管理工具

    启动容器

    docker run -d --name zookeeper --publish 2181:2181 \--volume /etc/localtime:/etc/localtime \--restart=always \wurstmeister/zookeeper
    
    docker run -d --name kafka --publish 9082:9092 \--link zookeeper:zookeeper \--env KAFKA_BROKER_ID=100 \--env HOST_IP=127.0.0.1 \--env KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 \--env KAFKA_ADVERTISED_HOST_NAME=192.168.1.108 \--env KAFKA_ADVERTISED_PORT=9082 \--restart=always \--volume /etc/localtime:/etc/localtime \wurstmeister/kafka
    
    docker run -d --name kafka-manager \--link zookeeper:zookeeper \--link kafka:kafka -p 9001:9000 \--restart=always \--env ZK_HOSTS=zookeeper:2181 \sheepkiller/kafka-manager
    

    访问

    http://127.0.0.1:9001

    添加Cluster

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    查看界面

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    搭建完毕,页面其他功能自己摸索下

    Kafka快速加入门

    //以下Spring Boot应用程序将三个消息发送到一个主题,接收它们,然后停止:
    @SpringBootApplication
    public class Application implements CommandLineRunner {
    
        public static Logger logger = LoggerFactory.getLogger(Application.class);
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args).close();
        }
    
        @Autowired
        private KafkaTemplate<String, String> template;
    
        private final CountDownLatch latch = new CountDownLatch(3);
    
        @Override
        public void run(String... args) throws Exception {
            this.template.send("myTopic", "foo1");
            this.template.send("myTopic", "foo2");
            this.template.send("myTopic", "foo3");
            latch.await(60, TimeUnit.SECONDS);
            logger.info("All received");
        }
    
        @KafkaListener(topics = "myTopic")
        public void listen(ConsumerRecord<?, ?> cr) throws Exception {
            logger.info(cr.toString());
            latch.countDown();
        }
    
    }
    

    Kafka进阶

    通信原理

    消息是 kafka 中最基本的数据单元,在 kafka 中,一条消息由 key、 value 两部分构成,在发送一条消息时,我们可以指定这个 key,那么 producer 会根据 key 和 partition 机制来判断当前这条消息应该发送并存储到哪个 partition 中。我们可以根据需要进行扩展 producer 的 partition 机制。

    消息默认的分发机制

    默认情况下,kafka 采用的是 hash 取模的分区算法。如果Key 为 null,则会随机分配一个分区。这个随机是在这个参数”metadata.max.age.ms”的时间范围内随机选择一个。对于这个时间段内,如果 key 为 null,则只会发送到唯一的分区。这个值值哦默认情况下是 10 分钟更新一次。

    关于 Metadata ,这个之前没讲过,简单理解就是T opic/Partition 和 broker 的映射关系,每一个 topic 的每一个 partition,需要知道对应的 broker 列表是什么, leader是谁、 follower 是谁。这些信息都是存储在 Metadata 这个类里面。

    消费端如何消费指定的分区

    //通过下面的代码,就可以消费指定该 topic 下的 0 号分区。其他分区的数据就无法接收
    //消费指定分区的时候,不需要再订阅
    //kafkaConsumer.subscribe(Collections.singletonList(topic));
    //消费指定的分区
    TopicPartition topicPartition=new 
    TopicPartition(topic,0);
    kafkaConsumer.assign(Arrays.asList(topicPartit
    ion));
    

    消费原理

    在实际生产过程中,每个 topic 都会有多个 partitions,多个 partitions 的好处在于,一方面能够对 broker 上的数据进行分片有效减少了消息的容量从而提升 io 性能。另外一方面,为了提高消费端的消费能力,一般会通过多个consumer 去消费同一个 topic ,也就是消费端的负载均衡机制,也就是我们接下来要了解的,在多个partition 以及多个 consumer 的情况下,消费者是如何消费消息的同时,在上一节课,我们讲了, kafka 存在 consumer group的 概 念 , 也 就是 group.id 一样 的 consumer ,这些consumer 属于一个 consumer group,组内的所有消费者协调在一起来消费订阅主题的所有分区。当然每一个分区只能由同一个消费组内的 consumer 来消费,那么同一个consumer group 里面的 consumer 是怎么去分配该消费哪个分区里的数据的呢?如下图所示, 3 个分区, 3 个消费者,那么哪个消费者消分哪个分区?

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    分区分配策略

    在 kafka 中,存在两种分区分配策略,一种是 Range(默认)、另 一 中 另 一 中 还 是 RoundRobin ( 轮 询 )。 通过partition.assignment.strategy 这个参数来设置。

    Range strategy(范围分区)

    Range 策略是对每个主题而言的,首先对同一个主题里面的分区按照序号进行排序,并对消费者按照字母顺序进行排序。假设我们有 10 个分区,3 个消费者,排完序的分区将会是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;消费者线程排完序将会是C1-0, C2-0, C3-0。然后将 partitions 的个数除于消费者线程的总数来决定每个消费者线程消费几个分区。如果除不尽,那么前面几个消费者线程将会多消费一个分区。在我们的例子里面,我们有 10 个分区,3 个消费者线程, 10 / 3 = 3,而且除不尽,那么消费者线程 C1-0 将会多消费一个分区,所以最后分区分配的结果看起来是这样的:

    • C1-0 将消费 0, 1, 2, 3 分区
    • C2-0 将消费 4, 5, 6 分区
    • C3-0 将消费 7, 8, 9 分区

    假如我们有 11 个分区,那么最后分区分配的结果看起来是这样的:

    • C1-0 将消费 0, 1, 2, 3 分区
    • C2-0 将消费 4, 5, 6, 7 分区
    • C3-0 将消费 8, 9, 10 分区

    假如我们有 2 个主题(T1 和 T2),分别有 10 个分区,那么最后分区分配的结果看起来是这样的:

    • C1-0 将消费 T1 主题的 0, 1, 2, 3 分区以及 T2 主题的 0, 1, 2, 3 分区
    • C2-0 将消费 T1 主题的 4, 5, 6 分区以及 T2 主题的 4, 5, 6 分区
    • C3-0 将消费 T1 主题的 7, 8, 9 分区以及 T2 主题的 7, 8, 9 分区

    可以看出,C1-0 消费者线程比其他消费者线程多消费了 2 个分区,这就是 Range strategy 的一个很明显的弊端

    RoundRobin strategy(轮询分区)

    轮询分区策略是把所有 partition 和所有 consumer 线程都列出来,然后按照 hashcode 进行排序。最后通过轮询算法分配 partition 给消费线程。如果所有 consumer 实例的订阅是相同的,那么 partition 会均匀分布。

    在我们的例子里面,假如按照 hashCode 排序完的 topicpartitions 组依次为 T1-5, T1-3, T1-0, T1-8, T1-2, T1-1, T1-4, T1-7, T1-6, T1-9,我们的消费者线程排序为 C1-0, C1-1, C2-0, C2-1,最后分区分配的结果为:

    • C1-0 将消费 T1-5, T1-2, T1-6 分区;
    • C1-1 将消费 T1-3, T1-1, T1-9 分区;
    • C2-0 将消费 T1-0, T1-4 分区;
    • C2-1 将消费 T1-8, T1-7 分区;

    使用轮询分区策略必须满足两个条件

    1. 每个主题的消费者实例具有相同数量的流
    2. 每个消费者订阅的主题必须是相同的

    什么时候会触发这个策略呢?

    当出现以下几种情况时,kafka 会进行一次分区分配操作,

    也就是 kafka consumer 的 rebalance

    1. 同一个 consumer group 内新增了消费者
    2. 消费者离开当前所属的 consumer group,比如主动停机或者宕机
    3. topic 新增了分区(也就是分区数量发生了变化)
      kafka consuemr 的 rebalance 机制规定了一个 consumergroup 下的所有 consumer 如何达成一致来分配订阅 topic的每个分区。而具体如何执行分区策略,就是前面提到过的两种内置的分区策略。而 kafka 对于分配策略这块,提供了可插拔的实现方式, 也就是说,除了这两种之外,我们还可以创建自己的分配机制。

    什么时候会触发这个策略呢?

    当出现以下几种情况时,kafka 会进行一次分区分配操作,也就是 kafka consumer 的 rebalance

    1. 同一个 consumer group 内新增了消费者
    2. 消费者离开当前所属的 consumer group,比如主动停机或者宕机
    3. topic 新增了分区(也就是分区数量发生了变化)kafka consuemr 的 rebalance 机制规定了一个 consumergroup 下的所有 consumer 如何达成一致来分配订阅 topic的每个分区。而具体如何执行分区策略,就是前面提到过的两种内置的分区策略。而 kafka 对于分配策略这块,提供了可插拔的实现方式, 也就是说,除了这两种之外,我们还可以创建自己的分配机制。

    谁来执行 Rebalance 以及管理 consumer 的 group 呢?

    Kafka 提供了一个角色: coordinator 来执行对于 consumer group 的管理,Kafka 提供了一个角色:coordinator 来执行对于 consumer group 的管理,当 consumer group 的第一个 consumer 启动的时候,它会去和 kafka server 确定谁是它们组的 coordinator。之后该 group 内的所有成员都会和该 coordinator 进行协调通信

    如何确定 coordinator

    consumer group 如何确定自己的 coordinator 是谁呢, 消费 者 向 kafka 集 群 中 的 任 意 一 个 broker 发 送 一 个GroupCoordinatorRequest 请求,服务端会返回一个负载最 小 的 broker 节 点 的 id , 并 将 该 broker 设 置 为coordinator

    JoinGroup 的过程

    在 rebalance 之前,需要保证 coordinator 是已经确定好了的,整个 rebalance 的过程分为两个步骤,Join 和 Syncjoin: 表示加入到 consumer group 中,在这一步中,所有的成员都会向 coordinator 发送 joinGroup 的请求。一旦所有成员都发送了 joinGroup 请求,那么 coordinator 会选择一个 consumer 担任 leader 角色,并把组成员信息和订阅信息发送消费者

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    protocol_metadata: 序列化后的消费者的订阅信息

    leader_id: 消费组中的消费者,coordinator 会选择一个座位 leader,对应的就是 member_id

    member_metadata 对应消费者的订阅信息

    members:consumer group 中全部的消费者的订阅信息

    generation_id: 年代信息,类似于之前讲解 zookeeper 的时候的 epoch 是一样的,对于每一轮 rebalance

    generation_id 都会递增。主要用来保护 consumer group。隔离无效的 offset 提交。也就是上一轮的 consumer 成员无法提交 offset 到新的 consumer group 中。

    Synchronizing Group State 阶段

    完成分区分配之后,就进入了 Synchronizing Group State阶段,主要逻辑是向 GroupCoordinator 发送SyncGroupRequest 请求,并且处理 SyncGroupResponse响应,简单来说,就是 leader 将消费者对应的 partition 分配方案同步给 consumer group 中的所有 consumer

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    每个消费者都会向 coordinator 发送 syncgroup 请求,不过只有 leader 节点会发送分配方案,其他消费者只是打打酱油而已。当 leader 把方案发给 coordinator 以后,coordinator 会把结果设置到 SyncGroupResponse 中。这样所有成员都知道自己应该消费哪个分区。

    ➢ consumer group 的分区分配方案是在客户端执行的!Kafka 将这个权利下放给客户端主要是因为这样做可以有更好的灵活性

    如何保存消费端的消费位置

    什么是 offset

    前面在讲partition 的时候,提到过 offset, 每个 topic可以划分多个分区(每个 Topic 至少有一个分区),同一topic 下的不同分区包含的消息是不同的。每个消息在被添加到分区时,都会被分配一个 offset(称之为偏移量),它是消息在此分区中的唯一编号, kafka 通过 offset 保证消息在分区内的顺序, offset 的顺序不跨分区,即 kafka 只保证在同一个分区内的消息是有序的; 对于应用层的消费来说,每次消费一个消息并且提交以后,会保存当前消费到的最近的一个 offset。那么 offset 保存在哪里?

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    offset 在哪里维护?

    在 kafka 中,提供了一个_consumer_offsets的一个topic ,把 offset 信息写入到这个topic中。

    _consumer_offsets——按保存了每个 consumer group某一时刻提交的 offset 信息。 consumer_offsets 默认有50 个分区。

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    消息的存储原理

    消息的保存路径

    消息发送端发送消息到 broker 上以后,消息是如何持久化的呢?那么接下来去分析下消息的存储

    首先我们需要了解的是, kafka 是使用日志文件的方式来保存生产者和发送者的消息,每条消息都有一个 offset 值来表示它在分区中的偏移量。 Kafka 中存储的一般都是海量的消息数据,为了避免日志文件过大,Log 并不是直接对应在一个磁盘上的日志文件,而是对应磁盘上的一个目录,这个目录的明明规则是<topic_name>_<partition_id>比如创建一个名为 firstTopic 的 topic,其中有 3 个 partition,那么在 kafka 的数据目录(/tmp/kafka-log)中就有 3 个目录,firstTopic-0~3

    多个分区在集群中的分配

    如果我们对于一个 topic,在集群中创建多个 partition,那么 partition 是如何分布的呢?

    1.将所有 N Broker 和待分配的 i 个 Partition 排序

    2.将第 i 个 Partition 分配到第(i mod n)个 Broker 上

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    了解到这里的时候,大家再结合前面讲的消息分发策略,就应该能明白消息发送到 broker 上,消息会保存到哪个分区中,并且消费端应该消费哪些分区的数据了。

    消息写入的性能

    我们现在大部分企业仍然用的是机械结构的磁盘,如果把消息以随机的方式写入到磁盘,那么磁盘首先要做的就是寻址,也就是定位到数据所在的物理地址,在磁盘上就要找到对应的柱面、磁头以及对应的扇区;这个过程相对内存来说会消耗大量时间,为了规避随机读写带来的时间消耗, kafka 采用顺序写的方式存储数据。

    页缓存

    顺序写入是Kafka高吞吐量的一个原因,当然即使采用的是磁盘的顺序写入,那么也是没有办法和内存相比的。因为为了再一次提高Kakfa的吞吐量,Kafka采用了Memory Mapped Files

    (后面简称mmap)也被翻译成内存映射文件 ,它的工作原理是直接利用操作系统的page cache 来实现文件到物理内存的直接映射,完成映射之后你对物理内存的操作会被同步到硬盘上(操作系统在适当的时候)。

    操作系统本身有一层缓存,叫做page cache,是在内存里的缓存,我们也可以称之为os cache,意思就是操作系统自己管理的缓存。你在写入磁盘文件的时候,可以直接写入这个os cache里,也就是仅仅写入内存中,接下来由操作系统自己决定什么时候把os cache里的数据真的刷入磁

    盘文件中(每5秒检查一次是否需要将页缓存数据同步到磁盘文件)。仅仅这一个步骤,就可以将磁盘文件写性能提升很多了,因为其实这里相当于是在写内存,不是在写磁盘.

    零拷贝

    消息从发送到落地保存,broker 维护的消息日志本身就是文件目录,每个文件都是二进制保存,生产者和消费者使用相同的格式来处理。在消费者获取消息时,服务器先从硬盘读取数据到内存,然后把内存中的数据原封不动的通过 socket 发送给消费者。虽然这个操作描述起来很简单,但实际上经历了很多步骤。

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    ▪ 操作系统将数据从磁盘读入到内核空间的页缓存

    ▪ 应用程序将数据从内核空间读入到用户空间缓存中

    ▪ 应用程序将数据写回到内核空间到 socket 缓存中

    ▪ 操作系统将数据从 socket 缓冲区复制到网卡缓冲区,以便将数据经网络发出

    这个过程涉及到 4 次上下文切换以及 4 次数据复制,并且有两次复制操作是由 CPU 完成。但是这个过程中,数据完全没有进行变化,仅仅是从磁盘复制到网卡缓冲区。

    通过“ 零拷贝 ”技术,可以去掉这些没必要的数据复制操作,同时也会减少上下文切换次数。现代的 unix 操作系统提供一个优化的代码路径,用于将数据从页缓存传输到 socket;在 Linux 中,是通过 sendfile 系统调用来完成的。Java 提供了访问这个系统调用的方法: FileChannel.transferTo API

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    使用 sendfile,只需要一次拷贝就行,允许操作系统将数据直接从页缓存发送到网络上。所以在这个优化的路径中,只有最后一步将数据拷贝到网卡缓存中是需要的

    消息的文件存储机制

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    前面我们知道了一个 topic 的多个 partition 在物理磁盘上的保存路径,那么我们再来分析日志的存储方式。通过如下命令找到对应 partition 下的日志内容

    [root@localhost ~]# ls /tmp/kafka-logs/firstTopic-1/00000000000000000000.index 00000000000000000000.log  00000000000000000000.timeindex   leader-epochcheckpoint
    

    kafka 是通过分段的方式将 Log 分为多个 LogSegment,LogSegment 是一个逻辑上的概念,一个 LogSegment 对应磁盘上的一个日志文件和一个索引文件,其中日志文件是用来记录消息的。索引文件是用来保存消息的索引。那么这个 LogSegment 是什么呢?

    LogSegment

    假设 kafka 以 partition 为最小存储单位,那么我们可以想象当 kafka producer 不断发送消息,必然会引起 partition文件的无线扩张,这样对于消息文件的维护以及被消费的消息的清理带来非常大的挑战,所以 kafka 以 segment 为单位又把 partition 进行细分。每个 partition 相当于一个巨型文件被平均分配到多个大小相等的 segment 数据文件中(每个 segment 文件中的消息不一定相等),这种特性方便已经被消费的消息的清理,提高磁盘的利用率。

    ➢ log.segment.bytes=107370 ( 设置分段大小 ), 默认是1gb,我们把这个值调小以后,可以看到日志分段的效果

    ➢ 抽取其中 3 个分段来进行分析

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    segment file 由 2 大部分组成,分别为 index file 和 data file,此 2 个文件一一对应,成对出现,后缀".index"和“.log”分别表示为 segment 索引文件、数据文件.segment 文件命名规则:partion 全局的第一个 segment从 0 开始,后续每个 segment 文件名为上一个 segment文件最后一条消息的 offset 值进行递增。数值最大为 64 位long 大小,20 位数字字符长度,没有数字用 0 填。

    segment 中 index 和 log 的对应关系

    从所有分段中,找一个分段进行分析为了提高查找消息的性能,为每一个日志文件添加 2 个索引索引文件: OffsetIndex 和 TimeIndex,分别对应 .index以及 .timeindex, TimeIndex 索引文件格式:它是映射时间戳和相对offset

    查 看 索 引 内 容 : sh  kafka-run-class.sh 
    kafka.tools.DumpLogSegments  --files  /tmp/kafkalogs/test-0/00000000000000000000.index  --print-datalog
    
    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    如图所示,index 中存储了索引以及物理偏移量。 log 存储了消息的内容。索引文件的元数据执行对应数据文件中

    message 的物理偏移地址。举个简单的案例来说,以[4053,80899]为例,在 log 文件中,对应的是第 4053 条记录,物理偏移量( position )为 80899. position 是ByteBuffer 的指针位置

    在 partition 中如何通过 offset 查找 message

    1. 根据 offset 的值,查找 segment 段中的 index 索引文件。由于索引文件命名是以上一个文件的最后一个offset 进行命名的,所以,使用二分查找算法能够根据offset 快速定位到指定的索引文件。
    2. 找到索引文件后,根据 offset 进行定位,找到索引文件中的符合范围的索引。(kafka 采用稀疏索引的方式来提高查找性能)
    3. 得到 position 以后,再到对应的 log 文件中,从 position出开始查找 offset 对应的消息,将每条消息的 offset 与目标 offset 进行比较,直到找到消息

    比如说,我们要查找 offset=2490 这条消息,那么先找到00000000000000000000.index, 然后找到[2487,49111]这个索引,再到 log 文件中,根据 49111 这个 position 开始查找,比较每条消息的 offset 是否大于等于 2490。最后查找到对应的消息以后返回

    日志清除策略

    前面提到过,日志的分段存储,一方面能够减少单个文件内容的大小,另一方面,方便 kafka 进行日志清理。日志的清理策略有两个

    1. 根据消息的保留时间,当消息在 kafka 中保存的时间超过了指定的时间,就会触发清理过程
    2. 根据 topic 存储的数据大小,当 topic 所占的日志文件大小大于一定的阀值,则可以开始删除最旧的消息。 kafka会启动一个后台线程,定期检查是否存在可以删除的消息

    通过 log.retention.bytes 和 log.retention.hours 这两个参数来设置,当其中任意一个达到要求,都会执行删除。默认的保留时间是:7 天

    日志压缩策略

    Kafka 还提供了“日志压缩(Log Compaction)”功能,通过这个功能可以有效的减少日志文件的大小,缓解磁盘紧张的情况,在很多实际场景中,消息的 key 和 value 的值之间的对应关系是不断变化的,就像数据库中的数据会不断被修改一样,消费者只关心 key 对应的最新的 value。 因此,我们可以开启 kafka 的日志压缩功能,服务端会在后台启动启动 Cleaner 线程池,定期将相同的 key 进行合并,只保留最新的 value 值。日志的压缩原理是

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    partition 的高可用副本机制

    我们已经知道 Kafka 的每个 topic 都可以分为多个 Partition,并且多个 partition 会均匀分布在集群的各个节点下。虽然这种方式能够有效的对数据进行分片,但是对于每个partition 来说,都是单点的,当其中一个 partition 不可用的时候,那么这部分消息就没办法消费。所以 kafka 为了提高 partition 的可靠性而提供了副本的概念(Replica) ,通过副本机制来实现冗余备份。每个分区可以有多个副本,并且在副本集合中会存在一个leader 的副本,所有的读写请求都是由 leader 副本来进行处理。剩余的其他副本都做为 follower 副本,follower 副本 会 从 leader 佛 本 同 步 笑 息 日 志 。 这 个 有 点 类 似zookeeper 中 leader 和 follower 的概念,但是具体的时间方式还是有比较大的差异。所以我们可以认为,副本集会存在一主多从的关系。

    一般情况下,同一个分区的多个副本会被均匀分配到集群中的不同 broker 上,当 leader 副本所在的 broker 出现故障后,可以重新选举新的 leader 副本继续对外提供服务。通过这样的副本机制来提高 kafka 集群的可用性。

    副本分配算法

    将所有 N Broker 和待分配的 i 个 Partition 排序.

    将第 i 个 Partition 分配到第(i mod n)个 Broker 上.

    将第 i 个 Partition 的第 j 个副本分配到第((i + j) mod n)个Broker 上.

    kafka 副本机制中的几个概念

    Kafka 分区下有可能有很多个副本(replica)用于实现冗余,从而进一步实现高可用。副本根据角色的不同可分为 3 类:

    leader 副本:响应 clients 端读写请求的副本

    follower 副本:被动的备份 leader 副本中的数据,不能响应 clients 端读写请求。

    ISR 副本:包含了 leader 副本和所有与 leader 副本保持同步的 follower 副本——如何判定是否与 leader 同步后面会提到每个 Kafka 副本对象都有两个重要的属性:LEO 和HW。注意是所有的副本,而不只是 leader 副本。

    LEO:即日志末端位移(log end offset),记录了该副本底层日志(log)中下一条消息的位移值。注意是下一条消息!也就是说,如果 LEO=10,那么表示该副本保存了 10 条消息,位移值范围是[0, 9]。另外, leader LEO 和follower LEO 的更新是有区别的。我们后面会详细说

    HW:即上面提到的水位值。对于同一个副本对象而言,其

    HW 值不会大于 LEO 值。小于等于 HW 值的所有消息都被认为是“ 已备份” 的(replicated )。同理, leader 副本和follower 副本的 HW 更新是有区别的

    副本协同机制

    刚刚提到了,消息的读写操作都只会由 leader 节点来接收和处理。follower 副本只负责同步数据以及当 leader 副本所在的 broker 挂了以后,会从 follower 副本中选取新的leader。

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    请求首先由 Leader 副本处理,之后 follower 副本会从leader 上拉取写入的消息,这个过程会有一定的延迟,导致 follower 副本中保存的消息略少于 leader 副本,但是只要没有超出阈值都可以容忍。但是如果一个 follower 副本出现异常,比如宕机、网络断开等原因长时间没有同步到消息,那这个时候, leader 就会把它踢出去。 kafka 通过 ISR集合来维护一个分区副本信息

    HW&LEO

    关于 follower 副本同步的过程中,还有两个关键的概念,HW(HighWatermark)和 LEO(Log End Offset). 这两个参数跟 ISR 集合紧密关联。 HW 标记了一个特殊的 offset,当消费者处理消息的时候,只能拉去到 HW 之前的消息, HW之后的消息对消费者来说是不可见的。也就是说,取partition 对应 ISR 中最小的 LEO 作为 HW,consumer 最多只能消费到 HW 所在的位置。每个 replica 都有 HW,leader 和 follower 各自维护更新自己的 HW 的状态。一条消息只有被 ISR 里的所有 Follower 都从 Leader 复制过去才会被认为已提交。这样就避免了部分数据被写进了Leader,还没来得及被任何 Follower 复制就宕机了,而造成数据丢失(Consumer 无法消费这些数据)。而对于Producer 而言,它可以选择是否等待消息 commit,这可以通过 acks 来设置。这种机制确保了只要 ISR 有一个或以上的 Follower,一条被 commit 的消息就不会丢失。

    数据的同步过程

    了解了副本的协同过程以后,还有一个最重要的机制,就是数据的同步过程。它需要解决

    1. 怎么传播消息
    2. 在向消息发送端返回 ack 之前需要保证多少个 Replica
      已经接收到这个消息

    初始状态

    初始状态下,leader 和 follower 的 HW 和 LEO 都是 0,leader 副本会保存 remote LEO,表示所有 follower LEO,也会被初始化为 0,这个时候,producer 没有发送消息。follower 会不断地个 leader 发送 FETCH 请求,但是因为没有数据,这个请求会被 leader 寄存,当在指定的时间之后会 强 制 完 成 请 秋 , 这 个 时 见 配 致 是(replica.fetch.wait.max.ms),如果在指定时间内 producer有消息发送过来,那么 kafka 会唤醒 fetch 请求,让 leader继续处理

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    这里会分两种情况,第一种是 leader 处理完 producer 请求之后,follower 发送一个 fetch 请求过来、第二种是follower 阻塞在 leader 指定时间之内,leader 副本收到producer 的请求。这两种情况下处理方式是不一样的。先来看第一种情况

    一、follower 的 fetch 请求是当 leader 处理消息以后执行的

    leader 处理完 producer 请求之后,follower 发送一个fetch 请求过来 。状态图如下

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    leader 副本收到请求以后,会做几件事情

    1. 把消息追加到 log 文件,同时更新 leader 副本的 LEO
    2. 尝试更新 leader HW 值。这个时候由于 follower 副本还没有发送 fetch 请求,那么 leader 的 remote LEO 仍然是 0。leader 会比较自己的 LEO 以及 remote LEO 的值发现最小值是 0,与 HW 的值相同,所以不会更新 HW

    follower fetch 消息

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入

    follower 发送 fetch 请求,leader 副本的处理逻辑是:

    1. 读取 log 数据、更新 remote LEO=0(follower 还没有写入这条消息,这个值是根据 follower 的 fetch 请求中的offset 来确定的)
    2. 尝试更新 HW,因为这个时候 LEO 和 remoteLEO 还是不一致,所以仍然是 HW=0
    3. 把消息内容和当前分区的 HW 只发送给 follower 副本follower 副本收到 response 以后
    4. 将消息写入到本地 log,同时更新 follower 的 LEO
    5. 更新 follower HW,本地的 LEO 和 leader 返回的 HW进行比较取小的值,所以仍然是 0第一次交互结束以后, HW 仍然还是 0,这个值会在下一次follower 发起 fetch 请求时被更新

    follower 发第二次 fetch 请求,leader 收到请求以后

    万字修行!消息中间件架构体系:Kafka研究,从入门到深入
    1. 读取 log 数据
    2. 更新 remote LEO=1, 因为这次 fetch 携带的 offset 是1.
    3. 更新当前分区的 HW,这个时候 leader LEO 和 remoteLEO 都是 1,所以 HW 的值也更新为 1
    4. 把数据和当前分区的 HW 值返回给 follower 副本,这个时候如果没有数据,则返回为空

    follower 副本收到 response 以后

    1. 如果有数据则写本地日志,并且更新 LEO
    2. 更新 follower 的 HW 值 到目前为止,数据的同步就完成了,意味着消费端能够消费 offset=0 这条消息。

    二、follower 的 fetch 请求是直接从阻塞过程中触发

    前面说过,由于 leader 副本暂时没有数据过来,所以follower 的 fetch 会被阻塞,直到等待超时或者 leader 接收到新的数据。当 leader 收到请求以后会唤醒处于阻塞的fetch 请求。处理过程基本上和前面说的一直

    1. leader 将消息写入本地日志,更新 Leader 的 LEO
    2. 唤醒 follower 的 fetch 请求
    3. 更新 HWkafka 使用 HW 和 LEO 的方式来实现副本数据的同步,本身是一个好的设计,但是在这个地方会存在一个数据丢失的问题,当然这个丢失只出现在特定的背景下。我们回想一下, HW 的值是在新的一轮 FETCH 中才会被更新。我们分析下这个过程为什么会出现数据丢失

    由于篇幅限制的原因,只能将文章展示到这里,希望可以对大家学习Kafka有帮助,喜欢的小伙伴可以帮忙转发+关注,感谢大家~

    相关文章

      网友评论

        本文标题:万字修行!消息中间件架构体系:Kafka研究,从入门到深入

        本文链接:https://www.haomeiwen.com/subject/anzqzktx.html