九、初探kafka消费者

已于 2022-07-21 22:22:45 修改
阅读量2.8k 收藏
点赞数 2
分类专栏： kafka 文章标签： kafka 分布式 zookeeper
于 2021-12-14 08:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34306010/article/details/121916943
版权

消费端参数配置

序号参数默认值等级描述
1bootstrap.servers高指定连接kafka集群所需的broker地址清单
2client.dns.lookupdefault中default,use_all_dns_ips,resolve_canonical_bootstrap_servers_only
3group.id高消费者隶属的消费组名称，如果设置为空会抛出异常：Exception in thread “main” org.apache.kafka.common.errors.InvalidGroupIdException:The configured groupId is Invalid
4group.instance.id中
5session.timeout.ms10000高
6heartbeat.interval.ms3000ms高当使用kafka分组管理功能时，心跳到消费者协调器之间的预计时间，心跳用于确保消费者的会话保持活动状态，当有新的消费者加入或离开组时方便重新平衡，该值必须必session.timeout.ms小，通常不高于1/3
7partition.assignment.strategyRangeAssignor中分区分配策略
8metadata.max.age.ms300000ms(5分钟)低用来配置元数据的过期时间，如果元数据在此参数所限定的时间范围内没有进行更新，则会被强制更新，即使没有任何分区变化或有新的broker加入
9enable.auto.commitTRUE中
10auto.commit.interval.ms5000低表示开启自动提交位移的时间间隔
11client.id低
12client.rack低
13max.partition.fetch.bytes1048576B(1MB)高配置每个分区里返回给Consumer的最大数据量，与fetch.max.bytes参数相似，超过不会影响
14send.buffer.bytes:131072B(128KB)中设置Socket发送消息缓冲区
15receive.buffer.bytes65536B(64KB)中用来设置Socket接收消息缓冲区的大小，如果设置为-1，则使用操作系统的默认值
16fetch.min.bytes1B高Consumer在一次拉取请求中能从kafka中拉取的最小数据量
17fetch.max.bytes5242880B(50M)中拉取的最大数据量，这个设置不是绝对的最大值，如果在第一个非空分区中拉取的第一条消息大于该值，那么该消息将仍然可以消费，kafka所能接受的最大消息,Message.max,bytes（对应于主题端参数max.message.bytes）来设置
18fetch.max.wait.ms500ms低指定kafka的等待时间
19reconnect.backoff.ms50ms低用来配置尝试重新连接指定主机之前的等待时间，避免频繁的连接主机
20reconnect.backoff.max.ms1000低
21retry.backoff.ms:100ms低用来配置尝试重新发送失败的请求到指定的主题分区之前的等待时间，避免频繁发送
22auto.offset.reetlatest中earliest、latest、none
23check.crcsTRUE低
24metrics.sample.window.ms30000低
25metrics.num.samples2低
26metrics.recording.levelINFOINFO，DEBUG
27metric.reporters低
28key.decerializer高解码方式
29value.decerializer高解码方式
30request.timeout.ms30000ms中用来配置Consumer等待请求响应的最长时间
31default.api.timeout.ms60 * 1000中
32connection.max.idle.ms540000ms(9分钟)中指定在多久之后关闭限制的链接
33interceptor.class低拦截器
34max.poll.records500条中配置Consumer在一次拉取请求中拉取的最大消息数
35max.poll.interval.ms300000中当通过消费组管理消费者时，该配置指定拉取消息新城最长空闲时间，若超过这个时间间隔还未发起poll操作，则消费组认为该消费组已离开了消费组，将进行再均衡操作
36exclude.internal.topicsTRUE中:指定kafka中的内部主题是否可以向消费者公开，默认为true，如果为true，则只能使用subscribe(Collection)的方式而不能使用subscribe(Pattern)的方式来订阅内部主题
37isolation.levelread_uncommitted中这个参数用来配置消费者的事务隔离级别，有效值为“read_uncommitted"和"read_committed"，表示消费者所消费到的位置，如果为read_committed，那么消费者就会忽略事务未提交的消息，只能消费到LSO(LastStableOffet)的位置，默认为read_uncommitted,可以消费到HW处的位置
38allow.auto.create.topicsTRUE中
39security.providers低
40security.protocol中

跟组重平衡有关的参数

  • session.timeout.ms
  • max.poll.interval.ms
  • heartbeat.interval.ms
  • group.id
  • group.instance.id
  • retry.backoff.ms
  • internal.leave.group.on.close

跟consumerMetadata有关的数据

  • retry.backoff.ms
  • metadata.max.age.ms
  • exclude.internal.topics
  • allow.auto.create.topics

consume启动样例

public class MyConsume {
    public static void main(String[] args) {
        Consumer<String,String> consumer = new KafkaConsumer<String, String>(MyConsume.getConsumeProp());
        consumer.subscribe(Collections.singletonList("test_2"));
        System.out.println("开始-------------------------------");
        while(true){
            ConsumerRecords<String,String> records = consumer.poll(Duration.ofMillis(1000));
            if(!records.isEmpty()) {
                Map<TopicPartition,OffsetAndMetadata> offsets = new HashMap<>();
                try {
                    for (TopicPartition partition : records.partitions()) {
                        List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
                        for (ConsumerRecord<String, String> record : partitionRecords) {
                            System.out.println("-----------------------------------"+record.value());
                        }
                        long lastConsumeOffset = partitionRecords.get(partitionRecords.size() - 1).offset();
                        offsets.put(partition,new OffsetAndMetadata(lastConsumeOffset+1));
                    }
                    consumer.commitAsync();

                }catch (Exception e){

                }
            }
        }
    }
    public static Properties getConsumeProp(){
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092,localhost:9093,localhost:9094");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,false);
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"mykafka-group");
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        return props;
    }
}

客户端初始化源码分析

org.apache.kafka.clients.consumer.KafkaConsumer#KafkaConsumer(java.util.Properties)

private KafkaConsumer(ConsumerConfig config, Deserializer<K> keyDeserializer, Deserializer<V> valueDeserializer) {
        try {
            //跟组重平衡有关的参数
            GroupRebalanceConfig groupRebalanceConfig = new GroupRebalanceConfig(config,
                    GroupRebalanceConfig.ProtocolType.CONSUMER);
            //初始化groupId、clientId
            this.groupId = Optional.ofNullable(groupRebalanceConfig.groupId);
            this.clientId = buildClientId(config.getString(CommonClientConfigs.CLIENT_ID_CONFIG), groupRebalanceConfig);

            LogContext logContext;

            // If group.instance.id is set, we will append it to the log context.
            if (groupRebalanceConfig.groupInstanceId.isPresent()) {
                logContext = new LogContext("[Consumer instanceId=" + groupRebalanceConfig.groupInstanceId.get() +
                        ", clientId=" + clientId + ", groupId=" + groupId.orElse("null") + "] ");
            } else {
                logContext = new LogContext("[Consumer clientId=" + clientId + ", groupId=" + groupId.orElse("null") + "] ");
            }

            this.log = logContext.logger(getClass());
            boolean enableAutoCommit = config.getBoolean(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG);
            if (!groupId.isPresent()) { // overwrite in case of default group id where the config is not explicitly provided
                if (!config.originals().containsKey(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG)) {
                    enableAutoCommit = false;
                } else if (enableAutoCommit) {
                    throw new InvalidConfigurationException(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG + " cannot be set to true when default group id (null) is used.");
                }
            } else if (groupId.get().isEmpty()) {
                log.warn("Support for using the empty group id by consumers is deprecated and will be removed in the next major release.");
            }

            log.debug("Initializing the Kafka consumer");
            this.requestTimeoutMs = config.getInt(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG);
            this.defaultApiTimeoutMs = config.getInt(ConsumerConfig.DEFAULT_API_TIMEOUT_MS_CONFIG);
            this.time = Time.SYSTEM;
            //客户端指标
            this.metrics = buildMetrics(config, time, clientId);
            this.retryBackoffMs = config.getLong(ConsumerConfig.RETRY_BACKOFF_MS_CONFIG);

            // 加载客户端自定义拦截器
            Map<String, Object> userProvidedConfigs = config.originals();
            userProvidedConfigs.put(ConsumerConfig.CLIENT_ID_CONFIG, clientId);
            List<ConsumerInterceptor<K, V>> interceptorList = (List) (new ConsumerConfig(userProvidedConfigs, false)).getConfiguredInstances(ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG,
                    ConsumerInterceptor.class);
            this.interceptors = new ConsumerInterceptors<>(interceptorList);
            //key及value序列化方式
            if (keyDeserializer == null) {
                this.keyDeserializer = config.getConfiguredInstance(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, Deserializer.class);
                this.keyDeserializer.configure(config.originals(), true);
            } else {
                config.ignore(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG);
                this.keyDeserializer = keyDeserializer;
            }
            if (valueDeserializer == null) {
                this.valueDeserializer = config.getConfiguredInstance(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, Deserializer.class);
                this.valueDeserializer.configure(config.originals(), false);
            } else {
                config.ignore(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG);
                this.valueDeserializer = valueDeserializer;
            }
            //offset重置策略
            OffsetResetStrategy offsetResetStrategy = OffsetResetStrategy.valueOf(config.getString(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG).toUpperCase(Locale.ROOT));
            //初始化SubscriptionState
            this.subscriptions = new SubscriptionState(logContext, offsetResetStrategy);
            ClusterResourceListeners clusterResourceListeners = configureClusterResourceListeners(keyDeserializer,
                    valueDeserializer, metrics.reporters(), interceptorList);
            //初始化ConsumerMetadata
            this.metadata = new ConsumerMetadata(retryBackoffMs,
                    config.getLong(ConsumerConfig.METADATA_MAX_AGE_CONFIG),
                    !config.getBoolean(ConsumerConfig.EXCLUDE_INTERNAL_TOPICS_CONFIG),
                    config.getBoolean(ConsumerConfig.ALLOW_AUTO_CREATE_TOPICS_CONFIG),
                    subscriptions, logContext, clusterResourceListeners);
            List<InetSocketAddress> addresses = ClientUtils.parseAndValidateAddresses(
                    config.getList(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG), config.getString(ConsumerConfig.CLIENT_DNS_LOOKUP_CONFIG));
            this.metadata.bootstrap(addresses);
            String metricGrpPrefix = "consumer";

            FetcherMetricsRegistry metricsRegistry = new FetcherMetricsRegistry(Collections.singleton(CLIENT_ID_METRIC_TAG), metricGrpPrefix);
            ChannelBuilder channelBuilder = ClientUtils.createChannelBuilder(config, time, logContext);
            IsolationLevel isolationLevel = IsolationLevel.valueOf(
                    config.getString(ConsumerConfig.ISOLATION_LEVEL_CONFIG).toUpperCase(Locale.ROOT));
            Sensor throttleTimeSensor = Fetcher.throttleTimeSensor(metrics, metricsRegistry);
            int heartbeatIntervalMs = config.getInt(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG);

            ApiVersions apiVersions = new ApiVersions();
            NetworkClient netClient = new NetworkClient(
                    new Selector(config.getLong(ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG), metrics, time, metricGrpPrefix, channelBuilder, logContext),
                    this.metadata,
                    clientId,
                    100, // a fixed large enough value will suffice for max in-flight requests
                    config.getLong(ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG),
                    config.getLong(ConsumerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG),
                    config.getInt(ConsumerConfig.SEND_BUFFER_CONFIG),
                    config.getInt(ConsumerConfig.RECEIVE_BUFFER_CONFIG),
                    config.getInt(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG),
                    ClientDnsLookup.forConfig(config.getString(ConsumerConfig.CLIENT_DNS_LOOKUP_CONFIG)),
                    time,
                    true,
                    apiVersions,
                    throttleTimeSensor,
                    logContext);
            this.client = new ConsumerNetworkClient(
                    logContext,
                    netClient,
                    metadata,
                    time,
                    retryBackoffMs,
                    config.getInt(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG),
                    heartbeatIntervalMs); //Will avoid blocking an extended period of time to prevent heartbeat thread starvation
            //获取分区分配策略
            this.assignors = getAssignorInstances(config.getList(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG), config.originals());

            // no coordinator will be constructed for the default (null) group id
            //初始化ConsumerCoordinator及ConsumerGroupMetadata
            this.coordinator = !groupId.isPresent() ? null :
                new ConsumerCoordinator(groupRebalanceConfig,
                        logContext,
                        this.client,
                        assignors,
                        this.metadata,
                        this.subscriptions,
                        metrics,
                        metricGrpPrefix,
                        this.time,
                        enableAutoCommit,
                        config.getInt(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG),
                        this.interceptors);
            this.fetcher = new Fetcher<>(
                    logContext,
                    this.client,
                    config.getInt(ConsumerConfig.FETCH_MIN_BYTES_CONFIG),
                    config.getInt(ConsumerConfig.FETCH_MAX_BYTES_CONFIG),
                    config.getInt(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG),
                    config.getInt(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG),
                    config.getInt(ConsumerConfig.MAX_POLL_RECORDS_CONFIG),
                    config.getBoolean(ConsumerConfig.CHECK_CRCS_CONFIG),
                    config.getString(ConsumerConfig.CLIENT_RACK_CONFIG),
                    this.keyDeserializer,
                    this.valueDeserializer,
                    this.metadata,
                    this.subscriptions,
                    metrics,
                    metricsRegistry,
                    this.time,
                    this.retryBackoffMs,
                    this.requestTimeoutMs,
                    isolationLevel,
                    apiVersions);
            //客户端统计指标
            this.kafkaConsumerMetrics = new KafkaConsumerMetrics(metrics, metricGrpPrefix);

            config.logUnused();
            AppInfoParser.registerAppInfo(JMX_PREFIX, clientId, metrics, time.milliseconds());
            log.debug("Kafka consumer initialized");
        } catch (Throwable t) {
            // call close methods if internal objects are already constructed; this is to prevent resource leak. see KAFKA-2121
            // we do not need to call `close` at all when `log` is null, which means no internal objects were initialized.
            if (this.log != null) {
                close(0, true);
            }
            // now propagate the exception
            throw new KafkaException("Failed to construct kafka consumer", t);
        }
    }

总结

客户端初始化主要做了以下几件事：
1、读一些配置
2、初始化SubscriptionState
3、初始化客户端指标fetch-throttle-time-avg，fetch-throttle-time-max
4、初始化客户端元数据 ConsumerMetadata
5、读取分区分配策略
6、初始化客户端协调器

  • 初始化消费组元数据 ConsumerGroupMetadata
  • 初始化消费组有关的统计指标
    7、初始化消费者有关的统计指标

客户端绑定topic源码分析

org.apache.kafka.clients.consumer.KafkaConsumer#subscribe(java.util.Collection<java.lang.String>, org.apache.kafka.clients.consumer.ConsumerRebalanceListener)

public void subscribe(Collection<String> topics, ConsumerRebalanceListener listener) {
        acquireAndEnsureOpen();
        try {
            //校验groupId
            maybeThrowInvalidGroupIdException();
            if (topics == null)
                throw new IllegalArgumentException("Topic collection to subscribe to cannot be null");
            if (topics.isEmpty()) {
                // treat subscribing to empty topic list as the same as unsubscribing
                this.unsubscribe();
            } else {
                for (String topic : topics) {
                    if (topic == null || topic.trim().isEmpty())
                        throw new IllegalArgumentException("Topic collection to subscribe to cannot contain null or empty topic");
                }
                //如果没有分区分配规则，则抛错，清除没有绑定的topic
                throwIfNoAssignorsConfigured();
                fetcher.clearBufferedDataForUnassignedTopics(topics);
                log.info("Subscribed to topic(s): {}", Utils.join(topics, ", "));
                //更新客户端元数据
                if (this.subscriptions.subscribe(new HashSet<>(topics), listener))
                    metadata.requestUpdateForNewTopics();
            }
        } finally {
            release();
        }
    }

总结

1、校验groupId
2、如果绑定的topic为空则执行解绑操作
3、设置立即更新客户端元数据 ConsumerMetadata
客户端绑定topic是支持动态刷新的，如果topic有变动，绑定topic的代码会请求立即更新元数据

客户端poll做的事

org.apache.kafka.clients.consumer.KafkaConsumer#poll(org.apache.kafka.common.utils.Timer, boolean)

  private ConsumerRecords<K, V> poll(final Timer timer, final boolean includeMetadataInTimeout) {
        //获取轻量级的锁，防止多线程使用kafkaConsumer
        acquireAndEnsureOpen();
        try {
            //之前已经初始化的kafkaConsumer指标
            this.kafkaConsumerMetrics.recordPollStart(timer.currentTimeMs());

            if (this.subscriptions.hasNoSubscriptionOrUserAssignment()) {
                throw new IllegalStateException("Consumer is not subscribed to any topics or assigned any partitions");
            }

            do {
                //判断客户端是否能被唤醒，如果线程没有在执行不可中断请求，且被中断，则抛异常
                client.maybeTriggerWakeup();

                if (includeMetadataInTimeout) {
                    // 这个方法有三个作用
                    //1、更新元数据
                    //2、加入消费组，非阻塞
                    //3、获取消费位点
                    updateAssignmentMetadataIfNeeded(timer, false);
                } else {
                    while (!updateAssignmentMetadataIfNeeded(time.timer(Long.MAX_VALUE), true)) {
                        log.warn("Still waiting for metadata");
                    }
                }
                //fetch数据
                final Map<TopicPartition, List<ConsumerRecord<K, V>>> records = pollForFetches(timer);
                if (!records.isEmpty()) {
                    // before returning the fetched records, we can send off the next round of fetches
                    // and avoid block waiting for their responses to enable pipelining while the user
                    // is handling the fetched records.
                    //
                    // NOTE: since the consumed position has already been updated, we must not allow
                    // wakeups or any other errors to be triggered prior to returning the fetched records.
                    if (fetcher.sendFetches() > 0 || client.hasPendingRequests()) {
                        client.transmitSends();
                    }
                    //调用自定义拦截器过滤数据
                    return this.interceptors.onConsume(new ConsumerRecords<>(records));
                }
                //判断time是否有超时，没有的话继续poll数据
            } while (timer.notExpired());

            return ConsumerRecords.empty();
        } finally {
            release();
            this.kafkaConsumerMetrics.recordPollEnd(timer.currentTimeMs());
        }
    }

总结

1、与最小负载节点通信找到group节点
2、加入group，rebanlance
3、与其他节点同步rebanlance结果
4、fetch数据
5、处理数据
6、与group交互提交位点

客户端poll数据简易流程图

图一

小飞侠fly
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
初始 Kafka Consumer 消费者
中间件兴趣圈
11-24 1980
温馨提示：整个 Kafka 专栏基于 kafka-2.2.1 版本。 1、KafkaConsumer 概述 根据 KafkaConsumer 类上的注释上来看 KafkaConsumer 具有如下特征： 在 Kafka 中 KafkaConsumer 是线程不安全的。 2.2.1 版本的KafkaConsumer 兼容 kafka 0.10.0 和 0.11.0 等低版本。 消息偏...
kafka源码分析 消费消息
coding and writing and 承接需求
07-12 367
文章目录kafka 消费消息源码分析消费消息的实例代码过程步骤参数说明创建消费者实例主流程 kafka 消费消息源码分析 消费消息的实例代码 package com.example.demo.kafka; import org.apache.kafka.clients.consumer.ConsumerConfig; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consum
kafka报错:No group.id found in consumer config, container properties
不积跬步，无以至千里
07-20 6650
Caused by: java.lang.IllegalStateException: No group.id found in consumer config, container properties, or @KafkaListener annotation; a group.id is required when group management is used.
kafka —— consumers 消费者 group 找不到得原因
idream
05-21 9908
近期也有一个需求 问题：spark消费kafka数据，消费过程没有任何问题，数据正常消费，编译没问题，运行也没问题。但是：无论从哪里，kafka manager或者其他得，都找不到group组。 检查kafka，检查ETLspark代码 最后测试发现： 消费kafka数据， 就是将offset得提交方式从自动改为手动 而且在执行过程中 你也没有手动提交offset值 就会出现gro...
No group.id found in consumer config, container properties, or @KafkaListener annotation； a group.id
whiteBearClimb的博客
11-06 2363
监听模式下要给消费组定义 group id: 重启即可
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot 基于spring-kafka动态创建kafka消费者
11-17
本文将详细探讨如何在Spring Boot项目中基于Spring Kafka动态创建Kafka消费者。 首先，了解Kafka基本概念：Kafka是一种分布式流处理平台，用于构建实时数据管道和流应用程序。它提供了高吞吐量、低延迟的消息传递，...
golang kafka sarama 消费者组
01-20
之前用kafka，没在网上找到关于 sarama消费者组的代码。后来才在源码里面找到例子，现在稍微修改了下代码，记录一下。 package main import ( context github.com/Shopify/sarama log github....
Kafka消费者详解.md
08-07
Kafka消费者详解，进阶篇
一个简单的kafka消费者
02-15
一个简单的kafka消费者
kafka启动报错
AgonyNew的博客
12-25 2092
报错内容：org.springframework.context.ApplicationContextException: Failed to start bean 'org.springframework.kafka.config.internalKafkaListenerEndpointRegistry'; nested exception is java.lang.IllegalStateException: No group.id found in consumer config, containe
kafka 启动错误: 找不到或无法加载主类 kafka.Kafka
lqylqylqy44的博客
06-08 3015
本人报错原因分析: 1、因为我下载的是src 源码包，所以启动报这个错误。（kafka-2.1.1-src.tgz） 2、后来我用非源码包 （kafka_2.11-2.0.0.tgz）按照下面文章的操作步骤安装后，一切正常启动。 具体kafka安装部署地址：https://www.jianshu.com/p/bdd9608df6b3 ...
Kafka 消费者组管理模块（一）：组元数据与组成员元数据
lianggx3的博客
10-03 982
消费者组的元数据主要是由 GroupMetadata 和 MemberMetadata 两个类组成，它们分别位于 GroupMetadata.scala 和 MemberMetadata.scala 这两个源码文件中。从它们的名字上也可以看出来，前者是保存消费者组的元数据，后者是保存消费者组下成员的元数据。 MemberMetadata 先看 MemberMetadata.scala 文件，包括 3 个类和对象 MemberSummary 类：组成员概要数据，提取了最核心的元数据信息。...
python简单操作kafka
kamil的博客
07-27 989
python操作kafka kafka命令行操作 # 创建主题 kafka-topics.sh --zookeeper localhost:2181 --create --replication-factor 1 --partitions 3 --topic userlog # 查看所有主题 kafka-topics.sh --zookeeper localhost:2181 --list # 查看主题 kafka-topics.sh --zookeeper localhost:2181 --describ
【Flink】使用kafka-connector消费数据时看不到consumer-id等信息
一只皮皮熊
04-10 7353
文章目录问题复现初步结论源码分析KafkaConsumer实现FlinkKafkaConsumer实现一句话总结 问题 复现 使用connecor消费数据的时候，我们./bin/kafka-consumer-groups.sh查看消费的情况时发现异常 而使用kafka-client的时候，这些信息是能正常显示的 初步结论 https://issues.apache.org/jira/brows...
springboot 使用 kafka
weixin_42555971的博客
06-08 2124
kafka
kafka配置详解
huxiaodong1994的博客
06-27 2741
broker端参数 log.dirs：指定broker端使用那些若干文件来进行日志存储，没有默认值，必须要进行指定。配置格式为csv的样式，如：/home/kafka1,/home/kafka2,/home/kafka3，并且可以将不同的目录挂在不同的磁盘下面，这样可以有如下好处 提升读写性能 可以实现故障转移，在kafka1.1之后，单个磁盘损坏时，坏掉的磁盘数据会自动转换到正常的磁盘，继续提供服务。 log.dir：同log.dirs参数配置效果一样，只不过只能配置单个路径。 zookeepe
kafka 的group-id不配置默认是广播_docker安装kafka快速搭建学习环境
weixin_33076057的博客
02-03 1622
安装docker安装docker之前，最好先做一次升级yumupdate安装dockeryum install dockerkafka需要zookeeper管理，所以需要先安装zookeeper。搜索镜像docker search zookeeper下载镜像docker pull docker.io/zookeeper查看镜像dockerimages运行docker ...
kafka消费者负载
最新发布
02-23
Kafka消费者负载是指将消息从Kafka主题中读取并处理的过程。Kafka的消费者负载可以通过以下几个方面来进行优化和管理： 1. 分区分配策略：Kafka提供了多种分区分配策略，用于将主题的分区分配给消费者组中的消费者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小飞侠fly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值