Kafka Broker(节点)

1.Kafka Broker 工作流程

1.Zookeeper 存储的 Kafka 信息

  1. /kafka/brokers/ids
    记录有哪些Kafka Broker服务器

  2. /kafka/brokers/topics/first/partitions/0/state
    记录每一个主题下的分区对应的Leader和ISR

  3. /kafka/consumers
    0.9版本之前用于保存offset信息,0.9版本之后offset存储在kafka主题中

  4. /kafka/controller
    辅助Leader选举

2. Kafka Broker 总体工作流程

  1. Kafka Broker启动后首先在Zookeeper中注册

  2. Kafka Broker抢占注册controller，谁先注册，谁说了算

  3. 由选举出来的Controller监听brokers节点变化

  4. Controller决定Leader选举
    选举规则：在isr中存活为前提，按照AR中排在前面的优先。例如ar[1,0,2], isr [1，0，2]，那么leader就会按照1，0，2的顺序轮询
    AR：Kafka分区中的所有副本统称

  5. Controller将节点信息上传到ZK

  6. 其他contorller从zk同步相关信息

  7. 假设Broker1中Leader挂了

  8. Controller监听到节点变化

  9. 获取ISR

  10. 选举新的Leader（在isr中存活为前提，按照AR中排在前面的优先）

  11. 更新Leader及ISR

3.Broker 重要参数

参数名称 描述
replica.lag.time.max.ms ISR 中，如果 Follower 长时间未向 Leader 发送通信请求或同步数据，则该 Follower 将被踢出 ISR。该时间阈值，默认 30s
auto.leader.rebalance.enable 默认是 true。 自动 Leader Partition 平衡
leader.imbalance.per.broker.percentage 默认是 10%。每个 broker 允许的不平衡的 leader的比率。如果每个 broker 超过了这个值，控制器会触发 leader 的平衡
leader.imbalance.check.interval.seconds 默认值 300 秒。检查 leader 负载是否平衡的间隔时间
log.segment.bytes Kafka 中 log 日志是分成一块块存储的，此配置是指 log 日志划分 成块的大小，默认值 1G。
log.index.interval.bytes 默认 4kb，kafka 里面每当写入了 4kb 大小的日志（.log），然后就往 index 文件里面记录一个索引
log.retention.hours Kafka 中数据保存的时间，默认 7 天
log.retention.minutes Kafka 中数据保存的时间，分钟级别，默认关闭
log.retention.ms Kafka 中数据保存的时间，毫秒级别，默认关闭
log.retention.check.interval.ms 检查数据是否保存超时的间隔，默认是 5 分钟
log.retention.bytes 默认等于-1，表示无穷大。超过设置的所有日志总大小，删除最早的 segment
log.cleanup.policy 默认是 delete，表示所有数据启用删除策略；如果设置值为 compact，表示所有数据启用压缩策略。
num.io.threads 默认是 8。负责写磁盘的线程数。整个参数值要占总核数的 50%
num.replica.fetchers 副本拉取线程数，这个参数占总核数的 50%的 1/3
num.network.threads 默认是 3。数据传输线程数，这个参数占总核数的50%的 2/3
log.flush.interval.messages 强制页缓存刷写到磁盘的条数，默认是 long 的最大值，9223372036854775807。一般不建议修改，交给系统自己管理
log.flush.interval.ms 每隔多久，刷数据到磁盘，默认是 null。一般不建议修改，交给系统自己管理。

2.生产经验——节点服役和退役

1.服役新节点

1.准备基础环境

  • 拷贝任意Kafka节点系统环境
    • 修改IP地址[略]
    • 修改hostname[略]
  • 准备全新环境的服务器
    • 配置静态IP地址[略]
    • 修改hostname[略]
    • 安装JDK[从已有节点拷贝JDK并配置环境变量]
    • 安装Zookeeper[从已有节点拷贝Zookeeper]

2.配置Zookeeper

  1. 配置当前Zookeeper服务器编号
  2. 修改Zookeeper配置文件zoo.cfg，添加 server.服务器编号=ip:2888:3888,并将配置文件同步到其他Zookeeper节点上。
  3. 启动Zookeeper集群

3.新节点配置Kafka

  1. 从已有节点拷贝Kafka并配置环境变量
  2. 在新节点上修改配置文件server.properties中的 broker.id及zookeeper.connect，在其他Kafka节点上同步修改zookeeper.connect信息。
  3. 删除 Kafka目录下的logs文件夹
  4. 删除 Kafka配置文件中log.dirs 指向的文件夹。此处为/usr/kafka/kafka_2.13-3.6.1/datas
  5. 启动新节点的Kafka

4.新节点不存在任何主题的数据，对已有主题从其他节点上负载均衡。

1.创建一个要均衡的主题
cat > /home/fanqi/topics-to-move.json << EOF
{
    "topics": [
        {
            "topic": "first"
        }
    ],
    "version": 1
}
EOF
2.生成一个负载均衡的计划
bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --topics-to-move-json-file /home/fanqi/topics-to-move.json --broker-list "0,1,2,3" --generate
3.创建副本存储计划（所有副本存储在 broker0、broker1、broker2、broker3 中）。

注意：此处文件的JSON内容为上面生成负载均衡计划后返回的JSON内容

cat > /home/fanqi/increase-replication-factor.json << EOF
{
    "version": 1,
    "partitions": [
        {
            "topic": "first",
            "partition": 0,
            "replicas": [
                2,
                3,
                0
            ],
            "log_dirs": [
                "any",
                "any",
                "any"
            ]
        },
        {
            "topic": "first",
            "partition": 1,
            "replicas": [
                3,
                0,
                1
            ],
            "log_dirs": [
                "any",
                "any",
                "any"
            ]
        },
        {
            "topic": "first",
            "partition": 2,
            "replicas": [
                0,
                1,
                2
            ],
            "log_dirs": [
                "any",
                "any",
                "any"
            ]
        }
    ]
}
EOF
4.执行副本存储计划
bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --execute
5.验证副本存储计划
bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --verify

2.退役旧节点

先生成执行计划后负载均衡将退役节点的数据进行剥离后然后将节点退出集群。

1.创建一个要均衡的主题

cat > /home/fanqi/topics-to-move.json << EOF
{
    "topics": [
        {
            "topic": "first"
        }
    ],
    "version": 1
}
EOF

2.生成一个负载均衡的计划

注：--broker-list的参数不要添加即将下线的kafka节点的broker.id

bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --topics-to-move-json-file /home/fanqi/topics-to-move.json --broker-list "0,1,2" --generate

3.创建副本存储计划（所有副本存储在 broker0、broker1、broker2 中）。

注意：此处文件的JSON内容为上面生成负载均衡计划后返回的JSON内容

cat > /home/fanqi/increase-replication-factor.json << EOF
{
    "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"
            ]
        }
    ]
}
EOF

4.执行副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --execute

5.验证副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --verify

6.在下线的Kafka节点上执行停止运行命令

bin/kafka-server-stop.sh

3.Kafka 副本

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 副本同步时，延迟过多的副本

2.Leader 选举流程

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

Controller 的信息同步工作是依赖于 Zookeeper 的。

3.Leader 和 Follower 故障处理细节

LEO（Log End Offset）：每个副本的最后一个offset，LEO其实就是最新的offset + 1

HW（High Watermark）：所有副本中最小的LEO

1.Follower故障处理细节

  1. Follower发生故障后会被临时踢出ISR
  2. 这个期间Leader和Follower继续接收数据
  3. 待该Follower恢复后，Follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分截取掉，从HW开始向Leader进行同步。
  4. 等该Follower的LEO大于等于该Partition的HW，即Follower追上Leader之后，就可以重新加入ISR了

2.Leader故障

  1. Leader发生故障之后，会从ISR中选出一个新的Leader
  2. 为保证多个副本之间的数据一致性，其余的Follower会先将各自的log文件高于HW的部分截掉，然后从新的Leader同步数据。

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

4.分区副本分配

均匀分布并保证数据的可靠。

5.生产经验——手动调整分区副本存储

在生产环境中，每台服务器的配置和性能不一致，但是Kafka只会根据自己的代码规则创建对应的分区副本，就会导致个别服务器存储压力较大。所有某些情况下需要手动调整分区副本的存储。

需求：创建一个新的topic，4个分区，两个副本，名称为three。将 该topic的所有副本都存储到broker0和broker1两台服务器上。

1.创建一个新的 topic，名称为 three。

bin/kafka-topics.sh --bootstrap-server 192.168.58.130:9092 --create --partitions 4 --replication-factor 2 --topic three

2.查看分区副本存储情况

bin/kafka-topics.sh --bootstrap-server 192.168.58.130:9092 --describe --topic three

3.创建副本存储计划（所有副本都指定存储在 broker0、broker1 中）。

cat > /home/fanqi/increase-replication-factor.json << EOF
{
    "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
            ]
        }
    ]
}
EOF

4.执行副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --execute

5.验证副本存储计划

bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --verify

6.查看分区副本存储情况

bin/kafka-topics.sh --bootstrap-server 192.168.58.130:9092 --describe --topic three

6.生产经验——Leader Partition 负载平衡

正常情况下，Kafka本身会自动把Leader Partition均匀分散在各个机器上，来保证每台机器的读写吞吐量都是均匀的。但是如果某些broker宕机，会导致Leader Partition过于集中在其他少部分几台broker上，这会导致少数几台broker的读写请求压力过高，其他宕机的broker重启之后都是follower partition，读写请求很低，造成集群负载不均衡。

  • auto.leader.rebalance.enable，默认是true。自动Leader Partition 平衡

  • leader.imbalance.per.broker.percentage，默认是10%。每个broker允许的不平衡的leader的比率。如果每个broker超过了这个值，控制器会触发leader的平衡。

  • leader.imbalance.check.interval.seconds，默认值300秒。检查leader负载是否平衡的间隔时间。

参数名称 描述
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 负载是否平衡的间隔时间。

7.生产经验——增加副本因子

在生产环境当中，由于某个主题的重要等级需要提升，我们考虑增加副本。副本数的增加需要先制定计划，然后根据计划执行。

1.创建 topic

bin/kafka-topics.sh --bootstrap-server 192.168.58.130:9092 --create --partitions 3 --replication-factor 1 --topic four

2.手动增加副本存储

1.创建副本存储计划（所有副本都指定存储在 broker0、broker1、broker2 中）。
cat > /home/fanqi/increase-replication-factor.json << EOF
{
    "version": 1,
    "partitions": [
        {
            "topic": "four",
            "partition": 0,
            "replicas": [
                0,
                1,
                2
            ]
        },
        {
            "topic": "four",
            "partition": 1,
            "replicas": [
                0,
                1,
                2
            ]
        },
        {
            "topic": "four",
            "partition": 2,
            "replicas": [
                0,
                1,
                2
            ]
        }
    ]
}
EOF
2.执行副本存储计划
bin/kafka-reassign-partitions.sh --bootstrap-server 192.168.58.130:9092 --reassignment-json-file /home/fanqi/increase-replication-factor.json --execute

4.文件存储

1.文件存储机制

1.Topic 数据的存储机制

Topic是逻辑上的概念，而partition是物理上的概念，每个partition对应于一个log文件，该log文件中存储的就是Producer生产的数据。Producer生产的数据会被不断追加到该log文件末端，为防止log文件过大导致数据定位效率低下，Kafka采取了分片和索引机制，将每个partition分为多个segment。每个segment包括：“.index”文件、“.log”文件和.timeindex等文件。这些文件位于一个文件夹下，该文件夹的命名规则为：topic名称+分区序号，例如：first-0。

  1. 一个topic分为多个partition
  2. 一个partition分为多个segment
  3. segment包含
    1. log 日志文件
    2. .index 偏移量索引文件
    3. .timeindex 时间戳索引文件
    4. 其他文件
  • 说明：index和log文件以当前segment的第一条消息的offset命名。

2.查看相关文件

1.启动生产者，发送消息
bin/kafka-console-producer.sh --bootstrap-server 192.168.58.130:9092 --topic first
2.查看存储的文件
cd /usr/kafka/kafka_2.13-3.6.1/datas/first-1
ls

直接查看相关的文件会发现乱码，因为文件内容是序列化后保存的，无法直接查看内容。

3.使用Kafka提供的工具查看文件内容
kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.index

kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.log

3.index 文件和 log 文件详解

如何在log文件中定位到offset=600的Record？

  1. 根据目标offset定位Segment文件
  2. 找到小于等于目标offset的最大offset对应的索引项
  3. 定位到log文件
  4. 向下遍历找到目标Record

注意：

  1. index为稀疏索引，大约每往log文件写入4kb数据，会往index文件写入一条索引。参数log.index.interval.bytes默认4kb。

  2. Index文件中保存的offset为相对offset，这样能确保offset的值所占空间不会过大，因此能将offset的值控制在固定大小

说明：日志存储参数配置

参数 描述
log.segment.bytes Kafka 中 log 日志是分成一块块存储的，此配置是指 log 日志划分成块的大小，默认值 1G。
log.index.interval.bytes 默认 4kb，kafka 里面每当写入了 4kb 大小的日志（.log），然后就往 index 文件里面记录一个索引。 稀疏索引。

2.文件清理策略

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

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

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

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

  • log.cleanup.policy = delete 所有数据启用删除策略
    1. 基于时间：默认打开。以 segment 中所有记录中的最大时间戳作为该文件时间戳。
    2. 基于大小：默认关闭。超过设置的所有日志总大小，删除最早的 segment。
      log.retention.bytes，默认等于-1，表示无穷大。

2.compact 日志压缩

对于相同key的不同value值，只保留最后一个版本。

  • log.cleanup.policy = compact 所有数据启用压缩策略

压缩后的offset可能是不连续的

这种策略只适合特殊场景，比如消息的key是用户ID，value是用户的资料，通过这种压缩策略，整个消息集里就保存了所有用户最新的资料。

5.高效读写数据

  1. Kafka 本身是分布式集群，可以采用分区技术，并行度高
  2. 读数据采用稀疏索引，可以快速定位要消费的数据
  3. 顺序写磁盘
    Kafka 的 producer 生产数据，要写入到 log 文件中，写的过程是一直追加到文件末端，为顺序写。官网有数据表明，同样的磁盘，顺序写能到 600M/s，而随机写只有 100K/s。这与磁盘的机械机构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。
  4. 页缓存 + 零拷贝技术
    零拷贝：Kafka的数据加工处理操作交由Kafka生产者和Kafka消费者处理。Kafka Broker应用层不关心存储的数据，所以就不用走应用层，传输效率高。
    PageCache页缓存：Kafka重度依赖底层操作系统提供的PageCache功 能。当上层有写操作时，操作系统只是将数据写入PageCache。当读操作发生时，先从PageCache中查找，如果找不到，再去磁盘中读取。实际上PageCache是把尽可能多的空闲内存都当做了磁盘缓存来使用。
参数 描述
log.flush.interval.messages 强制页缓存刷写到磁盘的条数，默认是 long 的最大值，9223372036854775807。一般不建议修改，交给系统自己管理。
log.flush.interval.ms 每隔多久，刷数据到磁盘，默认是 null。一般不建议修改，交给系统自己管理。
posted @ 2024-02-16 14:11  SpringCore  阅读(10)  评论(0)  编辑  收藏  举报