Kafka高级应用

命令行工具

消费组管理

#所有消费组
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --list
#消费组详情
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --describe --group 消费组名
#消费组状态
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --describe --group 消费组名 --state
#消费组内成员信息
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --describe --group 消费组名 --members
#删除消费组，如果有消费者在使用会失败
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --delete --group 消费组名

current-offset：当期消费位移

LEO：日志文件中下一条待写入消息的offset，这个offset上实际是没有消息的

cosumer-id：当前消费id标识

host：当前消费的ip

消费位移管理

#重启消费位移，有消费者在消费会失败
./kafka-consumer-groups.sh --bootstrap-server 192.168.0.191:9092 --group 消费组名 --all-topics --reset-offsets --to-earliest --execute

数据管道Connect

概述

Kafka Connect是0.9版本之后简化其他系统与Kafka集成。

• 连接器：实现了Connect API，决定运行多少个任务，按照任务来进行数据复制，从work进程获取任务配置并将其传递下去
• 任务：负责将数据移入或移除Kafka
• work：相当与connector和任务的容器，用于负责管理连接器的配置，启动连接器和连接器任务，提供REST API
• 转换器：Kafka connect和其他存储系统之间发送或者接收数据之间转换数据

独立模式-文件系统

场景

以下实例用了两个Connectors，将文件source.txt中内容通过Source连接器写入Kafka主题，然后将内容写入sink.txt中

• FileStreamSource：从source.txt读取发到broker中
• FileStreamSink：从broker中读取写入到source.sink.txt中

步骤

1. 配置文件

Worker进程用的配置文件：confg/connect-standalone.properties。

修改集群地址为自己地址：bootstrap.servers=192.168.0.191:9092

#集群地址
bootstrap.servers=192.168.0.191:9092
#格式转化类
key.converter=org.apache.kafka.connect.json.JsonConverter
value.converter=org.apache.kafka.connect.json.JsonConverter
#json消息中是否包含schema
key.converter.schemas.enable=true
value.converter.schemas.enable=true
#保存偏移量的文件路径
offset.storage.file.filename=/tmp/connect.offsets
#提交偏移量的频率
offset.flush.interval.ms=10000

Source用的配置文件：connect-file-source.properties

先创建自己的源文件，file修改为自己源文件路径，主题名称修改为自己的

#连接器名称
name=local-file-source
#连接器全限定类名，设置名称也可以
connector.class=FileStreamSource
#task数量
tasks.max=1
#数据源文件路径
file=/tmp/source.txt
#主题名称
topic=jpy

Sink用的配置文件：connect-file-sink.properties

先创建自己的目标文件，file修改为自己目标文件路径，主题名称修改为自己的

name=local-file-sink
connector.class=FileStreamSink
tasks.max=1
#目标文件路径
file=/tmp/sink.txt
topics=jpy

2.启动

• 启动source连接器

  bin/connect-standalone.sh config/connect-standalone.properties config/connect-file-source.properties
  

• 在source.txt中写入内容进行测试

• 启动sink连接器

  bin/connect-standalone.sh config/connect-standalone.properties config/connect-file-sink.properties
  

• 查看sink.txt 内容：source.txt内容已经写到sink.txt中

Springboot整合Kafka

依赖

<dependency>
	<groupId>org.springframework.kafka</groupId>
	<artifactId>spring-kafka</artifactId>
</dependency>

配置

• properties配置或yml配置

  logging.level.root=INFO
  server.port=8080
  #============== kafka ===================
  # 指定kafka 代理地址，可以多个
  spring.kafka.bootstrap-servers=192.168.0.191:9092
   
  #=============== 重试次数  =======================
  spring.kafka.producer.retries=0
  # 每次批量发送消息的数量
  spring.kafka.producer.batch-size=16384
  spring.kafka.producer.buffer-memory=33554432
   
  # 指定消息key和消息体的编解码方式
  spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
  spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
   
  #=============== consumer  =======================
  # 指定默认消费者group id
  spring.kafka.consumer.group-id=group.demo
   
  spring.kafka.consumer.auto-offset-reset=earliest
  spring.kafka.consumer.enable-auto-commit=true
  spring.kafka.consumer.auto-commit-interval=1000
   
  # 指定消息key和消息体的编解码方式
  spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
  spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
  
  #事务，生产者事务发送时必须设置
  spring.kafka.producer.transaction-id-prefix=kafka_tx
  

  spring:
    kafka:
      #多个用逗号隔开
      bootstrap-servers: 192.168.0.191:9092
      producer:
        # 发生错误后，消息重发的次数。
        retries: 0
        #当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。
        batch-size: 16384
        # 设置生产者内存缓冲区的大小。
        buffer-memory: 33554432
        # 键的序列化方式
        key-serializer: org.apache.kafka.common.serialization.StringSerializer
        # 值的序列化方式
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
        # acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
        # acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
        # acks=all ：只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
        acks: 1
        #事务，生产者事务发送时必须设置
        transaction-id-prefix: kafka_tx
      consumer:
        # 自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式，如1S,1M,2H,5D
        auto-commit-interval: 1S
        # 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
        # latest（默认值）在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之后生成的记录）
        # earliest ：在偏移量无效的情况下，消费者将从起始位置读取分区的记录
        auto-offset-reset: earliest
        # 是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
        enable-auto-commit: false
        # 键的反序列化方式
        key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        # 值的反序列化方式
        value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        #指定默认消费者group id
        group-id: group.demo
      listener:
        # 在侦听器容器中运行的线程数。
        concurrency: 5
        #listner负责ack，每调用一次，就立即commit
        ack-mode: manual_immediate
        missing-topics-fatal: false
  
  

代码

@RestController
@RequestMapping("/kafka")
public class KafkaController {
    private static final Logger LOGGER = LoggerFactory.getLogger(KafkaController.class);
    private static final String topic = "jpy";

    @Resource
    private KafkaTemplate template;

    //生产者
    @GetMapping("/send/{input}")
    public String send(@PathVariable("input") String input) {
        template.send(topic, input);
        return "发送成功=>" + input;
    }

    //消费者，id可以为空
    @KafkaListener(id = "consumer-1", topics = {topic}, groupId = "group.demo")
    public void listener(String message) {
        LOGGER.info("收到消息=>:{}", message);
    }
}

事务

使用事务，必须配置transaction-id-prefix

方式1

//事务
@GetMapping("/txSend/{input}")
public String txSend(@PathVariable("input") String input) {
	template.executeInTransaction(t -> {
		template.send(topic, input);
		if ("error".equals(input)) {
			throw new RuntimeException("input error");
		}
		template.send(topic, input + "anthor");
		return true;
	});
	return "发送成功=>" + input;
}

方式2

//事务方式2
@GetMapping("/txSend2/{input}")
@Transactional(rollbackFor = {RuntimeException.class})
public String txSend2(@PathVariable("input") String input) {
	template.send(topic, input);
	if ("error".equals(input)) {
		throw new RuntimeException("input error");
	}
	template.send(topic, input + "anthor");
	return "发送成功=>" + input;
}

流式处理Spark

安装

官网下载http://spark.apache.org/downloads.html

上传至linux，解压，进入sbin目录，启动

./start-all.sh

如果失败，在此脚本中添加：export JAVA_HOME=/opt/java/jdk1.8.0_281

启动成功后，通过192.168.0.191:8080访问，如果访问404，有可能8080端口冲突，在start-master.sh中修改

SPARK_MASTER_WEBUI_PORT=修改后端口

可以通过spark-shell 操作spark

Spark和Kafka整合

依赖

<!--spring-kafka-->
<dependency>
	<groupId>org.springframework.kafka</groupId>
	<artifactId>spring-kafka</artifactId>
</dependency>

<!--spark-streaming-kafka-->
<dependency>
	<groupId>org.apache.spark</groupId>
	<artifactId>spark-streaming-kafka_2.11</artifactId>
	<version>1.6.3</version>
</dependency>

<!-- spark-streaming -->
<dependency>
	<groupId>org.apache.spark</groupId>
	<artifactId>spark-streaming_2.12</artifactId>
	<version>3.1.0</version>
	<scope>provided</scope>
</dependency>