Rubin's Blog

  • 首页
  • 关于作者
  • 隐私政策
享受恬静与美好~~~
分享生活的点点滴滴~~~
  1. 首页
  2. Kafka
  3. 正文

Kafka之架构与实战

2021年 11月 29日 657点热度 0人点赞 0条评论

概念和基本架构

Kafka介绍

Kafka是最初由Linkedin公司开发,是一个分布式、分区的、多副本的、多生产者、多订阅者,基于ZooKeeper协调的分布式日志系统(也可以当做MQ系统),常见可以用于web/nginx日志、访问日志,消息服务等等,Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。

主要应用场景是:日志收集系统和消息系统。

Kafka主要设计目标如下:

  • 以时间复杂度为O(1)的方式提供消息持久化能力,即使对TB级以上数据也能保证常数时间的访问性能
  • 高吞吐率。即使在非常廉价的商用机器上也能做到单机支持每秒100K条消息的传输
  • 支持Kafka Server间的消息分区,及分布式消费,同时保证每个partition内的消息顺序传输
  • 同时支持离线数据处理和实时数据处理
  • 支持在线水平扩展

有两种主要的消息传递模式:点对点传递模式、发布-订阅模式。大部分的消息系统选用发布-订阅模式。Kafka就是一种发布-订阅模式。

对于消息中间件,消息分推拉两种模式。Kafka只有消息的拉取,没有推送,可以通过轮询实现消息的推送。

  1. Kafka在一个或多个可以跨越多个数据中心的服务器上作为集群运行
  2. Kafka集群中按照主题分类管理,一个主题可以有多个分区,一个分区可以有多个副本分区
  3. 每个记录由一个键,一个值和一个时间戳组成

Kafka具有四个核心API:

  1. Producer API:允许应用程序将记录流发布到一个或多个Kafka主题
  2. Consumer API:允许应用程序订阅一个或多个主题并处理为其生成的记录流
  3. Streams API:允许应用程序充当流处理器,使用一个或多个主题的输入流,并生成一个或多个输出主题的输出流,从而有效地将输入流转换为输出流
  4. Connector API:允许构建和运行将Kafka主题连接到现有应用程序或数据系统的可重用生产者或使用者。例如,关系数据库的连接器可能会捕获对表的所有更改

Kafka优势

  1. 高吞吐量:单机每秒处理几十上百万的消息量。即使存储了许多TB的消息,它也保持稳定的性能
  2. 高性能:单节点支持上千个客户端,并保证零停机和零数据丢失
  3. 持久化数据存储:将消息持久化到磁盘。通过将数据持久化到硬盘以及replication防止数据丢失(零拷贝、顺序读,顺序写、利用Linux的页缓存)
  4. 分布式系统,易于向外扩展:所有的Producer、Broker和Consumer都会有多个,均为分布式的。无需停机即可扩展机器。多个Producer、Consumer可能是不同的应用
  5. 可靠性:Kafka是分布式,分区,复制和容错的
  6. 客户端状态维护:消息被处理的状态是在Consumer端维护,而不是由server端维护。当失败时能自动平衡
  7. 支持online和offline的场景
  8. 支持多种客户端语言。Kafka支持Java、.NET、PHP、Python等多种语言

Kafka应用场景

  • 日志收集:一个公司可以用Kafka可以收集各种服务的Log,通过Kafka以统一接口服务的方式开放给各种Consumer
  • 消息系统:解耦生产者和消费者、缓存消息等
  • 用户活动跟踪:Kafka经常被用来记录Web用户或者App用户的各种活动,如浏览网页、搜索、点击等活动,这些活动信息被各个服务器发布到Kafka的Topic中,然后消费者通过订阅这些Topic来做实时的监控分析,亦可保存到数据库
  • 运营指标:Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据,生产各种操作的集中反馈,比如报警和报告
  • 流式处理:比如Spark Streaming和Storm

基本架构

消息和批次

Kafka的数据单元称为消息。可以把消息看成是数据库里的一个“数据行”或一条“记录”。消息由字节数组组成。

消息有键,键也是一个字节数组。当消息以一种可控的方式写入不同的分区时,会用到键。

为了提高效率,消息被分批写入Kafka。批次就是一组消息,这些消息属于同一个主题和分区。

把消息分成批次可以减少网络开销。批次越大,单位时间内处理的消息就越多,单个消息的传输时间就越长。批次数据会被压缩,这样可以提升数据的传输和存储能力,但是需要更多的计算处理。

模式

消息模式(schema)有许多可用的选项,以便于理解。如JSON和XML,但是它们缺乏强类型处理能力。Kafka的许多开发者喜欢使用Apache Avro。Avro提供了一种紧凑的序列化格式,模式和消息体分开。当模式发生变化时,不需要重新生成代码,它还支持强类型和模式进化,其版本既向前兼容,也向后兼容。

数据格式的一致性对Kafka很重要,因为它消除了消息读写操作之间的耦合性。

主题和分区

Kafka的消息通过主题进行分类。主题可比是数据库的表或者文件系统里的文件夹。主题可以被分为若干分区,一个主题通过分区分布于Kafka集群中,提供了横向扩展的能力。

生产者和消费者

生产者创建消息。消费者消费消息。一个消息被发布到一个特定的主题上。生产者在默认情况下把消息均衡地分布到主题的所有分区上:

  1. 直接指定消息的分区
  2. 根据消息的key散列取模得出分区
  3. 轮询指定分区

消费者通过偏移量来区分已经读过的消息,从而消费消息。消费者是消费组的一部分。消费组保证每个分区只能被一个消费者使用,避免重复消费。

broker和集群

一个独立的Kafka服务器称为broker。broker接收来自生产者的消息,为消息设置偏移量,并提交消息到磁盘保存。broker为消费者提供服务,对读取分区的请求做出响应,返回已经提交到磁盘上的消息。单个broker可以轻松处理数千个分区以及每秒百万级的消息量。

每个集群都有一个broker是集群控制器(自动从集群的活跃成员中选举出来)。

控制器负责管理工作:

  • 将分区分配给broker
  • 监控broker

集群中一个分区属于一个broker,该broker称为分区首领。一个分区可以分配给多个broker,此时会发生分区复制。分区的复制提供了消息冗余,高可用。副本分区不负责处理消息的读写。

核心概念

Producer

生产者创建消息。

该角色将消息发布到Kafka的topic中。broker接收到生产者发送的消息后,broker将该消息追加到当前用于追加数据的segment文件中。

一般情况下,一个消息会被发布到一个特定的主题上。

  1. 默认情况下通过轮询把消息均衡地分布到主题的所有分区上
  2. 在某些情况下,生产者会把消息直接写到指定的分区。这通常是通过消息键和分区器来实现的,分区器为键生成一个散列值,并将其映射到指定的分区上。这样可以保证包含同一个键的消息会被写到同一个分区上
  3. 生产者也可以使用自定义的分区器,根据不同的业务规则将消息映射到分区

Consumer

消费者读取消息。

  1. 消费者订阅一个或多个主题,并按照消息生成的顺序读取它们
  2. 消费者通过检查消息的偏移量来区分已经读取过的消息。偏移量是另一种元数据,它是一个不断递增的整数值,在创建消息时,Kafka会把它添加到消息里。在给定的分区里,每个消息的偏移量都是唯一的。消费者把每个分区最后读取的消息偏移量保存在ZooKeeper或Kafka上,如果消费者关闭或重启,它的读取状态不会丢失
  3. 消费者是消费组的一部分。群组保证每个分区只能被一个消费者使用
  4. 如果一个消费者失效,消费组里的其他消费者可以接管失效消费者的工作,再平衡,分区重新分配

Broker

一个独立的Kafka服务器被称为broker。

broker 为消费者提供服务,对读取分区的请求作出响应,返回已经提交到磁盘上的消息。

  1. 如果某topic有N个partition,集群有N个broker,那么每个broker存储该topic的一个partition
  2. 如果某topic有N个partition,集群有(N+M)个broker,那么其中有N个broker存储该topic的一个partition,剩下的M个broker不存储该topic的partition数据
  3. 如果某topic有N个partition,集群中broker数目少于N个,那么一个broker存储该topic的一个或多个partition。在实际生产环境中,尽量避免这种情况的发生,这种情况容易导致Kafka集群数据不均衡

broker是集群的组成部分。每个集群都有一个broker同时充当了集群控制器的角色(自动从集群的活跃成员中选举出来)。

控制器负责管理工作,包括将分区分配给broker和监控broker。

在集群中,一个分区从属于一个broker,该broker被称为分区的首领。

Topic

每条发布到Kafka集群的消息都有一个类别,这个类别被称为Topic。

物理上不同Topic的消息分开存储。

主题就好比数据库的表,尤其是分库分表之后的逻辑表。

Partition

  1. 主题可以被分为若干个分区,一个分区就是一个提交日志
  2. 消息以追加的方式写入分区,然后以先入先出的顺序读取
  3. 无法在整个主题范围内保证消息的顺序,但可以保证消息在单个分区内的顺序
  4. Kafka通过分区来实现数据冗余和伸缩性
  5. 在需要严格保证消息的消费顺序的场景下,需要将partition数目设为1

Replicas

Kafka使用主题来组织数据,每个主题被分为若干个分区,每个分区有多个副本。那些副本被保存在broker上,每个broker可以保存成百上千个属于不同主题和分区的副本。

副本有以下两种类型:

  • 首领副本:每个分区都有一个首领副本。为了保证一致性,所有生产者请求和消费者请求都会经过这个副本
  • 跟随者副本:首领以外的副本都是跟随者副本。跟随者副本不处理来自客户端的请求,它们唯一的任务就是从首领那里复制消息,保持与首领一致的状态。如果首领发生崩溃,其中的一个跟随者会被提升为新首领

Offset

生产者Offset

消息写入的时候,每一个分区都有一个offset,这个offset就是生产者的offset,同时也是这个分区的最新最大的offset。

有些时候没有指定某一个分区的offset,这个工作kafka帮我们完成。

消费者Offset

这是某一个分区的offset情况,生产者写入的offset是最新最大的值是12,而当Consumer A进行消费时,从0开始消费,一直消费到了9,消费者的offset就记录在9,Consumer B就纪录在了11。等下一次他们再来消费时,他们可以选择接着上一次的位置消费,当然也可以选择从头消费,或者跳到最近的记录并从“现在”开始消费。

副本

Kafka通过副本保证高可用。副本分为首领副本(Leader)和跟随者副本(Follower)。

跟随者副本包括同步副本和不同步副本,在发生首领副本切换的时候,只有同步副本可以切换为首领副本。

AR

分区中的所有副本统称为AR(Assigned Repllicas)。

AR=ISR+OSR

ISR

所有与leader副本保持一定程度同步的副本(包括Leader)组成ISR(In-Sync Replicas),ISR集合是AR集合中的一个子集。消息会先发送到leader副本,然后follower副本才能从leader副本中拉取消息进行同步,同步期间内follower副本相对于leader副本而言会有一定程度的滞后。前面所说的“一定程度”是指可以忍受的滞后范围,这个范围可以通过参数进行配置。

OSR

与leader副本同步滞后过多的副本(不包括leader)副本,组成OSR(Out-Sync Relipcas)。在正常情况下,所有的follower副本都应该与leader副本保持一定程度的同步,即AR=ISR,OSR集合为空。

HW

HW是High Watermak的缩写, 俗称高水位,它表示了一个特定消息的偏移量(offset),消费之只能拉取到这个offset之前的消息。

LEO

LEO是Log End Offset的缩写,它表示了当前日志文件中下一条待写入消息的offset。

Kafka安装与配置

安装软件可以自行下载或者下载附件。

Java环境为前提

上传jdk-8u261-linux-x64.rpm到服务器并安装:

rpm -ivh jdk-8u261-linux-x64.rpm 

配置环境变量:

vim /etc/profile
# 生效
source /etc/profile
# 验证
java -version

ZooKeeper的安装配置

上传zookeeper-3.4.14.tar.gz到服务器。

解压到/opt:

tar -zxf zookeeper-3.4.14.tar.gz -C /opt
cd /opt/zookeeper-3.4.14/conf
# 复制zoo_sample.cfg命名为zoo.cfg
cp zoo_sample.cfg zoo.cfg
# 编辑zoo.cfg文件
vim zoo.cfg

修改ZooKeeper保存数据的目录,dataDir:

dataDir=/var/zookeeper/data

编辑/etc/profile:

使配置生效:

source /etc/profile

启动ZooKeeper:

zkServer.sh start 

验证:

Kafka的安装与配置

上传kafka_2.12-1.0.2.tgz到服务器并解压:

tar -zxf kafka_2.12-1.0.2.tgz -C /opt 

配置环境变量并生效:

vim /etc/profile 

配置/opt/kafka_2.12-1.0.2/config中的server.properties文件:

启动Kafka:

进入Kafka安装的根目录,执行如下命令:

启动成功,可以看到控制台输出的最后一行的started状态:

查看ZooKeeper的节点:

此时Kafka是前台模式启动,要停止,使用Ctrl+C。

如果要后台启动,使用命令:

kafka-server-start.sh -daemon config/server.properties 

查看Kafka的后台进程:

ps aux | grep kafka 

停止后台运行的Kafka:

生产与消费

kafka-topics.sh用于管理主题。

# 列出现有的主题
[root@node1 ~]# kafka-topics.sh --list --zookeeper localhost:2181/myKafka
# 创建主题,该主题包含一个分区,该分区为Leader分区,它没有Follower分区副本。
[root@node1 ~]# kafka-topics.sh --zookeeper localhost:2181/myKafka --create
 --topic topic_1 --partitions 1 --replication-factor 1
# 查看分区信息
[root@node1 ~]# kafka-topics.sh --zookeeper localhost:2181/myKafka --list
# 查看指定主题的详细信息
[root@node1 ~]# kafka-topics.sh --zookeeper localhost:2181/myKafka --
describe --topic topic_1
# 删除指定主题
[root@node1 ~]# kafka-topics.sh --zookeeper localhost:2181/myKafka --delete
 --topic topic_1

kafka-console-producer.sh用于生产消息:

# 开启生产者
[root@node1 ~]# kafka-console-producer.sh --topic topic_1 --broker-list
 localhost:9092

kafka-console-consumer.sh用于消费消息:

# 开启消费者
[root@node1 ~]# kafka-console-consumer.sh --bootstrap-server localhost:9092 -
-topic topic_1
# 开启消费者方式二,从头消费,不按照偏移量消费
[root@node1 ~]# kafka-console-consumer.sh --bootstrap-server localhost:9092 -
-topic topic_1 --from-beginning

Kafka开发实战

消息的发送与接收

生产者主要的对象有:KafkaProducer,ProducerRecord。其中KafkaProducer是用于发送消息的类,ProducerRecord类用于封装Kafka的消息。

KafkaProducer的创建需要指定的参数和含义:

参数说明
bootstrap.servers配置生产者如何与broker建立连接。该参数设置的是初始化参数。如果生产者需要连接的是Kafka集群,则这里配置集群中几个broker的地址,而不是全部,当生产者连接上此处指定的broker之后,在通过该连接发现集群中的其他节点
key.serializer要发送信息的key数据的序列化类。设置的时候可以写类名,也可以使用该类的Class对象
value.serializer要发送消息的alue数据的序列化类。设置的时候可以写类名,也可以使用该类的Class对象
acks默认值:all。

acks=0:
生产者不等待broker对消息的确认,只要将消息放到缓冲区,就认为消息已经发送完成。该情形不能保证broker是否真的收到了消息,retries配置也不会生效。发送的消息的返回的消息偏移量永远是-1

acks=1:
表示消息只需要写到主分区即可,然后就响应客户端,而不等待副本分区的确认。在该情形下,如果主分区收到消息确认之后就宕机了,而副本分区还没来得及同步该消息,则该消息丢失

acks=all:
首领分区会等待所有的ISR副本分区确认记录
该处理保证了只要有一个ISR副本分区存活,消息就不会丢失
这是Kafka最强的可靠性保证,等效于 acks=-1
retriesretries重试次数
当消息发送出现错误的时候,系统会重发消息
跟客户端收到错误时重发一样
如果设置了重试,还想保证消息的有序性,需要设置MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1
否则在重试此失败消息的时候,其他的消息可能发送成功了

其他参数可以从org.apache.kafka.clients.producer.ProducerConfig中找到。

消费者生产消息后,需要broker端的确认,可以同步确认,也可以异步确认。

同步确认效率低,异步确认效率高,但是需要设置回调对象。

同步发送生产者

package com.rubin.kafka.example;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.header.Header;
import org.apache.kafka.common.header.internals.RecordHeader;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class MyProducer1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Map<String, Object> configs = new HashMap<>();
        // 指定初始连接用到的broker地址
        configs.put("bootstrap.servers", "kafka-host:9092");
        // 指定key的序列化类
        configs.put("key.serializer", IntegerSerializer.class);
        // 指定value的序列化类
        configs.put("value.serializer", StringSerializer.class);

//        configs.put("acks", "all");
//        configs.put("reties", "3");

        KafkaProducer<Integer, String> producer = new KafkaProducer<Integer, String>(configs);

        // 用于设置用户自定义的消息头字段
        List<Header> headers = new ArrayList<>();
        headers.add(new RecordHeader("biz.name", "producer.demo".getBytes()));

        ProducerRecord<Integer, String> record = new ProducerRecord<Integer, String>(
                "topic_1",
                0,
                0,
                "hello rubin 0",
                headers
        );

        // 消息的同步确认
//        final Future<RecordMetadata> future = producer.send(record);
//        final RecordMetadata metadata = future.get();
//        System.out.println("消息的主题:" + metadata.topic());
//        System.out.println("消息的分区号:" + metadata.partition());
//        System.out.println("消息的偏移量:" + metadata.offset());

        // 消息的异步确认
        producer.send(record, new Callback() {
            @Override
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                if (exception == null) {
                    System.out.println("消息的主题:" + metadata.topic());
                    System.out.println("消息的分区号:" + metadata.partition());
                    System.out.println("消息的偏移量:" + metadata.offset());
                } else {
                    System.out.println("异常消息:" + exception.getMessage());
                }
            }
        });

        // 关闭生产者
        producer.close();
    }
}

异步发送生产者

package com.rubin.kafka.example;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.header.Header;
import org.apache.kafka.common.header.internals.RecordHeader;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class MyProducer2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Map<String, Object> configs = new HashMap<>();
        // 指定初始连接用到的broker地址
        configs.put("bootstrap.servers", "kafka-host:9092");
        // 指定key的序列化类
        configs.put("key.serializer", IntegerSerializer.class);
        // 指定value的序列化类
        configs.put("value.serializer", StringSerializer.class);

//        configs.put("acks", "all");
//        configs.put("reties", "3");

        KafkaProducer<Integer, String> producer = new KafkaProducer<Integer, String>(configs);

        // 用于设置用户自定义的消息头字段
        List<Header> headers = new ArrayList<>();
        headers.add(new RecordHeader("biz.name", "producer.demo".getBytes()));

        for (int i = 0; i < 100; i++) {

            ProducerRecord<Integer, String> record = new ProducerRecord<Integer, String>(
                    "topic_1",
                    0,
                    i,
                    "hello rubin " + i,
                    headers
            );

            // 消息的同步确认
            //        final Future<RecordMetadata> future = producer.send(record);
            //        final RecordMetadata metadata = future.get();
            //        System.out.println("消息的主题:" + metadata.topic());
            //        System.out.println("消息的分区号:" + metadata.partition());
            //        System.out.println("消息的偏移量:" + metadata.offset());

            // 消息的异步确认
            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        System.out.println("消息的主题:" + metadata.topic());
                        System.out.println("消息的分区号:" + metadata.partition());
                        System.out.println("消息的偏移量:" + metadata.offset());
                    } else {
                        System.out.println("异常消息:" + exception.getMessage());
                    }
                }
            });
        }

        // 关闭生产者
        producer.close();
    }
}

一次拉取消费者

package com.rubin.kafka.example;

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.IntegerDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class MyConsumer1 {
    public static void main(String[] args) {

        Map<String, Object> configs = new HashMap<>();
        // kafka-host对应于服务器IP,windows的hosts文件中手动配置域名解析
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-host:9092");
        // 使用常量代替手写的字符串,配置key的反序列化器
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        // 配置value的反序列化器
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 配置消费组ID
        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer_demo1");
        // 如果找不到当前消费者的有效偏移量,则自动重置到最开始
        // latest表示直接重置到消息偏移量的最后一个
        configs.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        KafkaConsumer<Integer, String> consumer = new KafkaConsumer<Integer, String>(configs);

        // 先订阅,再消费
        consumer.subscribe(Arrays.asList("topic_1"));

//        while (true) {
//            final ConsumerRecords<Integer, String> consumerRecords = consumer.poll(3_000);
//        }
        // 如果主题中没有可以消费的消息,则该方法可以放到while循环中,每过3秒重新拉取一次
        // 如果还没有拉取到,过3秒再次拉取,防止while循环太密集的poll调用。

        // 批量从主题的分区拉取消息
        final ConsumerRecords<Integer, String> consumerRecords = consumer.poll(3_000);

        // 遍历本次从主题的分区拉取的批量消息
        consumerRecords.forEach(new Consumer<ConsumerRecord<Integer, String>>() {
            @Override
            public void accept(ConsumerRecord<Integer, String> record) {
                System.out.println(record.topic() + "\t"
                        + record.partition() + "\t"
                        + record.offset() + "\t"
                        + record.key() + "\t"
                        + record.value());
            }
        });

        consumer.close();
    }
}

循环拉取消费者

package com.rubin.kafka.example;

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.IntegerDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class MyConsumer2 {
    public static void main(String[] args) {

        Map<String, Object> configs = new HashMap<>();
        // kafka-host对应于服务器IP,windows的hosts文件中手动配置域名解析
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-host:9092");
        // 使用常量代替手写的字符串,配置key的反序列化器
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        // 配置value的反序列化器
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 配置消费组ID
        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer_demo2");
        // 如果找不到当前消费者的有效偏移量,则自动重置到最开始
        // latest表示直接重置到消息偏移量的最后一个
        configs.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        KafkaConsumer<Integer, String> consumer = new KafkaConsumer<Integer, String>(configs);

        // 先订阅,再消费
        consumer.subscribe(Arrays.asList("topic_1"));

        while (true) {
            // 如果主题中没有可以消费的消息,则该方法可以放到while循环中,每过3秒重新拉取一次
            // 如果还没有拉取到,过3秒再次拉取,防止while循环太密集的poll调用。

            // 批量从主题的分区拉取消息
            final ConsumerRecords<Integer, String> consumerRecords = consumer.poll(3_000);

            // 遍历本次从主题的分区拉取的批量消息
            consumerRecords.forEach(new Consumer<ConsumerRecord<Integer, String>>() {
                @Override
                public void accept(ConsumerRecord<Integer, String> record) {
                    System.out.println(record.topic() + "\t"
                            + record.partition() + "\t"
                            + record.offset() + "\t"
                            + record.key() + "\t"
                            + record.value());
                }
            });
        }

//        consumer.close();

    }
}

手动调整分区偏移量消费者

创建主题:

kafka-topics.sh --zookeeper localhost:2181/myKafka --create --topic tp_demo_01 --partitions 3 --replication-factor 1
package com.rubin.kafka.example;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class MyOffsetManager {
    public static void main(String[] args) {

        Map<String, Object> configs = new HashMap<>();
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-host:9092");
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // group.id很重要
        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "mygrp1");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(configs);

//        consumer.subscribe(Collections.singleton("tp_demo_01"));

        // 如何手动给消费者分配分区?
        // 1、需要知道有哪些主题可以访问,和消费

        // 获取当前消费者可以访问和消费的主题以及它们的分区信息
//        final Map<String, List<PartitionInfo>> stringListMap = consumer.listTopics();
//
//        stringListMap.forEach(new BiConsumer<String, List<PartitionInfo>>() {
//            @Override
//            public void accept(String topicName, List<PartitionInfo> partitionInfos) {
//                System.out.println("主题名称:" + topicName);
//                for (PartitionInfo partitionInfo : partitionInfos) {
//                    System.out.println(partitionInfo);
//                }
//            }
//        });

//        final Set<TopicPartition> assignment1 = consumer.assignment();
//
//        for (TopicPartition partition : assignment1) {
//            System.out.println(partition);
//        }
//        System.out.println("----------------------------");

        // 给当前消费者分配指定的主题分区
        consumer.assign(Arrays.asList(
                new TopicPartition("tp_demo_01", 0),
                new TopicPartition("tp_demo_01", 1),
                new TopicPartition("tp_demo_01", 2)
        ));

        // 获取给当前消费者分配的主题分区信息
//        final Set<TopicPartition> assignment = consumer.assignment();
//
//        for (TopicPartition partition : assignment) {
//            System.out.println(partition);
//        }

        // 查看当前消费者在指定主题的分区上的消费者偏移量
//        final long offset0 = consumer.position(new TopicPartition("tp_demo_01", 0));
//
//        System.out.println("当前主题在0号分区上的位移:" + offset0);

//        consumer.seekToBeginning(Arrays.asList(
//                new TopicPartition("tp_demo_01", 0),
//                new TopicPartition("tp_demo_01", 2)
//        ));
        long offset0 = consumer.position(new TopicPartition("tp_demo_01", 0));
        long offset1 = consumer.position(new TopicPartition("tp_demo_01", 1));
        long offset2 = consumer.position(new TopicPartition("tp_demo_01", 2));

        System.out.println(offset0);
        System.out.println(offset1);
        System.out.println(offset2);

//        consumer.seekToEnd(Arrays.asList(new TopicPartition("tp_demo_01", 2)));

        consumer.seek(new TopicPartition("tp_demo_01", 2), 14);

        offset0 = consumer.position(new TopicPartition("tp_demo_01", 0));
        offset1 = consumer.position(new TopicPartition("tp_demo_01", 1));
        offset2 = consumer.position(new TopicPartition("tp_demo_01", 2));

        System.out.println(offset0);
        System.out.println(offset1);
        System.out.println(offset2);

        consumer.close();
    }

}

需要注意的点(特别重要)

小伙伴们如果跟着做,八九不离十会遇到一些坑。本小节的目的就是描述一下笔者遇到的一些坑,防止小伙伴们二次踩坑。

首先,讲一下Kafka客户端(包括消息生产者和消费者)的连接服务器流程。首先,客户端会根据我们配置的ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG去连接服务器,然后拉取服务器集群列表,选中集群中的一台机器连接,连接之后再进行生产消息或者消费消息。

Kafka默认的对外连接器监听的是本机的9092端口,向zk中注册的节点连接地址为hostname:9092!这个hostname如果是新手很容易踩坑,笔者是默认的阿里云机器,hostname就是一串随机字符串。。。所以我的客户端申请回来的选中节点的链接地址为asdasdgajhsdasghdashgd:9092,然后就是连接超时。。。

这里的解决办法有很多,知道了原因就很容易解决。

第一种就是更改服务器的hostname,比如改为node1,然后在本地host文件配制一个node1的映射,映射到服务器的真实IP即可。

第二种就是更改Kafka服务器的配置文件config/server.properties中的listeners属性如下:

listeners=PLAINTEXT://kafka-host:9092

然后在服务器端的host文件中添加kafka-host的映射(本机IP即局域网IP,千万不能是公网IP,因为服务器起来的时候会根据这个地址去初始化ServerSocket,公网IP会导致初始化失败),添加好之后启动Kafka服务。

同时我们客户端机器也要在host中添加 kafka-host的映射,映射地址为Kafka服务的公网IP,如果在一个局域网中也可以是局域网IP。配置好后启动才能正常访问。

SpringBoot集成Kafka

新建SpringBoot项目,添加Kafka的Starter:

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

添加配置项如下:

spring.application.name=springboot-kafka
server.port=8080

# kafka的配置
spring.kafka.bootstrap-servers=kafka-host:9092

#producer配置
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.IntegerSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
# 生产者每个批次最多放多少条记录
spring.kafka.producer.batch-size=16384
# 生产者一端总的可用发送缓冲区大小,此处设置为32MB
spring.kafka.producer.buffer-memory=33554432

#consumer配置
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.IntegerDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.group-id=springboot-consumer
# 如果在kafka中找不到当前消费者的偏移量,则直接将偏移量重置为最早的
spring.kafka.consumer.auto-offset-reset=earliest
# 消费者的偏移量是自动提交还是手动提交,此处自动提交偏移量
spring.kafka.consumer.enable-auto-commit=true
# 消费者偏移量自动提交的时间间隔
spring.kafka.consumer.auto-commit-interval=1000

编写生产者:

@RestController
@RequestMapping("kafka")
public class KafkaController {

    @Autowired
    private KafkaTemplate<Integer, String> template;

    @RequestMapping("send/sync/{message}")
    public String sendSync(@PathVariable String message) {

        final ListenableFuture<SendResult<Integer, String>> future = template.send("topic-spring-boot", 0, 0, message);
        // 同步发送消息
        try {
            final SendResult<Integer, String> sendResult = future.get();
            final RecordMetadata metadata = sendResult.getRecordMetadata();

            System.out.println(metadata.topic() + "\t" + metadata.partition() + "\t" + metadata.offset());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        return "success";
    }

    @RequestMapping("send/async/{message}")
    public String sendAsync(@PathVariable String message) {

        final ListenableFuture<SendResult<Integer, String>> future = this.template.send("topic-spring-boot", 0, 1, message);

        // 设置回调函数,异步等待broker端的返回结果
        future.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                System.out.println("发送消息失败:" + throwable.getMessage());
            }

            @Override
            public void onSuccess(SendResult<Integer, String> result) {
                final RecordMetadata metadata = result.getRecordMetadata();

                System.out.println("发送消息成功:" + metadata.topic() + "\t" + metadata.partition() + "\t" + metadata.offset());
            }
        });

        return "success";
    }

}

编写消费者:

@Component
public class MyConsumer {

    @KafkaListener(topics = "topic-spring-boot")
    public void onMessage(ConsumerRecord<Integer, String> record) {
        System.out.println("消费者收到的消息:"
                + record.topic() + "\t"
                + record.partition() + "\t"
                + record.offset() + "\t"
                + record.key() + "\t"
                + record.value());
    }

}

启动项目测试即可。

服务端参数配置

本节主要讲解$KAFKA_HOME/config/server.properties文件中的配置。

zookeeper.connect

该参数用于配置Kafka要连接的ZooKeeper/集群的地址。

它的值是一个字符串,使用逗号分隔Zookeeper的多个地址。ZooKeeper的单个地址是host:port形式的,可以在最后添加Kafka在ZooKeeper中的根节点路径。

如:

zookeeper.connect=node2:2181,node3:2181,node4:2181/myKafka 

listeners

用于指定当前Broker向外发布服务的地址和端口。

与advertised.listeners配合,用于做内外网隔离。

内外网隔离配置

  • listener.security.protocol.map:监听器名称和安全协议的映射配置。比如,可以将内外网隔离,即使它们都使用SSL协议,可配置为:listener.security.protocol.map=INTERNAL:SSL,EXTERNAL:SSL。每个监听器的名称只能在map中出现一次
  • inter.broker.listener.name:用于配置broker之间通信使用的监听器名称,该名称必须在advertised.listeners列表中。例如:inter.broker.listener.name=EXTERNAL
  • listeners:用于配置broker监听的URI以及监听器名称列表,使用逗号隔开多个URI及监听器名称。如果监听器名称代表的不是安全协议,必须配置listener.security.protocol.map。每个监听器必须使用不同的网络端口
  • advertised.listeners:需要将该地址发布到ZooKeeper供客户端使用,如果客户端使用的地址与listeners配置不同。可以在ZooKeeper的get /myKafka/brokers/ids/<broker.id>中找到。如果不设置此条目,就使用listeners的配置。advertised.listeners的地址必须是listeners中配置的或配置的一部分

典型配置:

broker.id

该属性用于唯一标记一个Kafka的Broker,它的值是一个任意integer值。当Kafka以分布式集群运行的时候,尤为重要。

最好该值跟该Broker所在的物理主机有关的,如主机名为host1.rubinchu.com,则broker.id=1,如果主机名为192.168.100.101,则broker.id=101等等。

log.dir

通过该属性的值,指定Kafka在磁盘上保存消息的日志片段的目录。它是一组用逗号分隔的本地文件系统路径。如果指定了多个路径,那么Broker会根据“最少使用”原则,把同一个分区的日志片段保存到同一个路径下。

Broker会往拥有最少数目分区的路径新增分区,而不是往拥有最小磁盘空间的路径新增分区。

以上就是本文的全部内容。欢迎小伙伴们积极留言交流~~~

附件

链接:https://pan.baidu.com/s/1f4LzpE4XowwbHqlwHs8GSw

提取码:ejr2

本作品采用 知识共享署名 4.0 国际许可协议 进行许可
标签: Kafka
最后更新:2022年 6月 9日

RubinChu

一个快乐的小逗比~~~

打赏 点赞
下一篇 >

文章评论

razz evil exclaim smile redface biggrin eek confused idea lol mad twisted rolleyes wink cool arrow neutral cry mrgreen drooling persevering
取消回复
文章目录
  • 概念和基本架构
    • Kafka介绍
    • Kafka优势
    • Kafka应用场景
    • 基本架构
      • 消息和批次
      • 模式
      • 主题和分区
      • 生产者和消费者
      • broker和集群
    • 核心概念
      • Producer
      • Consumer
      • Broker
      • Topic
      • Partition
      • Replicas
      • Offset
      • 副本
  • Kafka安装与配置
    • Java环境为前提
    • ZooKeeper的安装配置
    • Kafka的安装与配置
    • 生产与消费
  • Kafka开发实战
    • 消息的发送与接收
      • 同步发送生产者
      • 异步发送生产者
      • 一次拉取消费者
      • 循环拉取消费者
      • 手动调整分区偏移量消费者
      • 需要注意的点(特别重要)
    • SpringBoot集成Kafka
  • 服务端参数配置
    • zookeeper.connect
    • listeners
      • 内外网隔离配置
    • broker.id
    • log.dir
  • 附件
最新 热点 随机
最新 热点 随机
问题记录之Chrome设置屏蔽Https禁止调用Http行为 问题记录之Mac设置软链接 问题记录之JDK8连接MySQL数据库失败 面试系列之自我介绍 面试总结 算法思维
JVM简介 Elasticsearch之企业级高可用分布式集群 Netty初探 问题记录之设置普通maven工程的编译级别 MySQL之Sharding-JDBC读写分离 Elasticsearch之数据模型构建

COPYRIGHT © 2021 rubinchu.com. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang

京ICP备19039146号-1