首页手记 Kafka消息丢失学习：新手入门教程

Kafka消息丢失学习：新手入门教程

标签：

大数据中间件

概述

本文深入探讨了Kafka消息丢失的原因及其解决方案，涵盖生产者端、传输过程和消费者端可能出现的问题。文章详细介绍了如何通过优化配置参数、使用确认机制（ACK）以及实施数据备份与日志清理策略来避免消息丢失。文章还提供了检测消息丢失的方法，包括日志审查、消息追踪与审计以及使用监控工具。了解这些内容有助于读者更好地进行Kafka消息丢失学习。

Kafka基础概念

简介与背景

Apache Kafka 是一个分布式的流处理平台，最初由 LinkedIn 开发，用于处理大量实时数据流。Kafka 被设计为可以处理高吞吐量、持久性和容错性的数据流，广泛应用于日志聚合、指标收集、流处理等领域。

Kafka架构解析

Kafka 的核心概念包括生产者、消费者、代理（Broker）、主题（Topic）和分区（Partition）。

生产者（Producer）：生成消息并发送到 Kafka 代理。
消费者（Consumer）：从 Kafka 代理中读取消息。
代理（Broker）：Kafka 集群中的一个节点，负责存储和提供数据。
主题（Topic）：消息分类的逻辑集合。每个消息都属于一个特定的主题。
分区（Partition）：主题的物理分片，分布在多个代理上。每个分区都是一个有序的、不可变的消息序列。

主题（Topic）、分区（Partition）、日志（Log）

主题（Topic）

主题是 Kafka 中消息的分类逻辑容器，每个生产者发送的消息都会分配到一个特定的主题。主题是命名的、持久的、多分区的。

public void sendMessage(String topic, String message) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
    producer.send(record);
    producer.close();
}

分区（Partition）

主题可以被划分为多个分区，每个分区是一个有序、不可变的消息序列。分区中的消息按照严格递增的偏移量顺序存储。

public void sendMessageWithPartition(String topic, String message, int partition) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, partition, message);
    producer.send(record);
    producer.close();
}

日志（Log）

每个分区对应一个日志文件，该文件存储该分区中所有的消息。每个日志文件都按照偏移量进行索引，从而可以高效地进行消息的读取和追加。

Kafka消息传递流程

生产者（Producer）发送消息

生产者将消息发送到 Kafka 代理。每个消息都会被分配到一个特定的主题，并按照顺序写入该主题的一个或多个分区。生产者可以选择将消息发送到特定的分区，或让 Kafka 代理决定分区。

public void sendMessage(String topic, String message) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
    producer.send(record);
    producer.close();
}

消息持久化机制

Kafka 使用日志文件来持久化消息。每个分区对应一个日志文件，文件中的消息按照偏移量顺序存储。持久化确保消息在代理故障或重启后仍能被读取。

消费者（Consumer）消费消息

消费者从 Kafka 代理中读取消息。消费者可以订阅一个或多个主题，并按照分区中的偏移量顺序读取消息。消费者可以提交偏移量，表明它已经读取并处理了某个偏移量的消息。

public void consumeMessage(String topic) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("group.id", "test");
    props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
    consumer.subscribe(Arrays.asList(topic));
    while (true) {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

消息丢失的原因

生产者端原因

生产者发送消息时可能出现以下问题：

生产者发送消息时出现网络故障。
生产者未等待确认（ACK）机制，直接发送消息。
生产者配置不当（如参数设置不合理）。

传输过程中原因

消息在传输过程中可能出现以下问题：

网络故障导致消息未到达代理。
代理内存不足或磁盘空间不足，导致消息丢失。
代理配置不当，如日志清理策略不合适。

消费者端原因

消费者消费消息时可能出现以下问题：

消费者消费消息时出现网络故障。
消费者未正确提交偏移量，导致消息重复消费。
消费者配置不当（如参数设置不合理）。

如何避免消息丢失

配置参数优化

优化生产者、消费者和代理的配置参数，确保消息的可靠传输。

生产者配置参数：

acks：设置为 -1 或 all，以确保消息被完整发送到代理，并被所有副本确认。
retries：设置合理的重试次数，以应对网络故障。
linger.ms：设置合适的值，以增加消息的批量传输，提高吞吐量。
batch.size：设置合适的值，以增加消息的批量传输，提高吞吐量。
max.block.ms：设置合理的等待时间，以防止生产者阻塞。

public void sendMessage(String topic, String message) {
  Properties props = new Properties();
  props.put("bootstrap.servers", "localhost:9092");
  props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  props.put("acks", "all");
  props.put("retries", 3);
  props.put("linger.ms", 5);
  props.put("batch.size", 1024);
  props.put("max.block.ms", 1000);
  Producer<String, String> producer = new KafkaProducer<String, String>(props);
  ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
  producer.send(record, (metadata, exception) -> {
      if (exception != null) {
          exception.printStackTrace();
      } else {
          System.out.printf("offset = %d, timestamp = %d%n", metadata.offset(), metadata.timestamp());
      }
  });
  producer.close();
}

消费者配置参数：

auto.offset.reset：设置为 earliest 或 latest，以确保消费者从指定位置开始消费。
enable.auto.commit：设置为 true，以自动提交偏移量。
max.poll.records：设置合理的值，以控制每次轮询的最大记录数。
session.timeout.ms：设置合理的值，以控制会话超时时间。

public void consumeMessage(String topic) {
  Properties props = new Properties();
  props.put("bootstrap.servers", "localhost:9092");
  props.put("group.id", "test");
  props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
  props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
  props.put("auto.offset.reset", "earliest");
  props.put("enable.auto.commit", "true");
  props.put("max.poll.records", 10);
  props.put("session.timeout.ms", 30000);
  KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
  consumer.subscribe(Arrays.asList(topic));
  while (true) {
      ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
      for (ConsumerRecord<String, String> record : records) {
          System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
      }
  }
}

代理配置参数：

log.retention.hours：设置合适的保留时间，以避免日志文件被过早删除。
log.retention.bytes：设置合适的保留大小，以避免日志文件被过早删除。
log.segment.bytes：设置合适的日志文件大小，以避免频繁的日志文件切换。
replication.factor：设置合适的副本数量，以提高容错性。

public void configureBroker(String brokerId) {
  Properties props = new Properties();
  props.put("zookeeper.connect", "localhost:2181");
  props.put("broker.id", brokerId);
  props.put("log.flush.interval.messages", 1000);
  props.put("log.retention.hours", 72);
  props.put("log.retention.bytes", 1073741824);
  props.put("log.segment.bytes", 10485760);
  props.put("replication.factor", 3);
  props.put("zookeeper.connection.timeout.ms", 6000);
  props.put("advertised.host.name", "localhost");
  props.put("advertised.port", 9092);
  props.put("listeners", "PLAINTEXT://localhost:9092");
  KafkaServer server = new KafkaServerStartable(props);
  server.startup();
}

使用确认机制（ACK）

生产者发送消息时，可以选择等待确认机制（ACK）以确保消息被正确发送。根据 acks 参数的设置，生产者可以等待不同的确认级别：

acks=0：生产者不等待任何确认，直接发送消息。
acks=1：生产者等待代理确认消息已被接收到。
acks=all：生产者等待所有副本确认消息已被接收到。

public void sendMessage(String topic, String message) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("acks", "all");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
    producer.send(record, (metadata, exception) -> {
        if (exception != null) {
            exception.printStackTrace();
        } else {
            System.out.printf("offset = %d%n", metadata.offset());
        }
    });
    producer.close();
}

数据备份与日志清理策略

使用数据备份和适当的数据清理策略，确保消息的持久性和可靠性。

数据备份：通过配置合适的副本数量，确保消息在多个节点上进行备份。
日志清理策略：设置合适的数据保留策略，避免过早删除重要的日志文件。

public void configureBroker(String brokerId) {
    Properties props = new Properties();
    props.put("zookeeper.connect", "localhost:2181");
    props.put("broker.id", brokerId);
    props.put("log.flush.interval.messages", 1000);
    props.put("log.retention.hours", 72);
    props.put("log.retention.bytes", 1073741824);
    props.put("log.segment.bytes", 10485760);
    props.put("replication.factor", 3);
    props.put("zookeeper.connection.timeout.ms", 6000);
    props.put("advertised.host.name", "localhost");
    props.put("advertised.port", 9092);
    props.put("listeners", "PLAINTEXT://localhost:9092");
    KafkaServer server = new KafkaServerStartable(props);
    server.startup();
}

检测消息丢失的方法

日志审查

审查 Kafka 日志文件，查看消息是否成功发送和接收。通过日志审查，可以发现消息丢失的原因，如网络故障、磁盘空间不足等。

public void logReview(String logFile) {
    try (BufferedReader reader = new BufferedReader(new FileReader(logFile))) {
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.contains("Error")) {
                System.out.println(line);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

消息追踪与审计

通过消息追踪和审计，可以记录每个消息的发送和接收时间，以及偏移量等信息。这有助于发现消息丢失的根源。

消息追踪：通过配置生产者和消费者，记录消息的发送和接收时间。
消息审计：通过定期审计消息的发送和接收情况，发现异常情况。

public void sendMessage(String topic, String message) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("acks", "all");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
    producer.send(record, (metadata, exception) -> {
        if (exception != null) {
            exception.printStackTrace();
        } else {
            System.out.printf("offset = %d, timestamp = %d%n", metadata.offset(), metadata.timestamp());
        }
    });
    producer.close();
}

public void consumeMessage(String topic) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("group.id", "test");
    props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
    consumer.subscribe(Arrays.asList(topic));
    while (true) {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("offset = %d, timestamp = %d, key = %s, value = %s%n", record.offset(), record.timestamp(), record.key(), record.value());
        }
    }
}

监控工具使用

使用监控工具，可以实时监控 Kafka 系统的运行状态，及时发现和解决消息丢失的问题。

监控工具：如 Kafka Manager、Kafka Monitor、Ganglia、Prometheus 等。
监控指标：如生产者发送消息的延迟、消费者的消费速率、代理的磁盘使用率、网络带宽使用率等。

public void monitorKafka() {
    try (JMXConnector connector = JMXConnectorFactory.connect(new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/jmxrmi"))) {
        MBeanServerConnection connection = connector.getMBeanServerConnection();
        ObjectName name = new ObjectName("kafka.server:type=BrokerTopicMetrics,topic=*,client-id=producer");
        for (ObjectName objectName : connection.queryNames(name, null)) {
            System.out.printf("Metric = %s, Value = %s%n", objectName.getKeyProperty("topic"), connection.getAttribute(objectName, "BytesInPerSec"));
        }
    } catch (IOException | MalformedObjectNameException | ReflectionException | InstanceNotFoundException | AttributeNotFoundException | MBeanException | IntrospectionException e) {
        e.printStackTrace();
    }
}

实际案例分析

典型场景解析

假设我们有一个电子商务网站，需要处理大量的订单消息。为了确保订单消息的可靠传递，我们采取了以下措施：

生产者端：配置了合适的 acks=all，确保消息被所有副本确认。
消费者端：设置了自动提交偏移量，确保消息不会被重复消费。
代理端：配置了合适的副本数量和数据保留策略，确保消息的持久性和可靠性。

public void configureProducer() {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("acks", "all");
    props.put("retries", 3);
    props.put("linger.ms", 5);
    props.put("batch.size", 1024);
    props.put("max.block.ms", 1000);
    KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);
}

public void configureConsumer() {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("group.id", "test");
    props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("auto.offset.reset", "earliest");
    props.put("enable.auto.commit", "true");
    props.put("max.poll.records", 10);
    props.put("session.timeout.ms", 30000);
    KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
}

public void configureBroker(String brokerId) {
    Properties props = new Properties();
    props.put("zookeeper.connect", "localhost:2181");
    props.put("broker.id", brokerId);
    props.put("log.flush.interval.messages", 1000);
    props.put("log.retention.hours", 72);
    props.put("log.retention.bytes", 1073741824);
    props.put("log.segment.bytes", 10485760);
    props.put("replication.factor", 3);
    props.put("zookeeper.connection.timeout.ms", 6000);
    props.put("advertised.host.name", "localhost");
    props.put("advertised.port", 9092);
    props.put("listeners", "PLAINTEXT://localhost:9092");
    KafkaServer server = new KafkaServerStartable(props);
    server.startup();
}

解决方案与实践

通过上述配置，我们可以确保电子商务网站的订单消息的可靠传递。同时，我们通过日志审查和监控工具，实时监控系统运行状态，及时发现和解决消息丢失的问题。

public void sendMessage(String topic, String message) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    props.put("acks", "all");
    Producer<String, String> producer = new KafkaProducer<String, String>(props);
    ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, message);
    producer.send(record, (metadata, exception) -> {
        if (exception != null) {
            exception.printStackTrace();
        } else {
            System.out.printf("offset = %d, timestamp = %d%n", metadata.offset(), metadata.timestamp());
        }
    });
    producer.close();
}

public void consumeMessage(String topic) {
    Properties props = new Properties();
    props.put("bootstrap.servers", "localhost:9092");
    props.put("group.id", "test");
    props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
    props.put("auto.offset.reset", "earliest");
    props.put("enable.auto.commit", "true");
    props.put("max.poll.records", 10);
    KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
    consumer.subscribe(Arrays.asList(topic));
    while (true) {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("offset = %d, timestamp = %d, key = %s, value = %s%n", record.offset(), record.timestamp(), record.key(), record.value());
        }
    }
}

public void logReview(String logFile) {
    try (BufferedReader reader = new BufferedReader(new FileReader(logFile))) {
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.contains("Error")) {
                System.out.println(line);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void monitorKafka() {
    try (JMXConnector connector = JMXConnectorFactory.connect(new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/jmxrmi"))) {
        MBeanServerConnection connection = connector.getMBeanServerConnection();
        ObjectName name = new ObjectName("kafka.server:type=BrokerTopicMetrics,topic=*,client-id=producer");
        for (ObjectName objectName : connection.queryNames(name, null)) {
            System.out.printf("Metric = %s, Value = %s%n", objectName.getKeyProperty("topic"), connection.getAttribute(objectName, "BytesInPerSec"));
        }
    } catch (IOException | MalformedObjectNameException | ReflectionException | InstanceNotFoundException | AttributeNotFoundException | MBeanException | IntrospectionException e) {
        e.printStackTrace();
    }
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

繁星点点滴滴

手记
篇

粉丝

67

获赞与收藏

333

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30958 346

网络编程入门教程

20个小节 12735 240

Pandas 入门教程

25个小节 18632 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空