title: Kafka学习历程
date: 2023-04-17 18:51:01
tags: 大数据组件 Kafka 自学
Kafka 学习历程
第1章 Kafka概述
1.1 定义
企业使用Kafka,基本只是用于接收消息队列,基本不会使用Kafka进行流分析
1.2 消息队列
MQ(Massage Queue)信息中间件/信息队列
目前企业中比较常见的消息队列产品主要有Kafka、ActiveMQ、RabbitMQ、RocketMQ等。
在大数据场景主 要采用Kafka作为消息队列。在JavaEE开发中主要采用ActiveMQ、RabbitMQ、RocketMQ。
1.2.1 传统消息队列的应用场景
传统的消息队列的主要应用场景包括:缓存/消峰、解耦和异步通信。
不同的数据源分别存储进不同的消息队列,即可按需索取。如:MySQL在queue1,flume在queue2,网络端口数据在queue3。
可以将MQ看成一个超市,消费者只需要在货架上按需索取。
在同步处理中,一旦某一个环节出错,整个过程无法形成闭合。假设发送短信这一步,无法调用运营商的接口,发送不了短信,则就一直等待,直到短信发送成功才执行下一步。
在异步处理中,产生发送短信的请求后,便会响应完成注册。假设发送短信这一步,无法调用运营商的接口,发送不了短信,还是会显示完成注册,只不过发送短信的请求一直处于消息队列中,直到接口功能修复。
1.2.2 消息队列的两种模式
Kafka使用的是发布/订阅模式
1.3 Kafka基础架构
**(1)Producer:**消息生产者,就是向Kafka broker发消息的客户端。
**(2)Consumer:**消息消费者,向Kafka broker取消息的客户端。
**(3)Consumer Group(CG):**消费者组,由多个consumer组成。消费者组内每个消费者负责消费不同分区的数据,一个分区只能由一个组内消费者消费;消费者组之间互不影响。所有的消费者都属于某个消费者组,即消费者组是逻辑上的一个订阅者。
**(4)Broker:**一台Kafka服务器就是一个broker。一个集群由多个broker组成。一个broker可以容纳多个topic。
**(5)Topic:**可以理解为一个队列,生产者和消费者面向的都是一个topic。
**(6)Partition:**为了实现扩展性,一个非常大的topic可以分布到多个broker(即服务器)上,一个topic可以分为多个partition,每个partition是一个有序的队列。
(7)Replica:副本。一个topic的每个分区都有若干个副本,一个Leader和若干个Follower。
(8)Leader:每个分区多个副本的“主”,生产者发送数据的对象,以及消费者消费数据的对象都是Leader。
**(9)Follower:**每个分区多个副本中的“从”,实时从Leader中同步数据,保持和Leader数据的同步。Leader发生故障时,某个Follower会成为新的Leader。
注:partition(Leader)的数量和消费者组的consumer数量相同时,效率最高
第2章 Kafka快速入门
2.1 安装部署
2.1.1 集群规划
node02 | node03 | node04 |
---|---|---|
zk | zk | zk |
kafka | kafka | kafka |
2.1.2 集群部署
**0)**官方下载地址:http://kafka.apache.org/downloads.html
**1)**解压安装包
[hadoop@node02 software]$ tar -zxvf kafka_2.12-3.4.0.tgz -C /opt/module/
**2)**修改解压后的文件名称
[hadoop@node02 module]$ mv kafka_2.12-3.4.0/ kafka
使用Kafka主要使用这几个脚本命令。
**3)**进入到/opt/module/kafka目录,修改配置文件
[hadoop@node02 kafka]$ cd config/
[hadoop@node02 config]$ vim server.properties
输入以下内容:
#broker的全局唯一编号,不能重复,只能是数字。
broker.id=0
#处理网络请求的线程数量
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运行日志(数据)存放的路径,路径不需要提前创建,kafka自动帮你创建,可以配置多个磁盘路径,路径与路径之间可以用","分隔
log.dirs=/opt/module/kafka/datas
#topic在当前broker上的分区个数
num.partitions=1
#用来恢复和清理data下数据的线程数量
num.recovery.threads.per.data.dir=1
# 每个topic创建时的副本数,默认时1个副本
offsets.topic.replication.factor=1
#segment文件保留的最长时间,超时将被删除
log.retention.hours=168
#每个segment文件的大小,默认最大1G
log.segment.bytes=1073741824
# 检查过期数据的时间,默认5分钟检查一次是否数据过期
log.retention.check.interval.ms=300000
#配置连接Zookeeper集群地址(在zk根目录下创建/kafka,方便管理)
zookeeper.connect=node02:2181,node03:2181,node04:2181/kafka
4)分发安装包
[hadoop@node02 module]$ xsync kafka/
**5)**分别在node03和node04上修改配置文件/opt/module/kafka/config/server.properties中的broker.id=1、broker.id=2
注:broker.id不得重复,整个集群中唯一。
[hadoop@node03 module]$ vim kafka/config/server.properties
修改:
# The id of the broker. This must be set to a unique integer for each broker.
broker.id=1
[hadoop@node04 module]$ vim kafka/config/server.properties
修改:
# The id of the broker. This must be set to a unique integer for each broker.
broker.id=2
6)配置环境变量
(1)在/etc/profile.d/my_env.sh文件中增加kafka环境变量配置
[hadoop@node02 module]$ sudo vim /etc/profile.d/my_env.sh
增加如下内容:
#KAFKA_HOME
export KAFKA_HOME=/opt/module/kafka
export PATH=$PATH:$KAFKA_HOME/bin
(2)刷新一下环境变量。
[hadoop@node02 module]$ source /etc/profile
(3)分发环境变量文件到其他节点,并source。
[hadoop@node02 module]$ sudo /home/hadoop/bin/xsync /etc/profile.d/my_env.sh
[hadoop@node03 module]$ source /etc/profile
[hadoop@node04 module]$ source /etc/profile
7)启动集群
(1)先启动Zookeeper集群,然后启动Kafka。
[hadoop@node02 kafka]$ zk.sh start
(2)依次在node02、node03、node04节点上启动Kafka。
[hadoop@node02 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[hadoop@node03 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[hadoop@node04 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
注意:配置文件的路径要能够到server.properties。
8)关闭集群
[hadoop@node02 kafka]$ bin/kafka-server-stop.sh
[hadoop@node03 kafka]$ bin/kafka-server-stop.sh
[hadoop@node04 kafka]$ bin/kafka-server-stop.sh
2.1.3 集群启停脚本
1)在/home/hadoop/bin目录下创建文件kf.sh脚本文件
[hadoop@node02 bin]$ vim kf.sh
脚本如下:
#! /bin/bash
case $1 in
"start"){
for i in node02 node03 node04
do
echo " --------启动 $i Kafka-------"
ssh $i "/opt/module/kafka/bin/kafka-server-start.sh -daemon /opt/module/kafka/config/server.properties"
done
};;
"stop"){
for i in node02 node03 node04
do
echo " --------停止 $i Kafka-------"
ssh $i "/opt/module/kafka/bin/kafka-server-stop.sh "
done
};;
esac
2)添加执行权限
[hadoop@node02 bin]$ chmod +x kf.sh
3)启动集群命令
[hadoop@node02 ~]$ kf.sh start
4)停止集群命令
[hadoop@node02 ~]$ kf.sh stop
**注意:**停止Kafka集群时,一定要等Kafka所有节点进程全部停止后再停止Zookeeper集群。因为Zookeeper集群当中记录着Kafka集群相关信息,Zookeeper集群一旦先停止,Kafka集群就没有办法再获取停止进程的信息,只能手动杀死Kafka进程了。
2.2 Kafka命令行操作
2.2.1 主题命令行操作
1)查看操作主题命令参数
[hadoop@node02 kafka]$ bin/kafka-topics.sh
参数 | 描述 |
---|---|
–bootstrap-server <String: server toconnect to> | 连接的Kafka Broker主机名称和端口号。 |
–topic <String: topic> | 操作的topic名称。 |
–create | 创建主题。 |
–delete | 删除主题。 |
–alter | 修改主题。 |
–list | 查看所有主题。 |
–describe | 查看主题详细描述。 |
–partitions <Integer: # of partitions> | 设置分区数。 |
–replication-factor<Integer: replication factor> | 设置分区副本。 |
–config <String: name=value> | 更新系统默认的配置。 |
2)查看当前服务器中的所有topic
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --list
注意:假设node02:9092可用,只写node02:9092这个节点端口,kafka就会自动寻找集群的其它节点端口。也可以将集群所有节点都写上,但没必要。
3)创建first topic
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --create --partitions 1 --replication-factor 3 --topic first
选项说明:
–topic 定义topic名
–replication-factor 定义副本数
–partitions 定义分区数
4)查看first主题的详情
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic first
5)修改分区数(注意:分区数只能增加,不能减少)
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --alter --topic first --partitions 3
6)再次查看first主题的详情
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic first
7)删除topic
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --delete --topic first
Kafka可以修改replication副本数,但是需要执行一个.json格式的修改计划。
详细操作可以查阅此文章:kafka手动调整分区副本数的操作步骤_java_脚本之家 (jb51.net)
有一个需要注意的地方是,随着Kafka版本的升级,命令的格式也变化了
--zookeeper
#要改成
--bootst
2.2.2 生产者命令行操作
1)查看操作生产者命令参数
[hadoop@node02 kafka]$ bin/kafka-console-producer.sh
参数 | 描述 |
---|---|
–bootstrap-server <String: server toconnect to> | 连接的Kafka Broker主机名称和端口号。 |
–topic <String: topic> | 操作的topic名称。 |
2)发送消息
[hadoop@node02 kafka]$ bin/kafka-console-producer.sh --bootstrap-server node02:9092 --topic first
>hello world
>jason jason
2.2.3 消费者命令行操作
1)查看操作消费者命令参数
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh
参数 | 描述 |
---|---|
–bootstrap-server <String: server toconnect to> | 连接的Kafka Broker主机名称和端口号。 |
–topic <String: topic> | 操作的topic名称。 |
–from-beginning | 从头开始消费。 |
–group <String: consumer group id> | 指定消费者组名称。 |
2)消费消息
(1)消费first主题中的数据。
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
(2)把主题中所有的数据都读取出来(包括历史数据)。
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --from-beginning --topic first
(3)从消费者组中读取信息
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first --group first
当消费者断开后,再重连消费者,消费者组无需从最开始重新读取数据,而是从断点处开始读出数据,也叫偏移量。
第3章 Kafka生产者
3.1 生产者消息发送流程
3.1.1 发送原理
在消息发送的过程中,涉及到了两个线程——main线程和Sender线程。在main线程中创建了一个双端队列RecordAccumulator。main线程将消息发送给RecordAccumulator,Sender线程不断从RecordAccumulator中拉取消息发送到Kafka Broker。
3.1.2 生产者重要参数列表
参数名称 | 描述 |
---|---|
bootstrap.servers | 生产者连接集群所需的broker地址清单。例如node02:9092,node03:9092,node04:9092,可以设置1个或者多个,中间用逗号隔开。注意这里并非需要所有的broker地址,因为生产者从给定的broker里查找到其他broker信息。 |
key.serializer和value.serializer | 指定发送消息的key和value的序列化类型。一定要写全类名。 |
buffer.memory | RecordAccumulator缓冲区总大小,默认32m。 |
batch.size | 缓冲区一批数据最大值,默认16k。适当增加该值,可以提高吞吐量,但是如果该值设置太大,会导致数据传输延迟增加。 |
linger.ms | 如果数据迟迟未达到batch.size,sender等待linger.time之后就会发送数据。单位ms,默认值是0ms,表示没有延迟。生产环境建议该值大小为5-100ms之间。 |
acks | 0:生产者发送过来的数据,不需要等数据落盘应答。 1:生产者发送过来的数据,Leader收到数据后应答。 -1(all):生产者发送过来的数据,Leader+和isr队列里面的所有节点收齐数据后应答。默认值是-1,-1和all是等价的。 |
max.in.flight.requests.per.connection | 允许最多没有返回ack的次数,默认为5,开启幂等性要保证该值是 1-5的数字。 |
retries | 当消息发送出现错误的时候,系统会重发消息。retries表示重试次数。默认是int最大值,2147483647。 如果设置了重试,还想保证消息的有序性,需要设置 MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候,其他的消息可能发送成功了。 |
retry.backoff.ms | 两次重试之间的时间间隔,默认是100ms。 |
enable.idempotence | 是否开启幂等性,默认true,开启幂等性。 |
compression.type | 生产者发送的所有数据的压缩方式。默认是none,也就是不压缩。 支持压缩类型:none、gzip、snappy、lz4和zstd。 |
3.2 异步发送API
3.2.1 普通异步发送(Kafka默认)
异步发送的吞吐量比同步发送的吞吐量大,异步发送更适合生产环境。
1)需求:创建Kafka生产者,采用异步的方式发送到Kafka Broker
2)代码编写
(1)创建工程kafka
(2)导入依赖
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
(3)创建包名:com.jason.kafka.producer
(4)编写不带回调函数的API代码
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducer {
public static void main(String[] args) {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node03:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
producer.send(new ProducerRecord<String, String>("first","Jason----" + i));
}
// 4 关闭资源
producer.close();
}
}
测试:
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA中执行代码,观察node02控制台中是否接收到消息。
3.2.2 带回调函数的异步发送
回调函数会在producer收到ack时调用,为异步调用,该方法有两个参数,分别是元数据信息(RecordMetadata)和异常信息(Exception),如果Exception为null,说明消息发送成功,如果Exception不为null,说明消息发送失败。
注意:消息发送失败会自动重试,不需要我们在回调函数中手动重试。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerCallback {
public static void main(String[] args) throws InterruptedException {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
producer.send(new ProducerRecord<String, String>("first", "Jason----" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
}
else {
// 出现异常打印
e.printStackTrace();
}
}
});
// 延迟数据发送,查看数据发送到哪些分区
Thread.sleep(2);
}
// 4 关闭资源
producer.close();
}
}
测试:
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA中执行代码,观察node02控制台中是否接收到消息。
③在IDEA控制台观察回调信息。
3.3 同步发送API
只需在异步发送的基础上,再调用一下get()方法即可。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerSync {
public static void main(String[] args) {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
// 异步
// for (int i = 0; i < 10; i++) {
// producer.send(new ProducerRecord<String, String>("first","Jason----" + i));
// }
// 同步
for (int i = 0; i < 10; i++) {
try {
producer.send(new ProducerRecord<String, String>("first","Jason----" + i)).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
// 4 关闭资源
producer.close();
}
}
测试:
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA中执行代码,观察node02控制台中是否接收到消息。
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
3.4 生产者分区
3.4.1 分区好处
3.4.2 生产者发送消息的分区策略
1)默认的分区器 DefaultPartitioner
在IDEA中ctrl + n,全局查找DefaultPartitioner。
/**
\* The default partitioning strategy:
\* <ul>
\* <li>If a partition is specified in the record, use it
\* <li>If no partition is specified but a key is present choose a partition based on a hash of the key
\* <li>If no partition or key is present choose the sticky partition that changes when the batch is full.
\*
\* See KIP-480 for details about sticky partitioning.
*/
public class DefaultPartitioner implements Partitioner {
… …
}
2)案例一
将数据发往指定partition的情况下,例如,将所有数据发往分区1中。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerCallback {
public static void main(String[] args) throws InterruptedException {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
// 分区为 1 ,key为null
producer.send(new ProducerRecord<String, String>("first",1,null, "Jason----" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
}
else {
// 出现异常打印
e.printStackTrace();
}
}
});
// 延迟数据发送,查看数据发送到哪些分区
Thread.sleep(2);
}
// 4 关闭资源
producer.close();
}
}
测试:
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA中执行代码,观察node02控制台中是否接收到消息。
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
③在IDEA控制台观察回调信息。
3)案例二
没有指明partition值但有key的情况下,将key的hash值与topic的partition数进行取余得到partition值。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerCallback {
public static void main(String[] args) throws InterruptedException {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
producer.send(new ProducerRecord<String, String>("first","a", "Jason----" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
}
else {
// 出现异常打印
e.printStackTrace();
}
}
});
// 延迟数据发送,查看数据发送到哪些分区
Thread.sleep(200);
}
// 4 关闭资源
producer.close();
}
}
测试:
①key="a"时,在控制台查看结果。
②key="b"时,在控制台查看结果。
③key="f"时,在控制台查看结果。
3.4.3 自定义分区器
如果研发人员可以根据企业需求,自己重新实现分区器。
1)需求
例如我们实现一个分区器实现,发送过来的数据中如果包含jason,就发往0号分区,不包含jason,就发往1号分区。
2)实现步骤
(1)定义类实现Partitioner接口。
(2)重写partition()方法。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class MyPartitioner implements Partitioner {
// 主要是修改这个方法
public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
// 若value包含Jason则分到0分区,否则分到1分区
String s1 = value.toString();
if (s1.contains("Jason")){
return 0;
}
else return 1;
}
public void close() {
}
public void configure(Map<String, ?> map) {
}
}
(3)使用分区器的方法,在生产者的配置中添加分区器参数。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerCallback {
public static void main(String[] args) throws InterruptedException {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 自定义分区器
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
if (i % 2 != 0) {
producer.send(new ProducerRecord<String, String>("first", "hahaha---" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
} else {
// 出现异常打印
e.printStackTrace();
}
}
});
} else {
producer.send(new ProducerRecord<String, String>("first", "Jason----" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
} else {
// 出现异常打印
e.printStackTrace();
}
}
});
}
}
// 4 关闭资源
producer.close();
}
}
(4)测试
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA控制台观察回调信息。
3.5 生产经验——生产者如何提高吞吐量
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducerConfig {
public static void main(String[] args) throws InterruptedException {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 自定义分区器
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, MyPartitioner.class.getName());
// 自定义配置信息
//batch.size:批次大小,默认16k
properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
//linger.ms:等待时间,默认0
properties.put(ProducerConfig.LINGER_MS_CONFIG,5);
//compressing.type:压缩类型,默认none
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");
// RecordAccumulator:缓冲区大小,默认32M:buffer.memory
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 10; i++) {
producer.send(new ProducerRecord<String, String>("first", "Jason----" + i), new Callback() {
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "分区:" + recordMetadata.partition());
} else {
// 出现异常打印
e.printStackTrace();
}
}
});
}
// 4 关闭资源
producer.close();
}
}
测试:
①在node02上开启Kafka消费者。
[hadoop@node03 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic first
②在IDEA中执行代码,观察node02控制台中是否接收到消息。
3.6 生产经验——数据可靠性
0)回顾发送流程
1)ack应答原理
2)代码配置
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomProducerAck {
public static void main(String[] args) throws InterruptedException {
// 1. 创建kafka生产者的配置对象
Properties properties = new Properties();
// 2. 给kafka配置对象添加配置信息:bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "node02:9092");
// key,value序列化(必须):key.serializer,value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// 设置acks
properties.put(ProducerConfig.ACKS_CONFIG, "all");
// 重试次数retries,默认是int最大值,2147483647
properties.put(ProducerConfig.RETRIES_CONFIG, 3);
// 3. 创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
// 4. 调用send方法,发送消息
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first","jason " + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}
3.7 生产经验——数据去重
3.7.1 数据传递语义
3.7.2 幂等性
1)幂等性原理
2)如何使用幂等性
开启参数enable.idempotence 默认为true,false关闭。
3.7.3 生产者事务
1)Kafka事务介绍
0.11版本的Kafka同时引入了事务的特性,为了实现跨分区跨会话的事务,需要引入一个全局唯一的Transaction ID,并将Producer获得的PID和Transaction ID绑定。这样当Producer重启后就可以通过正在进行的Transaction ID获得原来的PID。
为了管理Transaction,Kafka引入了一个新的组件Transaction Coordinator。Producer就是通过和Transaction Coordinator交互获得Transaction ID对应的任务状态。Transaction Coordinator还负责将事务所有写入Kafka的一个内部Topic,这样即使整个服务重启,由于事务状态得到保存,进行中的事务状态可以得到恢复,从而继续进行。
注意:提前开启幂等性!!!
3.8 生产经验——数据有序
3.9 生产经验——数据乱序
第4章 Kafka Broker
4.1 Kafka Broker工作流程
4.1.1 Zookeeper存储的Kafka信息
(1)启动Zookeeper客户端。
[hadoop@node02 zookeeper-3.5.7]$ bin/zkCli.sh
(2)通过ls命令可以查看kafka相关信息。
[zk: localhost:2181(CONNECTED) 0] ls /kafka
4.1.2 Kafka Broker总体工作流程
模拟Kafka上下线,Zookeeper中数据变化
(1)查看/kafka/brokers/ids路径上的节点。
[zk: localhost:2181(CONNECTED) 0] ls /kafka/brokers/ids
(2)查看/kafka/controller路径上的数据。
[zk: localhost:2181(CONNECTED) 2] get /kafka/controller
(3)查看/kafka/brokers/topics/first/partitions/0/state路径上的数据。
[zk: localhost:2181(CONNECTED) 10] get /kafka/brokers/topics/first/partitions/0/state
(4)停止node04上的kafka。
[hadoop@node04 kafka]$ bin/kafka-server-stop.sh
(5)再次查看/kafka/brokers/ids路径上的节点。
[zk: localhost:2181(CONNECTED) 11] ls /kafka/brokers/ids
(6)再次查看/kafka/controller路径上的数据。
[zk: localhost:2181(CONNECTED) 12] get /kafka/controller
(7)再次查看/kafka/brokers/topics/first/partitions/0/state路径上的数据。
[zk: localhost:2181(CONNECTED) 13] get /kafka/brokers/topics/first/partitions/0/state
(8)启动node04上的kafka。
[hadoop@node04 kafka]$ bin/kafka-server-start.sh -daemon ./config/server.properties
(9)再次观察(1)、(2)、(3)步骤中的内容。
查看ar队列
[zk: localhost:2181(CONNECTED) 15] get /kafka/brokers/topics/first
4.1.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。一般不建议修改,交给系统自己管理。 |
4.2 Kafka 副本
4.2.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副本同步时,延迟过多的副本。
4.2.2 Leader选举流程
Kafka集群中有一个broker的Controller会被选举为Controller Leader,负责管理集群broker的上下线,所有topic的分区副本分配和Leader选举等工作。
Controller的信息同步工作是依赖于Zookeeper的。
假设有node02、node03、node04等3台服务器。
(1)创建一个新的topic,3个分区,3个副本
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --create --topic jason1 --partitions 3 --replication-factor 3
Created topic jason1.
(2)查看Leader分布情况
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic jason1
(3)停止掉node04的kafka进程,并查看Leader分区情况
[hadoop@node04 kafka]$ bin/kafka-server-stop.sh
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic jason1
(4)停止掉node03的kafka进程,并查看Leader分区情况
[hadoop@node03 kafka]$ bin/kafka-server-stop.sh
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic jason1
(5)启动node04的kafka进程,并查看Leader分区情况
[hadoop@node04 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic jason1
(6)启动node03的kafka进程,并查看Leader分区情况
[hadoop@node03 kafka]$ bin/kafka-server-start.sh -daemon config/server.properties
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --describe --topic jason1
4.2.3 Leader和Follower故障处理细节
4.3 文件存储
4.3.1 文件存储机制
1)Topic数据的存储机制
2)思考:Topic数据到底存储在什么位置?
(1)启动生产者,并发送消息。
[hadoop@node02 kafka]$ bin/kafka-console-producer.sh --bootstrap-server node02:9092 --topic first
>hello world
(2)查看node02(或者node03、node04)的/opt/module/kafka/datas/first-1(first-0、first-2)路径上的文件。
[hadoop@node02 first-1]$ ll
(3)直接查看log日志,发现是乱码。
[hadoop@node02 first-1]$ cat 00000000000000000002.log
(4)通过工具查看index和log信息。
[hadoop@node02 first-1]$ kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000002.log
(5)查看每一条offset的详细信息
[hadoop@node02 first-1]$ kafka-run-class.sh kafka.tools.DumpLogSegments --print-data-log --files ./00000000000000000002.log
3)index文件和log文件详解
说明:日志存储参数配置
参数 | 描述 |
---|---|
log.segment.bytes | Kafka中log日志是分成一块块存储的,此配置是指log日志划分 成块的大小,默认值1G。 |
log.index.interval.bytes | 默认4kb,kafka里面每当写入了4kb大小的日志(.log),然后就往index文件里面记录一个索引。 稀疏索引。 |
4.3.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,表示无穷大。
**思考:**如果一个segment中有一部分数据过期,一部分没有过期,怎么处理?
解答:在delete策略中,以segment中所有记录中的最大时间戳作为该文件时间戳,new部分的时间戳比old部分的时间戳大,会以new的时间戳为准,即segment2不会被删除,当最大时间戳超过7天,整个segment2才会被删除。
2)compact日志压缩
4.4 高效读写数据
1)Kafka本身是分布式集群,可以采用分区技术,并行度高
2)读数据采用稀疏索引,可以快速定位要消费的数据
3)顺序写磁盘
Kafka的producer生产数据,要写入到log文件中,写的过程是一直追加到文件末端,为顺序写。官网有数据表明,同样的磁盘,顺序写能到600M/s,而随机写只有100K/s。这与磁盘的机械机构有关,顺序写之所以快,是因为其省去了大量磁头寻址的时间。
4)页缓存 + 零拷贝技术
参数 | 描述 |
---|---|
log.flush.interval.messages | 强制页缓存刷写到磁盘的条数,默认是long的最大值,9223372036854775807。一般不建议修改,交给系统自己管理。 |
log.flush.interval.ms | 每隔多久,刷数据到磁盘,默认是null。一般不建议修改,交给系统自己管理。 |
第5章 Kafka消费者
5.1 Kafka消费方式
5.2 Kafka消费者工作流程
5.2.1 消费者总体工作流程
5.2.2 消费者组原理
5.2.3 消费者重要参数
参数名称 | 描述 |
---|---|
bootstrap.servers | 向Kafka集群建立初始连接用到的host/port列表。 |
key.deserializer和value.deserializer | 指定接收消息的key和value的反序列化类型。一定要写全类名。 |
group.id | 标记消费者所属的消费者组。 |
enable.auto.commit | 默认值为true,消费者会自动周期性地向服务器提交偏移量。 |
auto.commit.interval.ms | 如果设置了 enable.auto.commit 的值为true, 则该值定义了消费者偏移量向Kafka提交的频率,默认5s。 |
auto.offset.reset | 当Kafka中没有初始偏移量或当前偏移量在服务器中不存在(如,数据被删除了),该如何处理? earliest:自动重置偏移量到最早的偏移量。 latest:默认,自动重置偏移量为最新的偏移量。 none:如果消费组原来的(previous)偏移量不存在,则向消费者抛异常。 anything:向消费者抛异常。 |
offsets.topic.num.partitions | __consumer_offsets的分区数,默认是50个分区。 |
heartbeat.interval.ms | Kafka消费者和coordinator之间的心跳时间,默认3s。 该条目的值必须小于 session.timeout.ms ,也不应该高于 session.timeout.ms 的1/3。 |
session.timeout.ms | Kafka消费者和coordinator之间连接超时时间,默认45s。超过该值,该消费者被移除,消费者组执行再平衡。 |
max.poll.interval.ms | 消费者处理消息的最大时长,默认是5分钟。超过该值,该消费者被移除,消费者组执行再平衡。 |
fetch.min.bytes | 默认1个字节。消费者获取服务器端一批消息最小的字节数。 |
fetch.max.wait.ms | 默认500ms。如果没有从服务器端获取到一批数据的最小字节数。该时间到,仍然会返回数据。 |
fetch.max.bytes | 默认Default: 52428800(50 m)。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值(50m)仍然可以拉取回来这批数据,因此,这不是一个绝对最大值。一批次的大小受message.max.bytes (broker config)or max.message.bytes (topic config)影响。 |
max.poll.records | 一次poll拉取数据返回消息的最大条数,默认是500条。 |
5.3 消费者API
5.3.1 独立消费者案例(订阅主题)
1)需求:
创建一个独立消费者,消费first主题中数据。
**注意:**在消费者API代码中必须配置消费者组id。命令行启动消费者不填写消费者组id会被自动填写随机的消费者组id。
2)实现步骤
(1)创建包名:com.jason.kafka.consumer
(2)编写代码
package com.jason.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.serialization.StringDeserializer;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/12
* @package_name com.jason.kafka.consumer
*/
public class CustomConsumer {
public static void main(String[] args) {
// 1 封装消费者配置参数
Properties properties = new Properties();
// 连接Kafka集群
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node02:9092");
// key value 的反序列化
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
// 消费者组id
properties.put(ConsumerConfig.GROUP_ID_CONFIG,"first");
// 2 创建消费者对象
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);
// 3 指定消费者topic
ArrayList<String> topics = new ArrayList<String>();
topics.add("first");
kafkaConsumer.subscribe(topics);
// 4 消费者主动拉取数据
while (true){
ConsumerRecords<String, String> poll = kafkaConsumer.poll(Duration.ofSeconds(1));
for (ConsumerRecord<String, String> stringStringConsumerRecord : poll) {
System.out.println(stringStringConsumerRecord);
}
}
}
}
3)测试
(1)在IDEA中执行消费者程序。
(2)在Kafka集群控制台,创建Kafka生产者,并输入数据。
[hadoop@node02 kafka]$ bin/kafka-console-producer.sh --bootstrap-server node02:9092 --topic first
>hello
(3)在IDEA控制台观察接收到的数据。
ConsumerRecord(topic = first, partition = 1, leaderEpoch = 28, offset = 65, CreateTime = 1683883375480, serialized key size = -1, serialized value size = 5, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = hello)
5.3.2 消费者组案例
1)需求:测试同一个主题的分区数据,只能由一个消费者组中的一个消费。
2)案例实操
(1)复制一份基础消费者的代码,在IDEA中同时启动,即可启动同一个消费者组中的两个消费者。
(2)启动代码中的生产者(可以使用带回调的生产者查看分区)发送消息,在IDEA控制台即可看到两个消费者在消费不同分区的数据(如果只发生到一个分区,可以在发送时增加延迟代码Thread.sleep(2);)。
通过以上控制台得到的数据可以看出,消费者组中的每一个消费者都只消费一个分区的内容。
(3)重新发送到一个全新的主题中,由于默认创建的主题分区数为1,可以看到只能有一个消费者消费到数据。
5.4 生产经验——分区的分配以及再平衡
参数名称 | 描述 |
---|---|
heartbeat.interval.ms | Kafka消费者和coordinator之间的心跳时间,默认3s。 该条目的值必须小于 session.timeout.ms,也不应该高于 session.timeout.ms 的1/3。 |
session.timeout.ms | Kafka消费者和coordinator之间连接超时时间,默认45s。超过该值,该消费者被移除,消费者组执行再平衡。 |
max.poll.interval.ms | 消费者处理消息的最大时长,默认是5分钟。超过该值,该消费者被移除,消费者组执行再平衡。 |
partition.assignment.strategy | 消费者分区分配策略,默认策略是Range + CooperativeSticky。Kafka可以同时使用多个分区分配策略。可以选择的策略包括:Range、RoundRobin、Sticky、CooperativeSticky |
5.4.1 Range以及再平衡
1)Range分区策略原理
2)Range分区分配策略案例
(1)修改主题first为7个分区。
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --alter --topic first --partitions 7
注意:分区数可以增加,但是不能减少。
(2)复制CustomConsumer类,创建CustomConsumer2。这样可以由三个消费者CustomConsumer、CustomConsumer1、CustomConsumer2组成消费者组,组名都为“test”,同时启动3个消费者。
(3)启动CustomProducer生产者,发送7条消息,随机发送到不同的分区。
package com.jason.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/6
* @package_name com.jason.kafka.producer
*/
public class CustomerProducer {
public static void main(String[] args) {
// 1 设置生产者参数
Properties properties = new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"node02:9092");
// 配置key和value的序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
//或者可以这样写
// properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StraingSerializer.class.getName());
// 2 创建生产者对象
KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
// 3 发送数据
for (int i = 0; i < 7; i++) {
producer.send(new ProducerRecord<String, String>("first",i,"","Jason----" + i));
}
// 4 关闭资源
producer.close();
}
}
说明:Kafka默认的分区分配策略就是Range + CooperativeSticky,所以不需要修改策略。
(4)观看3个消费者分别消费哪些分区的数据。
3)Range分区分配再平衡案例
(1)停止掉2号消费者,快速重新发送消息观看结果(45s以内,越快越好)。
0号消费者:消费到3、4号分区数据。
1号消费者:消费到5、6号分区数据。
2号消费者的任务会整体被分配到0号消费者或者1号消费者。
说明:2号消费者挂掉后,消费者组需要按照超时时间45s来判断它是否退出,所以需要等待,时间到了45s后,判断它真的退出就会把任务分配给其他broker执行。
(2)再次重新发送消息观看结果(45s以后)。
0号消费者:消费到0、1、2、3号分区数据。
1号消费者:消费到4、5、6号分区数据。
说明:消费者2已经被踢出消费者组,所以重新按照range方式分配。
5.4.2 RoundRobin以及再平衡
1)RoundRobin分区策略原理
2)RoundRobin分区分配策略案例(轮巡策略)
(1)依次在CustomConsumer、CustomConsumer1、CustomConsumer2三个消费者代码中修改分区分配策略为RoundRobin。
// 修改分区分配策略
properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, "org.apache.kafka.clients.consumer.RoundRobinAssignor");
或者可以这样写
properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, RoundRobinAssignor.class.getName());
(2)重启3个消费者,重复发送消息的步骤,观看分区结果。
3)RoundRobin分区分配再平衡案例
(1)停止掉0号消费者,快速重新发送消息观看结果(45s以内,越快越好)。
1号消费者:消费到2、5号分区数据
2号消费者:消费到4、1号分区数据
0号消费者的任务会按照RoundRobin的方式,把数据轮询分成0 、6和3号分区数据,分别由1号消费者或者2号消费者消费。
说明:0号消费者挂掉后,消费者组需要按照超时时间45s来判断它是否退出,所以需要等待,时间到了45s后,判断它真的退出就会把任务分配给其他broker执行。
(2)再次重新发送消息观看结果(45s以后)。
1号消费者:消费到0、2、4、6号分区数据
2号消费者:消费到1、3、5号分区数据
说明:消费者0已经被踢出消费者组,所以重新按照RoundRobin方式分配。
5.4.3 Sticky以及再平衡
**粘性分区定义:**可以理解为分配的结果带有“粘性的”。即在执行一次新的分配之前,考虑上一次分配的结果,尽量少的调整分配的变动,可以节省大量的开销。
粘性分区是Kafka从0.11.x版本开始引入这种分配策略,首先会尽量均衡的放置分区到消费者上面,在出现同一消费者组内消费者出现问题的时候,会尽量保持原有分配的分区不变化。
1)需求
设置主题为first,7个分区;准备3个消费者,采用粘性分区策略,并进行消费,观察消费分配情况。然后再停止其中一个消费者,再次观察消费分配情况。
2)步骤
(1)修改分区分配策略为粘性。
注意:3个消费者都应该注释掉,之后重启3个消费者,如果出现报错,全部停止等会再重启,或者修改为全新的消费者组。
// 修改分区分配策略
ArrayList<String> startegys = new ArrayList<>();
startegys.add("org.apache.kafka.clients.consumer.StickyAssignor");
properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, startegys);
(2)使用同样的生产者发送7条消息。
可以看到会尽量保持分区的个数近似划分分区。
3)Sticky分区分配再平衡案例
(1)停止掉0号消费者,快速重新发送消息观看结果(45s以内,越快越好)。
1号消费者:消费到4、5号分区数据。
2号消费者:消费到3、6号分区数据。
0号消费者的任务会按照粘性规则,尽可能均衡的随机分成0和1号分区数据,分别由1号消费者或者2号消费者消费。
说明:0号消费者挂掉后,消费者组需要按照超时时间45s来判断它是否退出,所以需要等待,时间到了45s后,判断它真的退出就会把任务分配给其他broker执行。
(2)再次重新发送消息观看结果(45s以后)。
1号消费者:消费到0、2、4、5号分区数据。
2号消费者:消费到1、3、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+分区号就保留最新数据。
1)消费offset案例
(0)思想:__consumer_offsets为Kafka中的topic,那就可以通过消费者进行消费。
(1)在配置文件config/consumer.properties中添加配置exclude.internal.topics=false,默认是true,表示不能消费系统主题。为了查看该系统主题数据,所以该参数修改为false。
(2)采用命令行方式,创建一个新的topic。
[hadoop@node02 kafka]$ bin/kafka-topics.sh --bootstrap-server node02:9092 --create --topic jason --partitions 2 --replication-factor 2
(3)启动生产者往jason生产数据。
[hadoop@node02 kafka]$ bin/kafka-console-producer.sh --topic jason --bootstrap-server node02:9092
(4)启动消费者消费jason数据。
[hadoop@node04 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server node02:9092 --topic jason --group test
注意:指定消费者组名称,更好观察数据存储位置(key是group.id + topic + 分区号)。
(5)查看消费者消费主题__consumer_offsets。
[hadoop@node02 kafka]$ bin/kafka-console-consumer.sh --topic __consumer_offsets --bootstrap-server node02:9092 --consumer.config config/consumer.properties --formatter "kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter" --from-beginning
5.5.2 自动提交offset
参数名称 | 描述 |
---|---|
enable.auto.commit | 默认值为true,消费者会自动周期性地向服务器提交偏移量。 |
auto.commit.interval.ms | 如果设置了 enable.auto.commit 的值为true, 则该值定义了消费者偏移量向Kafka提交的频率,默认5s。 |
1)消费者自动提交offset
// offset提交策略
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true);
properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,5000);
5.5.3 手动提交offset
1)同步提交offset
由于同步提交offset有失败重试机制,故更加可靠,但是由于一直等待提交结果,提交的效率比较低。以下为同步提交offset的示例。
package com.jason.kafka.consumer;
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/12
* @package_name com.jason.kafka.consumer
*/
public class CustomConsumer1 {
public static void main(String[] args) {
// 1 封装消费者配置参数
Properties properties = new Properties();
// 连接Kafka集群
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node02:9092");
// key value 的反序列化
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
// 消费者组id
properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test1");
// 修改分区策略
properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, StickyAssignor.class.getName());
// offset 提交策略
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false); //先将offset自动提交关闭
// 2 创建消费者对象
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);
// 3 指定消费者topic
ArrayList<String> topics = new ArrayList<String>();
topics.add("first");
kafkaConsumer.subscribe(topics);
// 4 消费者主动拉取数据
while (true){
ConsumerRecords<String, String> poll = kafkaConsumer.poll(Duration.ofSeconds(1));
for (ConsumerRecord<String, String> stringStringConsumerRecord : poll) {
System.out.println(stringStringConsumerRecord);
}
// offset同步提交
kafkaConsumer.commitSync(); // 每拉取一次数据,offset就提交一次
}
}
}
2)异步提交offset
虽然同步提交offset更可靠一些,但是由于其会阻塞当前线程,直到提交成功。因此吞吐量会受到很大的影响。因此更多的情况下,会选用异步提交offset的方式。
以下为异步提交offset的示例:
package com.jason.kafka.consumer;
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;
/**
* @author Jason
* @date 2023/5/12
* @package_name com.jason.kafka.consumer
*/
public class CustomConsumer1 {
public static void main(String[] args) {
// 1 封装消费者配置参数
Properties properties = new Properties();
// 连接Kafka集群
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"node02:9092");
// key value 的反序列化
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
// 消费者组id
properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test1");
// 修改分区策略
properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, StickyAssignor.class.getName());
// offset 提交策略
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false); //先将offset自动提交关闭
// 2 创建消费者对象
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(properties);
// 3 指定消费者topic
ArrayList<String> topics = new ArrayList<String>();
topics.add("first");
kafkaConsumer.subscribe(topics);
// 4 消费者主动拉取数据
while (true){
ConsumerRecords<String, String> poll = kafkaConsumer.poll(Duration.ofSeconds(1));
for (ConsumerRecord<String, String> stringStringConsumerRecord : poll) {
System.out.println(stringStringConsumerRecord);
}
// offset同步提交
kafkaConsumer.commitAsync(); // 每拉取一次数据,offset就提交一次
}
}
}
5.5.4 指定Offset消费
auto.offset.reset = earliest | latest | none 默认是latest。
当Kafka中没有初始偏移量(消费者组第一次消费)或服务器上不再存在当前偏移量时(例如该数据已被删除),该怎么办?
(1)earliest:自动将偏移量重置为最早的偏移量,–from-beginning。
(2)latest(默认值):自动将偏移量重置为最新偏移量。
(3)none:如果未找到消费者组的先前偏移量,则向消费者抛出异常。
5.5.5 漏消费和重复消费
**重复消费:**已经消费了数据,但是offset没提交。
**漏消费:**先提交offset后消费,有可能会造成数据的漏消费。
思考:怎么能做到既不漏消费也不重复消费呢?详看消费者事务。
5.6 生产经验——消费者事务
5.7 生产经验——数据积压(消费者如何提高吞吐量)
参数名称 | 描述 |
---|---|
fetch.max.bytes | 默认Default: 52428800(50 m)。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值(50m)仍然可以拉取回来这批数据,因此,这不是一个绝对最大值。一批次的大小受message.max.bytes (broker config)or max.message.bytes (topic config)影响。 |
max.poll.records | 一次poll拉取数据返回消息的最大条数,默认是500条 |
第6章 Kafka-Eagle监控
Kafka-Eagle框架可以监控Kafka集群的整体运行情况,在生产环境中经常使用。
6.1 MySQL环境准备
Kafka-Eagle的安装依赖于MySQL,MySQL主要用来存储可视化展示的数据。如果集群中之前安装过MySQL可以跨过该步。
6.2 Kafka环境准备
1)关闭Kafka集群
[hadoop@node02 kafka]$ kf.sh stop
2)修改/opt/module/kafka/bin/kafka-server-start.sh命令中
[hadoop@node02 kafka]$ vim bin/kafka-server-start.sh
修改如下参数值:
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi
为
if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then
export KAFKA_HEAP_OPTS="-server -Xms2G -Xmx2G -XX:PermSize=128m -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:ParallelGCThreads=8 -XX:ConcGCThreads=5 -XX:InitiatingHeapOccupancyPercent=70"
export JMX_PORT="9999"
#export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G"
fi
注意:修改之后在启动Kafka之前要分发之其他节点。
[hadoop@node02 bin]$ xsync kafka-server-start.sh
6.3 Kafka-Eagle安装
0)官网:https://www.kafka-eagle.org/
1)上传压缩包kafka-eagle-bin-2.0.8.tar.gz到集群/opt/software目录
2)解压到本地
[hadoop@node02 software]$ tar -zxvf kafka-eagle-bin-2.0.8.tar.gz
3)进入刚才解压的目录
[hadoop@node02 kafka-eagle-bin-2.0.8]$ ll
总用量 79164
-rw-rw-r--. 1 jason jason 81062577 10月 13 00:00 efak-web-2.0.8-bin.tar.gz
4)将efak-web-2.0.8-bin.tar.gz解压至/opt/module
[hadoop@node02 kafka-eagle-bin-2.0.8]$ tar -zxvf efak-web-2.0.8-bin.tar.gz -C /opt/module/
5)修改名称
[hadoop@node02 module]$ mv efak-web-2.0.8/ efak
6)修改配置文件 /opt/module/efak/conf/system-config.properties
[hadoop@node02 conf]$ vim system-config.properties
######################################
# multi zookeeper & kafka cluster list
# Settings prefixed with 'kafka.eagle.' will be deprecated, use 'efak.' instead
######################################
efak.zk.cluster.alias=cluster1
cluster1.zk.list=node02:2181,node03:2181,node04:2181/kafka
######################################
# zookeeper enable acl
######################################
cluster1.zk.acl.enable=false
cluster1.zk.acl.schema=digest
cluster1.zk.acl.username=test
cluster1.zk.acl.password=test123
######################################
# broker size online list
######################################
cluster1.efak.broker.size=20
######################################
# zk client thread limit
######################################
kafka.zk.limit.size=32
######################################
# EFAK webui port
######################################
efak.webui.port=8048
######################################
# kafka jmx acl and ssl authenticate
######################################
cluster1.efak.jmx.acl=false
cluster1.efak.jmx.user=keadmin
cluster1.efak.jmx.password=keadmin123
cluster1.efak.jmx.ssl=false
cluster1.efak.jmx.truststore.location=/data/ssl/certificates/kafka.truststore
cluster1.efak.jmx.truststore.password=ke123456
######################################
# kafka offset storage
######################################
# offset保存在kafka
cluster1.efak.offset.storage=kafka
######################################
# kafka jmx uri
######################################
cluster1.efak.jmx.uri=service:jmx:rmi:///jndi/rmi://%s/jmxrmi
######################################
# kafka metrics, 15 days by default
######################################
efak.metrics.charts=true
efak.metrics.retain=15
######################################
# kafka sql topic records max
######################################
efak.sql.topic.records.max=5000
efak.sql.topic.preview.records.max=10
######################################
# delete kafka topic token
######################################
efak.topic.token=keadmin
######################################
# kafka sasl authenticate
######################################
cluster1.efak.sasl.enable=false
cluster1.efak.sasl.protocol=SASL_PLAINTEXT
cluster1.efak.sasl.mechanism=SCRAM-SHA-256
cluster1.efak.sasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username="kafka" password="kafka-eagle";
cluster1.efak.sasl.client.id=
cluster1.efak.blacklist.topics=
cluster1.efak.sasl.cgroup.enable=false
cluster1.efak.sasl.cgroup.topics=
cluster2.efak.sasl.enable=false
cluster2.efak.sasl.protocol=SASL_PLAINTEXT
cluster2.efak.sasl.mechanism=PLAIN
cluster2.efak.sasl.jaas.config=org.apache.kafka.common.security.plain.PlainLoginModule required username="kafka" password="kafka-eagle";
cluster2.efak.sasl.client.id=
cluster2.efak.blacklist.topics=
cluster2.efak.sasl.cgroup.enable=false
cluster2.efak.sasl.cgroup.topics=
######################################
# kafka ssl authenticate
######################################
cluster3.efak.ssl.enable=false
cluster3.efak.ssl.protocol=SSL
cluster3.efak.ssl.truststore.location=
cluster3.efak.ssl.truststore.password=
cluster3.efak.ssl.keystore.location=
cluster3.efak.ssl.keystore.password=
cluster3.efak.ssl.key.password=
cluster3.efak.ssl.endpoint.identification.algorithm=https
cluster3.efak.blacklist.topics=
cluster3.efak.ssl.cgroup.enable=false
cluster3.efak.ssl.cgroup.topics=
######################################
# kafka sqlite jdbc driver address
######################################
# 配置mysql连接
efak.driver=com.mysql.jdbc.Driver
efak.url=jdbc:mysql://node02:3306/ke?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
efak.username=root
efak.password=000000
######################################
# kafka mysql jdbc driver address
######################################
#efak.driver=com.mysql.cj.jdbc.Driver
#efak.url=jdbc:mysql://127.0.0.1:3306/ke?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
#efak.username=root
#efak.password=123456
注意:mysql的配置一定要写清楚,查看之前按照MySQL时的账号密码,不然登不进去eagel的webUI !!
7)添加环境变量
[hadoop@node02 conf]$ sudo vim /etc/profile.d/my_env.sh
# kafkaEFAK
export KE_HOME=/opt/module/efak
export PATH=$PATH:$KE_HOME/bin
注意:source /etc/profile
[hadoop@node02 conf]$ source /etc/profile
8)启动
(1)注意:启动之前需要先启动ZK以及KAFKA。
[hadoop@node02 kafka]$ kf.sh start
(2)启动efak
[hadoop@node02 efak]$ bin/ke.sh start
说明:如果停止efak,执行命令。
[hadoop@node02 efak]$ bin/ke.sh stop
6.4 Kafka-Eagle页面操作
1)登录页面查看监控数据
http://node02:8048/
webUI的具体操作可查看官方文档。
第7章 Kafka-Kraft模式
7.1 Kafka-Kraft架构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fYWisdLR-1684037315681)(…/post_picture/hive/clip_image136.gif)]
左图为Kafka现有架构,元数据在zookeeper中,运行时动态选举controller,由controller进行Kafka集群管理。右图为kraft模式架构(实验性),不再依赖zookeeper集群,而是用三台controller节点代替zookeeper,元数据保存在controller中,由controller直接进行Kafka集群管理。
这样做的好处有以下几个:
-
Kafka不再依赖外部框架,而是能够独立运行;
-
controller管理集群时,不再需要从zookeeper中先读取数据,集群性能上升;
-
由于不依赖zookeeper,集群扩展时不再受到zookeeper读写能力限制;
-
controller不再动态选举,而是由配置文件规定。这样我们可以有针对性的加强controller节点的配置,而不是像以前一样对随机controller节点的高负载束手无策。
7.2 Kafka-Kraft集群部署
1)再次解压一份kafka安装包
[hadoop@node02 software]$ tar -zxvf kafka_2.12-3.0.0.tgz -C /opt/module/
2)重命名为kafka2
[hadoop@node02 module]$ mv kafka_2.12-3.0.0/ kafka2
3)在node02上修改/opt/module/kafka2/config/kraft/server.properties配置文件
[hadoop@node02 kraft]$ vim server.properties
#kafka的角色(controller相当于主机、broker节点相当于从机,主机类似zk功能)
process.roles=broker, controller
#节点ID
node.id=2
#controller服务协议别名
controller.listener.names=CONTROLLER
#全Controller列表
controller.quorum.voters=2@node02:9093,3@node03:9093,4@node04:9093
#不同服务器绑定的端口
listeners=PLAINTEXT://:9092,CONTROLLER://:9093
#broker服务协议别名
inter.broker.listener.name=PLAINTEXT
#broker对外暴露的地址
advertised.Listeners=PLAINTEXT://node02:9092
#协议别名到安全协议的映射
listener.security.protocol.map=CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL
#kafka数据存储目录
log.dirs=/opt/module/kafka2/data
4)分发kafka2
[hadoop@node02 module]$ xsync kafka2/
-
在node03和node04上需要对node.id相应改变,值需要和controller.quorum.voters对应。
-
在node03和node04上需要根据各自的主机名称,修改相应的advertised.Listeners地址。
5)初始化集群数据目录
(1)首先生成存储目录唯一ID。
[hadoop@node02 kafka2]$ bin/kafka-storage.sh random-uuid
J7s9e8PPTKOO47PxzI39VA
(2)用该ID格式化kafka存储目录(三台节点)。
[hadoop@node02 kafka2]$ bin/kafka-storage.sh format -t J7s9e8PPTKOO47PxzI39VA -c /opt/module/kafka_2.12-3.0.0/config/kraft/server.properties
[hadoop@node03 kafka2]$ bin/kafka-storage.sh format -t J7s9e8PPTKOO47PxzI39VA -c /opt/module/kafka_2.12-3.0.0/config/kraft/server.properties
[hadoop@node04 kafka2]$ bin/kafka-storage.sh format -t J7s9e8PPTKOO47PxzI39VA -c /opt/module/kafka_2.12-3.0.0/config/kraft/server.properties
6)启动kafka集群
[hadoop@node02 kafka2]$ bin/kafka-server-start.sh -daemon config/kraft/server.properties
[hadoop@node03 kafka2]$ bin/kafka-server-start.sh -daemon config/kraft/server.properties
[hadoop@node04 kafka2]$ bin/kafka-server-start.sh -daemon config/kraft/server.properties
7)停止kafka集群
[hadoop@node02 kafka2]$ bin/kafka-server-stop.sh
[hadoop@node03 kafka2]$ bin/kafka-server-stop.sh
[hadoop@node04 kafka2]$ bin/kafka-server-stop.sh
7.3 Kafka-Kraft集群启动停止脚本
1)在/home/hadoop/bin目录下创建文件kf2.sh脚本文件
[hadoop@node02 bin]$ vim kf2.sh
脚本如下:
#! /bin/bash
case $1 in
"start"){
for i in node02 node03 node04
do
echo " --------启动 $i Kafka2-------"
ssh $i "/opt/module/kafka2/bin/kafka-server-start.sh -daemon /opt/module/kafka2/config/kraft/server.properties"
done
};;
"stop"){
for i in node02 node03 node04
do
echo " --------停止 $i Kafka2-------"
ssh $i "/opt/module/kafka2/bin/kafka-server-stop.sh "
done
};;
esac
2)添加执行权限
[hadoop@node02 bin]$ chmod +x kf2.sh
3)启动集群命令
[hadoop@node02 ~]$ kf2.sh start
4)停止集群命令
[hadoop@node02 ~]$ kf2.sh stop