kafka:大规模实时数据流的必选

kafka:大规模实时数据流的必选

  • Apache Kafka:分布式流媒体平台
    • 简介
    • ZooKeeper 和 Kafka 之间的关系:
    • Kafka基本概念
      • 主题(Topic)
      • 分区(Partition)
      • 生产者(Producer)
      • 消费者(Consumer)
    • 环境准备
      • zookeeper环境
      • 开启kafka
      • kafka主题订阅
      • 生产和消费
      • 查询分组和主题
    • Kafka示例
      • 创建一个主题
    • 基于java整合kafka
      • 生产者
      • 消费者
    • 基于springboot整合kafka
    • 结论

Apache Kafka:分布式流媒体平台

Apache Kafka是一个强大的分布式流媒体平台,用于处理实时数据流。它是一个高吞吐量、可扩展和持久的消息系统,广泛应用于日志处理、事件驱动的应用程序、监控和大数据分析等领域。

在本文中,我们将深入了解Apache Kafka的基本概念,并演示如何使用Kafka建立一个简单的消息生产者和消费者。

简介

Kafka 是一个分布式流媒体平台和消息代理,最初由LinkedIn开发并开源。它设计用于高吞吐量,可扩展性,持久性以及容错性。Kafka 主要用于处理实时数据流,广泛应用于各种领域,包括日志收集、事件处理、监控、报警、数据管道和流分析等。

以下是 Kafka 的一些关键概念和特点:

消息传递系统:Kafka 可以看作是一个高度可配置的分布式发布-订阅消息系统,它允许生产者将消息发布到主题(topic),然后允许消费者订阅这些主题并处理消息。

主题(Topic):主题是消息的类别或数据流的逻辑通道。生产者将消息发布到特定主题,而消费者订阅这些主题以接收消息。每个主题可以有多个分区,以实现消息的并行处理和负载均衡。

分区(Partition):每个主题可以分为多个分区,分区是 Kafka 中数据的基本单元。每个分区可以在不同的服务器上进行副本备份,以提高可用性和容错性。分区还允许消息并行处理,使 Kafka 能够处理大量数据并保持高吞吐量。

生产者(Producer):生产者负责将消息发布到 Kafka 主题。生产者可以是任何应用程序或系统,它们生成数据并将其发送到 Kafka 集群。

消费者(Consumer):消费者从 Kafka 主题中订阅消息并处理它们。消费者可以以不同的消费组(Consumer Group)形式进行组织,以实现负载均衡和横向扩展。

消息存储:Kafka 使用持久性存储来存储消息,以确保消息的持久性和可恢复性。消息通常在磁盘上保留一段时间,以供消费者检索。

**分布式和容错性:**Kafka 是分布式的,可以在多个服务器上运行,支持水平扩展。它具有容错性,能够处理服务器故障而不丢失数据。

流数据处理:Kafka 提供了流数据处理功能,允许开发人员构建复杂的数据流处理应用程序,例如实时分析、转换和复杂事件处理。

Kafka 的高吞吐量、可扩展性、持久性和容错性使其成为处理大规模实时数据流的理想选择。它在大数据、日志处理和实时监控等领域广泛应用,并且具有强大的生态系统,包括各种客户端库和工具,以帮助用户更轻松地集成 Kafka 到其应用程序和数据流处理流程中。

ZooKeeper 和 Kafka 之间的关系:

领导者选举: Kafka 使用 ZooKeeper 来实现代理节点(broker)的领导者选举,确保在分布式环境中只有一个代理节点能够写入和读取数据。

协调服务: ZooKeeper 可以用于管理 Kafka 集群的配置信息,例如主题和分区的元数据以及分区的分配。

监控和通知: Kafka 可以将集群的健康状态和元数据信息注册到 ZooKeeper,以供其他监控工具和应用程序使用。

Kafka基本概念

主题(Topic)

Kafka消息以主题(Topic)为单位进行分类。主题是数据流的逻辑通道,生产者将消息发布到主题,而消费者则订阅主题以接收消息。

分区(Partition)

每个主题可以分为多个分区,分区是Kafka中的数据分割单元。分区允许消息的并行处理和负载均衡,并且分区可以在多个服务器上进行副本备份以提高可用性。

生产者(Producer)

生产者是负责将消息发布到Kafka主题的组件。它们可以是应用程序、服务或系统,生成数据并将其发送到Kafka集群。

消费者(Consumer)

消费者从Kafka主题中订阅消息并进行处理。消费者可以组织成不同的消费组,以实现负载均衡和横向扩展。

环境准备

zookeeper环境

下载安装->考虑到是基于windows的环境
进入到bin目录后,

zkServer.sh start
zkServer.sh status
zkServer.sh stop


zkCli.cmd -server localhost:2181

可以基于log日志去判断是否开启,开启之后

开启kafka

 bin/windows/kafka-server-start.bat config/server.properties

kafka主题订阅

kafka-console-consumer.bat --topic quickstart-events --from-beginning --bootstrap-server localhost:9092



生产和消费

kafka-console-producer.bat --topic quickstart-events --bootstrap-server localhost:9092

kafka-console-consumer.bat --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

kafka:大规模实时数据流的必选_第1张图片
kafka:大规模实时数据流的必选_第2张图片

kafka:大规模实时数据流的必选_第3张图片

查询分组和主题

kafka-topics.bat --list --bootstrap-server localhost:9092

kafka-consumer-groups.bat --list --bootstrap-server localhost:9092

Kafka示例

让我们通过一个简单的示例来演示Kafka的基本用法。首先,确保你已经安装了Kafka并启动了Kafka服务。

创建一个主题

我们将首先创建一个名为my-topic的Kafka主题:

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

这将创建一个具有3个分区的主题,副本因子为1。

基于java整合kafka

     
     <dependency>
         <groupId>org.apache.kafkagroupId>
         <artifactId>kafka-clientsartifactId>
         <version>3.5.0version>
     dependency>

     <dependency>
         <groupId>org.apache.kafkagroupId>
         <artifactId>kafka-streamsartifactId>
         <version>3.5.0version>
     dependency>

     <dependency>
         <groupId>org.apache.kafkagroupId>
         <artifactId>kafka-streams-scala_2.13artifactId>
         <version>3.5.0version>
     dependency>

生产者

接下来,让我们创建一个Kafka生产者,发送一些消息到my-topic主题:

import org.apache.kafka.clients.producer.*;

public class KafkaProducerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String topic = "my-topic";

        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());// 指定键的反序列化器
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 指定值的反序列化器

        Producer<String, String> producer = new KafkaProducer<>(props);

        producer.send(new ProducerRecord<>(topic, "key", "Hello, Kafka!"));
        producer.close();
    }
}

这个生产者将一条消息发送到my-topic主题。

消费者

最后,我们创建一个Kafka消费者来接收并处理这些消息:

import org.apache.kafka.clients.consumer.*;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        String bootstrapServers = "localhost:9092";
        String groupId = "my-group";
        String topic = "my-topic";

        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        props.put("group.id", groupId);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());// 指定键的反序列化器
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName()); // 指定值的反序列化器

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList(topic));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("Received message: key=%s, value=%s%n", record.key(), record.value());
            }
        }
    }
}

这个消费者将订阅my-topic主题,并打印接收到的消息。
kafka:大规模实时数据流的必选_第4张图片

基于springboot整合kafka

步骤1:添加依赖

首先,在您的Spring Boot项目的pom.xml文件中添加Spring Kafka依赖:

<dependency>
    <groupId>org.springframework.kafkagroupId>
    <artifactId>spring-kafkaartifactId>
dependency>

步骤2:配置Kafka连接信息

在application.properties或application.yml中配置Kafka的连接信息,例如:

spring.kafka.bootstrap-servers=127.0.0.1:9092

您还可以配置其他Kafka相关属性,如序列化器、反序列化器等。

步骤3:创建Kafka生产者

创建一个Kafka生产者类,用于发送消息到Kafka主题:

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class KafkaProducer {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public KafkaProducer(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

步骤4:创建Kafka消费者

创建一个Kafka消费者类,用于从Kafka主题接收消息:

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class KafkaConsumer {

    @KafkaListener(topics = "your-topic-name")
    public void receiveMessage(String message) {
        // 处理接收到的消息
    }
}

步骤5:发送和接收消息

在您的服务或控制器中,使用KafkaProducer来发送消息,然后KafkaConsumer会监听并接收消息。

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

    private final KafkaProducer kafkaProducer;
	@Autowired
	private KafkaTemplate template;

    @Autowired
    public KafkaController(KafkaProducer kafkaProducer) {
        this.kafkaProducer = kafkaProducer;
    }

    @PostMapping("/send")
    public ResponseEntity<String> sendMessage(@RequestParam String message) {
        kafkaProducer.sendMessage("your-topic-name", message);
        return ResponseEntity.ok("Message sent to Kafka topic");
    }

    @GetMapping("/sends/{input}")
    public ResponseEntity<String> sentToKafka(@PathVariable String input) {
        this.template.send("your-topic-name", input);
        return ResponseEntity.ok(input);
    }
}

结论

Apache Kafka是一个强大的流媒体平台,用于构建实时数据处理系统。通过主题、分区、生产者和消费者的组合,Kafka能够轻松处理大规模的数据流。这只是Kafka的入门,它还具有更多高级功能和配置选项,可满足各种实际应用的需求。

你可能感兴趣的:(kafka,linq,分布式)