【Kafka】对 kafka 消费程序客户端进行监控采集

已于 2024-07-30 11:41:28 修改
阅读量846 收藏 13
点赞数 13
分类专栏： Kafka 文章标签： kafka linq 分布式
于 2024-07-30 11:28:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrerlou/article/details/140791475
版权

前言

对于 Kafka 组件而言，我们通常会对 kafka 服务端添加一些监控，来确保服务的稳定性，虽然有 kafka-exporter 来对消费者进行监控，但是指标很少，对于生产者和消费者更细粒度的监控就无法做到了。只能将监控部署在客户端上，这样我们就能拿到更加详细的监控数据。

例如：对于消费者来说，我们可以获取到消费者重平衡次数，每次poll 数据的条数等等。

这里梳理下如何对消费者添加 JMX 监控。

一、所需组件

这里我们只针对于 JAVA 语言的 KAFKA 客户端为例，需要以下东西：

  • kafka-client:3.4.1
  • JMX-exporter

需要提前准备好 kafka 服务和创建好topic。

二、编写测试代码

1. pom 文件

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <kafka.version>3.4.1</kafka.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>${kafka.version}</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2. 生产者代码

public class ProducerDemo {

    public static void main(String[] args) {
        //主题（当主题不存在，自动创建主题）
        String topic = "test";
        //配置
        Properties properties = new Properties();
        //kafka服务器地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.195.132:9092");
        //反序列化器
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class);

        //生产者
        KafkaProducer<String,String> kafkaProducer = new KafkaProducer(properties);

        //生产信息
        for (int i = 0; i < 100; i++) {
            String msg = String.format("hello,第%d条信息", i);
            //消息（key可以为null,key值影响消息发往哪个分区）
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(topic, String.valueOf(i), msg);
            //发送
            kafkaProducer.send(producerRecord);
            System.out.println("发送第"+i+"条信息");
        }
        //关闭
        kafkaProducer.close();
    }
}

3. 消费者代码

public class ConsumerDemo {

    public static void main(String[] args) throws Exception{
        //主题
        String topic = "test";

        //配置
        Properties properties = new Properties();
        //kafka服务器地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.195.132:9092");
        //k，v的序列化器
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class);
        //消费者分组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"Consumer-Group-1");
        //offset重置模式
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

        //消费者
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer(properties);
        //订阅（可以订阅多个主题）
        kafkaConsumer.subscribe(Collections.singletonList(topic));

        //消费
        while (true){
            //获取信息
            ConsumerRecords<String, String> records = kafkaConsumer.poll(Duration.ofMillis(1000));
            //遍历
            records.forEach(o->{
                System.out.println(String.format("topic==%s,offset==%s,key==%s,value==%s",o.topic(),o.offset(),o.key(),o.value()));
            });
            //睡眠
            Thread.sleep(500);
        }
    }
}

4. 打包

mvn clean package

5. 测试生产和消费

生产数据测试：

java -cp kafka-1.0-jar-with-dependencies.jar      ProducerDemo

在这里插入图片描述
消费数据测试：

java -cp kafka-1.0-jar-with-dependencies.jar      ConsumerDemo

在这里插入图片描述

三、使用jmx-agent

1. 下载

https://repo1.maven.org/maven2/io/prometheus/jmx/jmx_prometheus_javaagent/0.18.0/jmx_prometheus_javaagent-0.18.0.jar

2. 编写kafka-client.yaml

---
lowercaseOutputName: true
lowercaseOutputLabelNames: true
whitelistObjectNames:
  - "kafka.consumer:*"
  - "kafka.producer:*"
blacklistObjectNames:
  - "kafka.admin.client:*"
  - "kafka.consumer:type=*,id=*"
  - "kafka.producer:type=*,id=*"
  - "kafka.*:type=kafka-metrics-count,*"
rules:
  # "kafka.consumer:type=app-info,client-id=*"
  # "kafka.producer:type=app-info,client-id=*"
  - pattern: "kafka.(.+)<type=app-info, client-id=(.+)><>(.+): (.+)"
    value: 1
    name: kafka_$1_app_info
    cache: true
    labels:
      client_type: $1
      client_id: $2
      $3: $4
    type: UNTYPED
  # "kafka.consumer:type=consumer-metrics,client-id=*, protocol=*, cipher=*"
  # "kafka.consumer:type=type=consumer-fetch-manager-metrics,client-id=*, topic=*, partition=*"
  # "kafka.producer:type=producer-metrics,client-id=*, protocol=*, cipher=*"
  - pattern: "kafka.(.+)<type=(.+), (.+)=(.+), (.+)=(.+), (.+)=(.+)><>(.+):"
    name: kafka_$1_$2_$9
    type: GAUGE
    cache: true
    labels:
      client_type: $1
      $3: "$4"
      $5: "$6"
      $7: "$8"
  # "kafka.consumer:type=consumer-node-metrics,client-id=*, node-id=*"
  # "kafka.consumer:type=consumer-fetch-manager-metrics,client-id=*, topic=*"
  # "kafka.producer:type=producer-node-metrics,client-id=*, node-id=*"
  # "kafka.producer:type=producer-topic-metrics,client-id=*, topic=*"
  - pattern: "kafka.(.+)<type=(.+), (.+)=(.+), (.+)=(.+)><>(.+):"
    name: kafka_$1_$2_$7
    type: GAUGE
    cache: true
    labels:
      client_type: $1
      $3: "$4"
      $5: "$6"
  # "kafka.consumer:type=consumer-fetch-manager-metrics,client-id=*"
  # "kafka.consumer:type=consumer-metrics,client-id=*"
  # "kafka.producer:type=producer-metrics,client-id=*"
  - pattern: "kafka.(.+)<type=(.+), (.+)=(.+)><>(.+):"
    name: kafka_$1_$2_$5
    type: GAUGE
    cache: true
    labels:
      client_type: $1
      $3: "$4"
  - pattern: "kafka.(.+)<type=(.+)><>(.+):"
    name: kafka_$1_$2_$3
    cache: true
    labels:
      client_type: $1

yaml 参考：https://github.com/confluentinc/jmx-monitoring-stacks/blob/main/shared-assets/jmx-exporter/kafka_client.yml

3. 重新启动消费程序

java -cp kafka-1.0-jar-with-dependencies.jar -javaagent:/opt/javaProject/jmx_prometheus_javaagent-0.18.0.jar=1234:/opt/javaProject/kafka_client.yml ConsumerDemo
4. 打开web ui

访问http://xxx.xxx.xxx.xxx:1234
在这里插入图片描述
这里就能看到我们采集到了kafka 消费者实例的详细指标。我们就可以和Prometheus进行集成，这里就不详细介绍了。

四、具体指标

想要获取更多的指标和指标具体的用途可以参考官网的文档
https://kafka.apache.org/documentation/#consumer_monitoring

具体指标如下：
以下是添加了中文翻译后的Kafka Consumer Metrics表格：

Consumer Coordinator Metrics

METRIC NAMEDESCRIPTIONMBEAN NAME中文描述
commit-latency-avgThe average time taken for a commit requestkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)提交请求的平均时间
commit-latency-maxThe max time taken for a commit requestkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)提交请求的最大时间
commit-rateThe number of commit calls per secondkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每秒提交调用次数
commit-totalThe total number of commit callskafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)提交调用的总次数
assigned-partitionsThe number of partitions currently assigned to this consumerkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)当前分配给该消费者的分区数量
heartbeat-response-time-maxThe max time taken to receive a response to a heartbeat requestkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)接收到心跳请求响应的最大时间
heartbeat-rateThe average number of heartbeats per secondkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每秒心跳次数的平均值
heartbeat-totalThe total number of heartbeatskafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)心跳的总次数
join-time-avgThe average time taken for a group rejoinkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)加入组的平均时间
join-time-maxThe max time taken for a group rejoinkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)加入组的最大时间
join-rateThe number of group joins per secondkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每秒加入组的次数
join-totalThe total number of group joinskafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)加入组的总次数
sync-time-avgThe average time taken for a group synckafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)同步组的平均时间
sync-time-maxThe max time taken for a group synckafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)同步组的最大时间
sync-rateThe number of group syncs per secondkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每秒同步组的次数
sync-totalThe total number of group syncskafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)同步组的总次数
rebalance-latency-avgThe average time taken for a group rebalancekafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)组重新平衡的平均时间
rebalance-latency-maxThe max time taken for a group rebalancekafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)组重新平衡的最大时间
rebalance-latency-totalThe total time taken for group rebalances so farkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)到目前为止组重新平衡的总时间
rebalance-totalThe total number of group rebalances participatedkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)参与的组重新平衡总次数
rebalance-rate-per-hourThe number of group rebalance participated per hourkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每小时参与的组重新平衡次数
failed-rebalance-totalThe total number of failed group rebalanceskafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)失败的组重新平衡总次数
failed-rebalance-rate-per-hourThe number of failed group rebalance events per hourkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)每小时失败的组重新平衡事件次数
last-rebalance-seconds-agoThe number of seconds since the last rebalance eventkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)自上次重新平衡事件以来的秒数
last-heartbeat-seconds-agoThe number of seconds since the last controller heartbeatkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)自上次控制器心跳以来的秒数
partitions-revoked-latency-avgThe average time taken by the on-partitions-revoked rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)分区撤销重新平衡监听器回调的平均时间
partitions-revoked-latency-maxThe max time taken by the on-partitions-revoked rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)分区撤销重新平衡监听器回调的最大时间
partitions-assigned-latency-avgThe average time taken by the on-partitions-assigned rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)分配分区重新平衡监听器回调的平均时间
partitions-assigned-latency-maxThe max time taken by the on-partitions-assigned rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)分配分区重新平衡监听器回调的最大时间
partitions-lost-latency-avgThe average time taken by the on-partitions-lost rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)丢失分区重新平衡监听器回调的平均时间
partitions-lost-latency-maxThe max time taken by the on-partitions-lost rebalance listener callbackkafka.consumer:type=consumer-coordinator-metrics,client-id=([-.\w]+)丢失分区重新平衡监听器回调的最大时间

Consumer Fetch Metrics

METRIC NAMEDESCRIPTIONMBEAN NAME中文描述
bytes-consumed-rateThe average number of bytes consumed per secondkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每秒消费的字节平均数量
bytes-consumed-totalThe total number of bytes consumedkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”消费的字节总数
fetch-latency-avgThe average time taken for a fetch requestkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”提取请求的平均时间
fetch-latency-maxThe max time taken for any fetch requestkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”提取请求的最大时间
fetch-rateThe number of fetch requests per secondkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每秒提取请求的次数
fetch-size-avgThe average number of bytes fetched per requestkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每次请求提取的字节平均数量
fetch-size-maxThe maximum number of bytes fetched per requestkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每次请求提取的字节最大数量
fetch-throttle-time-avgThe average throttle time in mskafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”平均限速时间（毫秒）
fetch-throttle-time-maxThe maximum throttle time in mskafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”最大限速时间（毫秒）
fetch-totalThe total number of fetch requestskafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”提取请求的总次数
records-consumed-rateThe average number of records consumed per secondkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每秒消费的记录平均数量
records-consumed-totalThe total number of records consumedkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”消费的记录总数
records-lag-maxThe maximum lag in terms of number of records for any partition in this windowkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”任一分区的记录最大滞后数量
records-lead-minThe minimum lead in terms of number of records for any partition in this windowkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”任一分区的记录最小领先数量
records-per-request-avgThe average number of records in each requestkafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”每次请求的记录平均数量
bytes-consumed-rateThe average number of bytes consumed per second for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”每秒消费的字节平均数量（按主题）
bytes-consumed-totalThe total number of bytes consumed for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”消费的字节总数（按主题）
fetch-size-avgThe average number of bytes fetched per request for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”每次请求提取的字节平均数量（按主题）
fetch-size-maxThe maximum number of bytes fetched per request for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”每次请求提取的字节最大数量（按主题）
records-consumed-rateThe average number of records consumed per second for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”每秒消费的记录平均数量（按主题）
records-consumed-totalThe total number of records consumed for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”消费的记录总数（按主题）
records-per-request-avgThe average number of records in each request for a topickafka.consumer:type=consumer-fetch-manager-metrics,client-id=“{client-id}”,topic=“{topic}”每次请求的记录平均数量（按主题）
preferred-read-replicaThe current read replica for the partition, or -1 if reading from leaderkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”当前分区的读取副本，若从领导者读取则为-1
records-lagThe latest lag of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的最新滞后数量
records-lag-avgThe average lag of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的平均滞后数量
records-lag-maxThe max lag of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的最大滞后数量
records-leadThe latest lead of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的最新领先数量
records-lead-avgThe average lead of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的平均领先数量
records-lead-minThe min lead of the partitionkafka.consumer:type=consumer-fetch-manager-metrics,partition=“{partition}”,topic=“{topic}”,client-id=“{client-id}”分区的最小领先数量
kiraraLou
关注
  • 13
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot+Kafka实战生产级Kafka消费组
程序员光剑
08-06 2501
Kafka是一个开源分布式消息系统，最初由LinkedIn开发，之后成为Apache项目的一部分。Kafka主要用于大数据实时流处理，具有低延迟、高吞吐量等特点。本文将会从基本概念、术语说明、原理及应用场景三个方面对Kafka进行详细介绍。Kafka作为一个分布式系统，需要配合Zookeeper实现主备、容错等功能。因此在实际中部署Kafka集群至少需要2台服务器，其中一台为zookeeper服务器。
kafka监控工具
09-29
kafka的监控工具，主要通过在windows客户端连接zookeeper，监控kafka运行的相关信息。
kafka客户端生产者消费者kafka可视化工具（可生产和消费消息）
a342874650的专栏
02-04 3021
因在工作中经常有用到kafka做消息的收发，每次调试过程中，经常需要查看接收的消息内容以及人为发送消息，从网上搜寻了一下，找到的工具大部分都是Kafka Tool，此工具功能还比较全面，但是操作起来个人认为并不是那么方便，于是，就萌生了自己写一个简单又好用的kafka客户端的想法。
Kafka Client客户端操作详解
最新发布
qq_44027353的博客
08-08 1828
Kafka 客户端详细属性介绍
apache kafka监控系列-KafkaOffsetMonitor
热门推荐
李志涛的专栏
05-27 3万+
最近kafka server消息服务上线了，基于jmx指标参数也写到zabbix中了，但总觉得缺少点什么东西，可视化可操作的界面。zabbix中数据比较分散，不能集中看整个集群情况。或者一个cluster中broker列表，自己写web-console比较耗时耗力，用原型工具画了一些管理界面东西，关键自己也不前端方面技术，这方面比较薄弱。这不开源社区提供了kafka的web管理平台KafkaOffsetMonitor.就迅速拿过来运行。大家不要着急，马上娓娓道来。
Kafka监控工具汇总
weixin_30416497的博客
08-23 556
对于大数据集群来说，监控功能是非常必要的，通过日志判断故障低效，我们需要完整的指标来帮我们管理Kafka集群。本文讨论Kafka的监控以及一些常用的第三方监控工具。 一、Kafka Monitoring 首先介绍kafka的监控原理，第三方工具也是通过这些来进行监控的，我们也可以自己去是实现监控，官网关于监控的文档地址如下： http://kafka.apache.org/docume...
# Kafka_深入探秘者（10）：kafka 监控
段子手168的博客
06-28 2898
# Kafka_深入探秘者（10）：kafka 监控 第10章 01-JMX 第10章 02-编程获取指标 第10章 03-监控指标了解
字节架构师：来说说 Kafka 的消费者客户端详解，你都搞懂了吗？
公众号：该用户快成仙了
09-24 702
前言 前面讲解了 Kafka 的生产者，而与生产对应的就是消费者，程序中可以通过 KafkaConsumer 来订阅主题，并从订阅的主题中拉取消息。而 Kafka 中消费者比生产者多了个组的概念，也称消费者组，从而提升单机的消费速度。本文将介绍下消费者与消费者组的概念，然后再对客户端开发进行详细讲解。 一、消费者与消费者组 消费者负责订阅 Kafka 中的主题，并且从上面拉取消息，但与生产者不同的是它增加了消费者组的概念，这是因为很多时候 Kafka 的消费者在消费消息的时候经常会做一些高延时的动作，
Kafka 处理器客户端介绍
weixin_33889245的博客
06-01 116
【编者按】本文作者为 Bill Bejeck，主要介绍如何有效利用新的 Apache Kafka 客户端来满足数据处理需求。文章系国内 ITOM 管理平台 OneAPM 编译呈现，以下为正文。 如果你使用的系统需要传输大量数据，就算你没用过 Kafka，很有可能已经听说过它了。从较高层面来说，Kafka 是一个对错误零容忍、分布式的发布订...
kafka监控
cclucc的博客
09-21 464
编辑文章 监控策略 1、Kafka总体监控 leader 选举频率：kafka.controller:type=ControllerStats,name=LeaderElectionRateAndTimeMs 2、Kafka Broker监控 kafka集群中Broker列表,broker运行状况,包括node下线，活跃数量 Broker是否提供服务 失败的生产消息请求数量：阈值？ 失败...
Kafka监控
weixin_43497444的博客
03-19 129
1.Kafka Eagle 1.修改 kafka 启动命令 修改 kafka-server-start.sh 命令中 if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then export KAFKA_HEAP_OPTS="-Xmx1G -Xms1G" fi 为 if [ "x$KAFKA_HEAP_OPTS" = "x" ]; then export KAFKA_HEA...
kafka客户端手册
02-28
Kafka客户端手册主要介绍如何利用Kafka进行消息事件通信，尤其强调其消息持久化、高吞吐量及分布式特性。本手册适用于那些希望集成Kafka功能来增强自身应用稳定性和处理能力的开发者。 **核心功能：** - **消息持久...
python消费kafka数据nginx日志实时_Openresty+Lua+Kafka实现日志实时采集
weixin_39997311的博客
12-19 378
简介在很多数据采集场景下，Flume作为一个高性能采集日志的工具，相信大家都知道它。许多人想起Flume这个组件能联想到的大多数都是Flume跟Kafka相结合进行日志的采集，这种方案有很多他的优点，比如高性能、高吞吐、数据可靠性等。但是我们如果要求对日志进行实时的采集，这显然不是一个好的解决方案。原因如下：就目前来说，Flume能支持实时监控一个目录的数据文件，一旦对某个目录的文件采集完成，就会...
Kafka监控与指标解析-UnderReplicatedPartitions
JHIII的博客
08-31 2051
1 Kafka监控2 指标采集和统计机制3 常见指标分析1 Kafka监控Kafka 使用 Yammer Metrics 在服务器中报告指标,Java 客户端使用 Kafka Metrics，这是一个内置的指标注册表. 两者都通过 JMX 公开指标启用JMX并上报指标Kafka 默认禁用远程 JMX，Kafka启动JMX方式在这里插入图片描述方式二：在启动脚本里面 对JMX_PORT 赋值，在增加一句在这里插入图片描述然后再启动脚本,JMX就会自动开启了方式三：在IDEA中启用JMX。...
Kafka的运维利器-AdminClient
微信搜：import_bigdata，大数据领域硬核原创作者
11-17 1434
点击上方蓝色字体，选择“设为星标”回复”面试“获取更多惊喜前言一般情况下，我们都习惯使用kafka-topics.sh脚本来管理主题，但有些时候我们希望将主题管理类的功能集成到公司内部的系...
Kafka之监控
qq_43688472的博客
01-14 487
1.生产者和消费者的曲线趋势速度是一样的。 没有消息堆积 及时的消费 ss–&gt;hbase 么有压力 曲线趋势不吻合。消息堆积，要及时消费 2.为什么消费者曲线比 生产者曲线在同一时刻度要高？ 消费者输出字段，要比生产者多 例子： 生产者 send(null,“hello ruoze”) 消费者 { topic： g5 partition: p2 offset: 10000 value：...
kafka消费者监听消费
日日留心的技术专栏
07-02 401
消费成功调用 ack.acknowledge()方法确认。
kafka 监控
wangbaosongmsn的博客
07-27 166
https://xuemengran.blog.csdn.net/article/details/103875884 KafkaOffsetMonitor-assembly-0.4.1-SNAPSHOT.jar KafkaOffsetMonitor-assembly-0.2.1.jar package com.test; import java.util.*; import java.util.Map.Entry; import kafka.api.PartitionOffsetRequestIn
kafka 消费者客户端
09-01
Kafka消费者客户端是用于从Kafka集群中读取消息的应用程序。它允许应用程序订阅一个或多个主题，并从每个主题的一个或多个分区中消费消息。 Kafka提供了多种编程语言的消费者客户端，包括Java、Python、Go等。每个语言的客户端都提供了一组API，使开发人员可以轻松地编写消费者应用程序。 在使用Kafka消费者客户端时，需要指定要连接的Kafka集群的地址和端口，以及要订阅的主题和分区。消费者客户端会自动进行负载均衡，在多个消费者之间平均分配分区以实现高吞吐量。 一旦消费者客户端连接到Kafka集群并订阅了主题，它就可以开始从分区中读取消息。消费者可以按照自己的需求控制消息的消费速率，并可以在消费过程中提交偏移量以确保消息的可靠性。 消费者客户端还可以使用一些可选的配置选项，如自动提交偏移量、消息过滤等。这些选项可以根据具体的应用需求进行配置。 总的来说，Kafka消费者客户端是一种强大的工具，可以帮助开发人员构建可靠的消息消费应用程序，并从Kafka集群中获取高性能的消息流。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值