kafka基础篇使用01

最新推荐文章于 2025-02-14 14:51:49 发布
最新推荐文章于 2025-02-14 14:51:49 发布
阅读量574 收藏
点赞数
分类专栏： Hadoop BigData kafka 文章标签： kafka基础篇使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Alano1994/article/details/88747435
版权
本文介绍了Apache Kafka，一个分布式流处理平台，包括其特性、应用场景、核心API、消费者组原理和Kafka架构。接着，文章详细讲述了如何搭建Kafka环境，以及常用的操作指令，如启动服务、创建和管理Topic。最后，提到了Kafka的Java API使用，包括生产者和消费者API的介绍。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Kafka

一、官网

https://kafka.apache.org/intro

一、概述

Apache Kafka是一个分布式流处理平台

具备以下三种特性：

  1. 发布和订阅流式记录。类似于消息队列或者企业消息系统
  2. 存储流式数据，并且有较好的容错
  3. 流式数据处理

应用场景：

  1. 构造实时流数据管道，可以在系统或应用之间可靠的获取数据。（相当于MQ）
  2. 构建实时流式应用程序，对这些流数据进行转换或者影响。（流处理）

在这里插入图片描述

Kafka有四个核心API

  1. Producer API —Producer 消息的生产者
  2. Consumer API ---- —Producer 消息的消费者
  3. Stream API
  4. Connector API

Consumer Group
包含一个或者多个Consumer，同一个消息只会被同一个消费组中一个消费者实例处理
不同的消费组可以同时消费同一条数据

Kafka架构图

在这里插入图片描述

  • topic: 主题表示某一种类别的消息（订阅的一个服务）Kafka流中记录都是以Topic作为一个分类去管理。

  • partition： 分区, 一种类别的消息会根据自定义的分片数量进行hash分片，没一个分片中会按照时间戳的顺序维持 一个队列。

  • Record： Kafka流中的一则消息一般包含key、value、time stamp

Kafka是通过Topic对Record做分类管理，通常一个Topic会有0~n个订阅者订阅。一旦在订阅的Topic下产生新的Record，所有的订阅者都将消费该消息。对于每一个Topic底层Kafka集群都会以分区的形式存储

每一个分区会为每一条Record维护一份时序该时序是不可变更。每当使用API向Topic发送/写入一则记录的时候分区会会为该记录记录一次offset偏移量，该偏移量可以理解成为该Record在当前分区的唯一标示。

Kafka将按照’log.retention.hours’配置保留所有发布过来的Record无论该Record是否被消费。Record记录在规定的时间内 ”log.retention.hours”配置时间(默认1周168小时)是可以被消费者消费的，一旦操过规定时间内没有消费者消费Kafka中的消息，该消息会被系统自动清除。由于kafka的分布式磁盘存储，将数据长时间保留在磁盘中是没有太大问题的。

事实上kafka会记录每一个消费者消费的消息的offset偏移量，该偏移量是由客户端所控制的。正常情况下Consumer消费一则消息后对应该消费的者的偏移量会自动加1，但事实上消费者可以自由的控制offset偏移量来实现消息的重复消费，各个消费者之间相互不影响。

所有消息在Kafka集群中按照分区存储目的是为了针对海量数据的存储，一个Topic表示用户所关心的一类消息，Topic可以有很多的分区，因此无需担心海量日志的存储，其次每个分区运行在独立的机器上（broker），因此也会从某种意义上提升系统的并行度。

  • **leader：**Leader负责分区所有读取和写入的节点。每个节点随机选择的分区中的领导者。

    Kafka消息的日志数据是通过分区的形式分布在各个server之上，每个服务器负责接收和处理用户请求。每一个分区都会在集群节点上设置副本，每个副本都有一个Leader和0~n个follower。Leader负责接收读写请求，所有的Follower负责备份主机的数据。如果leader宕机了，其中的Follower会自动的做选举，选举出Leader。每一台服务器在集群中都会扮演着其中某一个Partition数据的Leader也会扮演着其他Partition数据的Follower的角色。

生产者

消息的生产者负责生产消息到他们选择的Topic中去，由生产者决定消息存储到哪一个Topic中的哪一个Partition当中，可以在生产者那边定义一个负载均衡用于实现消息发送的负载均衡策略，如何实现负载均衡后续章节再进行讨论。

消费者

消费者是通过group的概念对自己做标记。因为不同的Group消费者之间相互独立。如果隶属于一个Group中有多个消费者，则消息会在多个消费者之间负载均衡的形式被发送给组内的消费者；如果不是在一个组内的消费者之间是广播形式发送。

  • Consumer Group 消费组

在这里插入图片描述

同一组内的消费者之间是通过对分区日志数据做负载均衡，kafka通过均分原则（“fair share”）将分区的数据分配给每一组内的消费者（一般消费者的数目不应该操过分区的数目）。如果一个组内的有消费者退出了，kafka会自动的原本属于该消费者的分区在动态分分配给组内其他消费者。

二、环境搭建

准备工作

  1. 安装JDK，并配置JAVA_HOME
  2. 同步时钟
  3. 安装ZooKeeper
  4. 安装HDFS集群

  • 下载环境压缩包

    https://kafka.apache.org/downloads

  • 安装配置

    [root@nodeX ~]# tar -zxvf kafka_2.11-0.11.0.0.tgz -C /usr

  • 修改配置文件

    [root@nodeX ~]# vi /usr/kafka_2.11-0.11.0.0/config/server.properties
############################# Server Basics #############################
broker.id=0|1|2
delete.topic.enable=true
############################# Socket Server Settings #############################
listeners=PLAINTEXT://node1|node2|node3:9092
############################# Log Basics #############################
log.dirs=/usr/kafka-logs
############################# Log Retention Policy #############################
log.retention.hours=168
############################# Zookeeper #############################
zookeeper.connect=node1:2181,node2:2181,node3:2181

三、常用指令

服务相关

启动Kafka服务

[root@nodeX kafka_2.11-0.11.0.0]# bin/kafka-server-start.sh -daemon config/server.properties

停止Kafka服务

[root@nodeX kafka_2.11-0.11.0.0]# bin/kafka-server-stop.sh

Topic操作

创建Topic

[root@node1 kafka_2.11-0.11.0.0]# bin/kafka-topics.sh --create --zookeeper
node1:2181,node2:2181,node3:2181 --topic baizhi --partitions 3 --replication-factor 3
Created topic "baizhi".

展示所有Topic

[root@node2 kafka_2.11-0.11.0.0]# bin/kafka-topics.sh --list --zookeeper
node1:2181,node2:2181,node3:2181
baizhi

删除Topic

[root@node2 kafka_2.11-0.11.0.0]# bin/kafka-topics.sh --delete --topic zpark --zookeeper
node1:2181
Topic zpark is marked for deletion.
Note: This will have no impact if delete.topic.enable is not set to true.

查看Topic详情

[root@node2 kafka_2.11-0.11.0.0]# bin/kafka-topics.sh --describe --zookeeper
node1:2181,node2:2181,node3:2181 --topic baizhi
Topic:baizhi  PartitionCount:3    ReplicationFactor:3   Configs:
   Topic: baizhi  Partition: 0  Leader: 2    Replicas: 2,0,1 Isr: 2,0,1
   Topic: baizhi  Partition: 1  Leader: 0    Replicas: 0,1,2 Isr: 0,1,2
   Topic: baizhi  Partition: 2  Leader: 1    Replicas: 1,2,0 Isr: 1,2,0

在这里插入图片描述

Leader负责指定分区所有读取和写入的节点。每个节点将是一部分随机选择的分区中的领导者。
Replicas是此分区日志的节点列表集合，不管这些节点是否是领导者或者只是还活着(不在in-sync状态)。
ISR是一组”in-sync” 节点列表的集合。这个列表包括目前活着并跟leader保持同步的replicas，Isr 是Replicas的子
集。

  • 生产消息
[root@node2 kafka_2.11-0.11.0.0]# bin/kafka-console-producer.sh --topic baizhi --broker-list
node1:9092,node2:9092,node3:9092
>Hello zs
>Hello ls
  • 消费消息
[root@node3 kafka_2.11-0.11.0.0]# bin/kafka-console-consumer.sh --topic baizhi --bootstrap-
server node1:9092,node2:9092,node3:9092 --from-beginning
Hello zs
Hello ls

四、Java API

引入Maven依赖

<dependency>
      <groupId>org.apache.kafka</groupId>
      <artifactId>kafka-clients</artifactId>
      <version>2.0.0</version>
</dependency>

使用api进项测试需要注意在window中配置节点名字

C:\Windows\System32\drivers\etc\hosts

在这里插入图片描述

生产者

package com.baizhi.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;

public class MyKafkaProducer {
    public static void main(String[] args) {
        //1. kafka消息生产者的配置对象
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.21.155:9092,192.168.21.156:9092,192.168.21.157:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // kafka 事务消息产生对象
        KafkaProducer<Integer,String> kafkaProducer = new KafkaProducer<Integer, String>(properties);
        //3. 发布消息
        for (int i = 10; i <20 ; i++) {
            ProducerRecord<Integer,String> producerRecord = new ProducerRecord<Integer, String>("baizhi",i,"holler "+i);
            kafkaProducer.send(producerRecord);
            System.out.println(i);
        }
        kafkaProducer.flush();
        kafkaProducer.close();
    }
}

消费者

package com.baizhi.kafka;

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

import java.util.Arrays;
import java.util.Properties;

public class MyKafkaConsumer {
    public static void main(String[] args) {
        //1. 初始化消息的消费者配置对象
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.21.155:9092,192.168.21.156:9092,192.168.21.157:9092");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 消息广播给所有的消费组 消息只能被消费组中的一个消费组所消费
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "g1");

        //2. 初始化消息消费者对象
        KafkaConsumer<Integer, String> kafkaConsumer = new KafkaConsumer<Integer, String>(properties);
        kafkaConsumer.subscribe(Arrays.asList("baizhi")); // 订阅的主题
        // 消费指定分区的消息
        //kafkaConsumer.assign(Arrays.asList(new TopicPartition("zpark",1)));

        // 指定消费消息的分区及偏移量
        // kafkaConsumer.seek(new TopicPartition("zpark",1),0);
        //3. 消费消息
        while(true) {
            ConsumerRecords<Integer ,String> consumerRecords = kafkaConsumer.poll(1000);// 轮询
            for (ConsumerRecord<Integer, String> consumerRecord : consumerRecords) {
                Integer key = consumerRecord.key();
                String value = consumerRecord.value();
                int partition = consumerRecord.partition();
                long timestamp = consumerRecord.timestamp();
                long offset = consumerRecord.offset();
                System.out.println("key:"+key + "  value: "+value + "  offset:"+offset +"  partition: "+partition + "  timestamp: "+timestamp);

            }
        }

    }
}

kafka的流式编程

package com.baizhi;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Produced;

import java.util.Arrays;
import java.util.Locale;
import java.util.Properties;

/**
 * kafka流数据处理
 */
public class KafkaStreamDemo {
    public static void main(String[] args) {
        final Properties props = new Properties();
        props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-wordcount");
        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "node1:9092,node2:9092,node3:9092");
        props.put(StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG, 0);
        props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());

        // setting offset reset to earliest so that we can re-run the demo code with the same pre-loaded data
        // Note: To re-run the demo, you need to use the offset reset tool:
        // https://cwiki.apache.org/confluence/display/KAFKA/Kafka+Streams+Application+Reset+Tool
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        final StreamsBuilder builder = new StreamsBuilder();
        final KStream<String, String> source = builder.stream("streams-plaintext-input"); // inputTopic

        final KTable<String, Long> counts = source
                .flatMapValues(value -> Arrays.asList(value.toLowerCase(Locale.getDefault()).split(" ")))
                .groupBy((key, value) -> value)
                .count();

        // need to override value serde to Long type
        counts.toStream().to("streams-wordcount-output", Produced.with(Serdes.String(), Serdes.Long()));
        final KafkaStreams streams = new KafkaStreams(builder.build(), props);
        streams.start();
    }
}
大数据技术Kafka详解 ② | Kafka基础与架构介绍
dvlinker的技术专栏
12-02 2万+
本文详细介绍开源高吞吐量分布式消息中间件kafka的架构与组件构成。
【微服务】springboot整合kafka-stream使用详解
congge
12-24 1万+
kafka stream使用详解
Kafka produce flush 引起的性能分析
BITDDD小栈
08-28 1万+
调用kafka producer发送数据时，发现延迟级别在10-200ms不等，与正常的kafka写入速度不匹配，于是开始找问题~ 一.场景： 一批数据，需要遍历每个数据并发送数据细节的信息到kafka，下面是我原始代码，每个人发送后执行一次flush操作。 val results = Array[DataObject](...) results.foreach(data => { val info = new ProducerRecord[String, String](top.
发送kafka生产者数据，结果消费者接收不到数据 producer.flush()
托塔天王的博客
04-07 1472
生产者的缓冲区是指生产者在发送消息到Kafka集群时暂时存储消息的内存区域。当生产者发送消息时，消息通常首先被写入这个缓冲区，然后在适当的时机被批量发送到Kafka服务器。: 如果消费者组的消费速度较慢，即消费者处理消息的速度低于生产者发送消息的速度，那么消息会在Kafka中的主题分区中积压，直到消费者能够处理它们。: 消息从生产者发送到Kafka服务器，以及从Kafka服务器发送到消费者，都会受到网络延迟的影响。（消息压缩类型）等，这些配置参数会影响消息在缓冲区中停留的时间以及发送的时间间隔。
原理剖析：一文搞懂 Kafka Producer（上）
最新发布
sc35262的博客
02-14 769
在 KIP-794[3] 中，为了解决之前版本中的 Sticky Partitioner 导致的“向更慢的 broker 发送了更多的消息”的问题，提出了一个新的 Uniform Sticky Partitioner（并作为默认的内置 Partitioner）。二者组合控制发送失败后重试的指数退避策略——随着重试次数的增加，从 retry.backoff.ms 开始按照 2 的指数次幂增加重试等待时间，并增加一个 20% 的扰动，且最大不超过 retry.backoff.max.ms。
Kafka基础
fighting
09-30 523
Kafka基础 1 消息队列 1.1 什么是消息队列 消息队列（MQ）：消息+队列，保存消息的队列。消息的传输过程中的容器；主要提供生产、消费接口供外部调用做数据的存储和获取。 1.2 为什么要有消息队列 当网站面对教大的流量冲击，在网站系统中一般会有一个消息存储/缓存系统（即消息队列，也叫消息中间件），网站...
kafka学习笔记三producer学习
hwhanwan的专栏
08-17 1096
1.producer消息生产者 producer消息生产的两种方式同步，异步 同步demo package com.hanwan.kafka.demo1; import com.hanwan.common.ReadPropertity; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.ka...
kafka flush
HelloKitty520123的专栏
01-06 2348
日志刷新策略 Kafka的日志实际上是开始是在缓存中的，然后根据一定策略定期一批一批写入到日志文件中去，以提高吞吐量. log.flush.interval.messages 消息达到多少条时将数据写入到日志文件 10000 log.flush.interval.ms 当达到该时间时，强制执行一次flush null log.flush.shceduler.interval.ms 周期性检...
Kafka 入门基础篇.pptx
03-05
Kafka 入门基础篇 Kafka 是 LinkedIn 公司开发的一种分布式消息队列系统，支持离线和在线日志处理。它可以实时处理大量数据，满足各种需求场景，如基于 Hadoop 的批处理系统、低延迟的实时系统、Storm/Spark 流式...
Kafka基础入门篇（深度好文）
f_yuqing的博客
07-13 958
Kafka 作为一个高吞吐量的分布式的基于发布/订阅模式的消息队列（Message Queue）被广泛应用，本篇文章将为大家全面的介绍Kafka的基本架构演变和各个组件的基本信息。
看完这篇Kafka，你也许就会了Kafka
热门推荐
AaronCao
01-13 19万+
Kafka学习 文章目录Kafka学习1. Kafka简介1.1 Kafka消费模式1.2 Kafka的基础架构1.3 Kafka的安装和使用2. Kafka高级2.1 工作流程2.2 文件存储2.3 生产者分区策略2.4 生产者ISR2.4.1 副本数据同步策略2.4.2 ISR(同步副本集)2.5 生产者ack机制2.6 数据一致性问题2.7 ExactlyOnce3. 消费者分区分配策略3.1 分区分配策略3.2 消费者offset的存储3.3 消费者组案例4. 高效读写&Zookeeper作
springboot for kafka 中的KafkaTemplate类的flush()方法初步探索
LinJAEQ的博客
09-10 3939
前言 版本：本文采用的springboot版本为2.1.3.RELEASE,对应的springkafka也是属于此版本。 起因：在学习springboot对kafka 的操作中，碰到过flush()函数，于是想探究下此函数的功能，就有了本文。 风遁！函数追踪术 新建一个springboot的项目，注入spring-kafka的依赖。打开KafkaTemplate的API搜索可以找到...
原理剖析| 一文搞懂 Kafka Producer（上）
AutoMQ的博客
05-16 565
retry.backoff.ms 与 retry.backoff.max.ms二者组合控制发送失败后重试的指数退避策略——随着重试次数的增加，从 retry.backoff.ms 开始按照 2 的指数次幂增加重试等待时间，并增加一个 20% 的扰动，且最大不超过 retry.backoff.max.ms。其包含1.producer 内部攒批的时间2.向 broker 发送请求并等待返回的时间3.每次重试的时间它的值应不小于 linger.ms + request.timeout.ms。
kafka producer.poll producer.flush consumer.poll的区别
weixin_30892763的博客
08-08 1501
参考文献：https://docs.confluent.io/current/clients/confluent-kafka-python/index.html#consumer Producer.poll(timeout) 　　timeout(float) – Maximum time to block waiting for events. (Seconds) 　　Polls ...
Kafka 核心源码解读
justlpf的专栏
04-20 1604
在开始介绍时间轮之前，思考这样一个问题：“怎么实现 Kafka 中的延时请求呢？”针对这个问题，第一反应是使用Java的DelayQueue。毕竟，这个类是 Java 天然提供的延时队列，非常适合建模延时对象处理。实际上，Kafka 的第一版延时请求就是使用 DelayQueue 做的。但是，DelayQueue 有一个弊端：它插入和删除队列元素的时间复杂度是 O(logN)。对于 Kafka 这种非常容易积攒几十万个延时请求的场景来说，该数据结构的性能是瓶颈。
kafka java 操作生产，消费
qq_55961709的博客
09-05 1762
kafka java 操作生产，消费
kafka producer主要参数详解
ForestCat的专栏
03-11 3896
acks（默认值为1） 在消息被认为是“已提交”之前，producer需要leader确认请求的应答数。该参数用于控制消息的持久性，目前提供了3个取值： acks = 0： 表示producer请求立即返回，不需要等待leader的任何确认。这种方案有最高的吞吐率，但是不保证消息是否真的发送成功。 acks = -1：表示分区leader必须等...
Kafka面试细节
Ethan_199402的博客
03-17 311
为什么kafka性能非常高 1.使用到零拷贝技术 属于linux操作系统内核自带；参考文章 2.顺序读写 kafka 属于日志存储系统实际将消息直接追加在segment 后面，将一个大的日志文件拆分成n多个小不同segment 文件，在访问的时候就可以提高效率 设计原理：segment 分段设计+稀疏索引算法（查找） 不会对每个msg建立索引。 3.分区模型架构 提高吞吐量 动态的消费者扩容与缩容 消息顺序一致性的问题 消息落地到同一个分区中，最终被一个消费者消费。在kafka中建议：相同分组中，
kafka调优
龙飞的博客
07-17 3027
kafka优化和相关问题 Kafka的Message存储采用了分区(partition)，分段(LogSegment)和稀疏索引这几个手段来达到了高效性。 Kafka消息数据积压，Kafka消费能力不足怎么处理？ 1）如果是Kafka消费能力不足，则可以考虑增加Topic的分区数，并且同时提升消费组的消费者数量，消费者数=分区数。（两者缺一不可） 2）如果是下游的数据处理不及时：提高每批次拉取的数量。批次拉取数据过少（拉取数据/处理时间<生产速度），使处理的数据小于生产的数据，也会造成数据积压。 ka
"Kafka 0.8.1.1基础篇总结：开篇、概念、配置详解
一、基础篇 1. 开篇说明 Kafka是一个分布式流处理平台，它由LinkedIn开发并开源，旨在解决海量数据的实时处理和存储问题。Kafka的设计理念是高性能、高可靠性、可扩展性强，适用于构建实时数据管道和实时数据分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值