Kafka之Consumer Rebalance

最新推荐文章于 2023-08-15 01:32:02 发布
最新推荐文章于 2023-08-15 01:32:02 发布
阅读量892 收藏 5
点赞数
分类专栏： # Kafka实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/103605907
版权

文章目录

Kafka版本

  1. kafka版本1.1.1，可能绝大部分也适用于kafka 0.10.x及以上版本。

rebalance

  1. ConsumerGroup(消费组)里的Consumer(消费者)共同读取topic(主题)的partition(分区)，一个新的Consumer(消费者)加入ConsumerGroup(消费组)时，读取的是原本由其他Consumer(消费者)读取的消息。当一个Consumer(消费者)被关闭或发生奔溃时，它就离开ConsumerGroup(消费组)，原本由它读取的分区将有ConsumerGroup(消费组)的其他Consumer(消费者)来读取。在topic发生变化时(比如添加了新的分区)，会发生Partition重分配,Partition的所有权从一个Consumer(消费者)转移到另一个Consumer(消费者)的行为被称为rebalance(再均衡)。rebalance(再均衡)本质上是一种协议，规定了ConsumerGroup(消费组)中所有Consumer(消费者)如何达成一致来消费topic(主题)下的partition(分区)
  2. rebalance(再均衡)为ConsumerGroup(消费组)带来了高可用性和伸缩性(可以安全的添加或移除消费者)，在rebalance(再均衡)期间，Consumer(消费者)无法读取消息，造成整个Consumer(消费者)一段时间的不可用
  3. Consumer(消费者)通过向GroupCoordinator(群组协调器)(不同的ConsumerGroup(消费组)可以有不同的)发送心跳来维持它们与群组的从属关系以及它们对分区的所有权关系。Consumer(消费者)会在轮询消息或者提交偏移量时发送心跳(kafka0.10.1之前的版本)，在kafka0.10.1版本里，心跳线程是独立的
  4. 分配分区的过程
    • Consumer(消费者)加入ConsumerGroup(消费组)时，会向GroupCoordinator(群组协调器)发送一个JoinGroup请求，第一个加入群组的Consumer(消费者)将会成为群主，群主从GroupCoordinator(群组协调器)获得ConsumerGroup(消费组)的成员列表(此列表包含所有最新正常发送心跳的活跃的Consumer(消费者))，并负责给每一个Consumer(消费者)分配分区(PartitionAssignor的实现类来决定哪个分区被分配给哪个Consumer(消费者))
    • 群主把分配情况列表发送给GroupCoordinator(群组协调器)，GroupCoordinator(群组协调器)再把这些信息发送给ConsumerGroup(消费组)里所有的Consumer(消费者)。每个Consumer(消费者)只能看到自己的分配信息，只有群主知道ConsumerGroup(消费组)里所有消费者的分配信息。
  5. rebalance(再均衡)触发条件
    • ConsumerGroup(消费组)里的Consumer(消费者)发生变更(主动加入、主动离开、崩溃)，崩溃不一定就是指 consumer进程"挂掉"、 consumer进程所在的机器宕机、长时间GC、网络延迟，当 consumer无法在指定的时间内完成消息的处理，那么coordinator就认为该 consumer已经崩溃，从而引发新一轮 rebalance
    • 订阅topic(主题)的数量发生变更(比如使用正则表达式的方式订阅),当匹配正则表达式的新topic被创建时则会触发 rebalance。
    • 订阅topic(主题)的partition(分区)数量发生变更,比如使用命令行脚本增加了订阅 topic 的分区数

rebalance策略

  1. 分配策略：决定订阅topic的每个分区会被分配给哪个consumer。默认提供了 3 种分配策略，分别是 range 策略、round-robin策略和 sticky策略，可以通过partition.assignment.strategy参数指定。kafka1.1.x默认使用range策略
  2. range策略：将单个 topic 的所有分区按照顺序排列，然后把这些分区划分成固定大小的分区段并依次分配给每个 consumer。假设有ConsumerA和ConsumerB分别处理三个分区的数据，当ConsumerC加入时，触发rebalance后，ConsumerA、ConsumerB、ConsumerC每个都处理2个分区的数据。
  3. round-robin 策略：把所有 topic 的所有分区顺序摆开，然后轮询式地分配给各个 consumer
  4. sticky策略（0.11.0.0后引入）:有效地避免了上述两种策略完全无视历史分配方案的缺陷。采用了"有黏性"的策略对所有 consumer 实例进行分配，可以规避极端情况下的数据倾斜并且在两次 rebalance间最大限度地维持了之前的分配方案

rebalance generation

  1. rebalance generation 用于标识某次 rebalance，在 consumer中它是一个整数，通常从 0开始
  2. consumer generation主要是防止无效 offset提交。比如上一届的 consumer成员由于某些原因延迟提交了 offset（已经被踢出group），但 rebalance 之后该 group 产生了新一届的 group成员，而延迟的offset提交携带的是旧的 generation信息，因此这次提交会被 consumer group拒绝，使用 consumer时经常碰到的 ILLEGAL_GENERATION异常就是这个原因导致的
  3. 每个 group进行 rebalance之后， generation号都会加 1，表示 group进入了 一个新的版本

rebalance协议

  1. rebalance本质是一组协议
    • JoinGroup: consumer请求加入组
    • SyncGroup:group leader把分配方案同步更新到组内所有成员
    • Heartbeat :consumer定期向coordinator发送心跳表示自己存活
    • LeaveGroup:consumer主动通知coordinator该consumer即将离组
    • DescribeGroup:查看组的所有信息，包括成员信息、协议信息、分配方案以及订阅信息。该请求类型主要供管理员使用 。 coordinator不使用该请求执行 rebalance
  2. 在 rebalance过程中， coordinator主要处理 consumer发过来的JoinGroup和 SyncGroup请求
  3. 当 consumer主动离组时会发送LeaveGroup请求给 coordinator
  4. 在成功 rebalance之后，组内所有 consumer都需要定期地向 coordinator发送Heartbeat请求。每个 consumer 也是根据Heartbeat请求的响应中是否包含 REBALANCE_IN_PROGRESS 来判断当前group是否开启了新一轮 rebalance

rebalance流程

  1. 第一步确认coordinator所在的broker，并建立socket连接

    • 计算Math.abs(groupId.hashcode)%offset.topic.num.partitions（默认50），假设是10

    • 查找__consumer_offsets分区10的leader副本所在的broker，该broker即为这个consumer group的coordinator

  2. 第二步执行rebalance，rebalance分为两步

    • 加入组

      • 组内所有consumer向coordinator发送JoinGroup请求
      • coordinator选择一个consumer担任组的leader，并把所有成员信息以及订阅信息发送给leader

    • 同步更新方案

      • leader根据rebalance的分配策略为 group中所有成员制定分配方案，决定每个 consumer都负责哪些 topic 的哪些分区。

      • 分配完成后，leader通过SyncGroup请求将分配方案发送给coordinator。组内所有的consumer成员也会发送SyncGroup给coordinator

      • coordinator把每个consumer的方案抽取出来作为SyncGroup请求的response返回给各自的consumer

  3. 为什么consumer group的分配方案在consumer端执行？

    • 这样做可以有更好的灵活性。比如同一个机架上的分区数据被分配给相同机架上的 consumer减少网络传输的开销。即使以后分区策略发生了变更，也只需要重启 consumer 应用即可，不必重启 Kafka服务器

  4. 加入组流程

    image-20191209225910650

  5. 同步分配方案

    image-20191209225959292

  6. kafka为consumer group定义了5种状态

    • Empty:表示group下没有任何激活的consumer，但可能包含offset信息。
      • 每个group创建时处于Empty状态
      • 所有consumer都离开group时处于Empty状态
      • 由于可能包含offset信息，所以此状态下的group可以响应 OffsetFetch请求，即返回 clients端对应的位移信息
    • PreparingRebalance:表示group 正在准备进行 group rebalance。此状态表示group已经接收到部分JoinGroup的请求，同时在等待其他成员发送JoinGroup请求，知道所有成员都成功加入组或者超时(Kafka 0.10.1.0之后超时时间由consumer端参数max.poll.interval.ms指定)
      • 该状态下的 group 依然可能保存有offset信息，因此 clients 依然可以发起 OffsetFetch 请求去获取offset，甚 至还可以发起OffsetCommit请求去提交位移
    • AwaitingSync:所有成员都已经加入组并等待 leader consumer 发送分区分配方案。同样地，此时依然可以获取位移，但若提交位移， coordinator 将会抛出REBALANCE_IN_PROGRESS异常来表明该 group 正在进行 rebalance
    • Stable:表明 group 开始正常消费 。 此时 group 必须响应 clients 发送过来的任何请求，比如位移提交请求、位移获取请求、心跳请求等
    • Dead: 表明 group 已经彻底废弃， group 内没有任何激活consumer并且 group 的所有元数据信息都己被删除。处于此状态的 group 不会响应任何请求。严格来说， coordinator会返回UNKNOWN_MEMBER_ID异常

rebalance监听器

  1. 如果要实现将offset存储在外部存储中，需要使用rebalance。使用 rebalance 监听器的前提是必须使用 consumer group。如果使用的是独立 consumer或是直接手动分配分区，那么 rebalance监听器是无效的

  2. rebalance 监听器最常见的用法就是手动提交位移到第三方存储以及在 rebalance 前后执行一些必要的审计操作

  3. 自动提交位移是不需要在 rebalance监听器中再提交位移的，consumer 每次 rebalance 时会检查用户是否启用了自动提交位移，如果是，它会帮用户执行提交

  4. 鉴于 consumer 通常都要求 rebalance 在很短的时间内完成，用户千万不要在 rebalance 监听器 的两个方法中放入执行时间很长的逻辑，特别是一些长时间阻塞方法

  5. 代码案例

    public class ConsumerOffsetSaveDB {
    private final static Logger logger = LoggerFactory.getLogger("kafka-consumer");
    @Test
    public void testConsumerOffsetSaveDB() {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-master:9092,kafka-slave1:9093,kafka-slave2:9094");
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 10);
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "30000");
        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.AUTO_OFFSET_RESET_CONFIG, "earliest");
        String groupId = "test_group_offset_db11";
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        String topic = "testTopic";
        Map<TopicPartition, OffsetAndMetadata> offsetAndMetadataMap = new HashMap<>();
        consumer.subscribe(Collections.singletonList(topic), new SaveOffsetsRebalance(consumer, offsetAndMetadataMap, groupId));
        consumer.poll(0);

        OffsetService offsetService = new OffsetService();

        for (TopicPartition partition : consumer.assignment()) {
            // 从数据库获取当前分区的偏移量
            Offset offset = offsetService.getOffset(groupId, partition.topic(), partition.partition());
            if (offset != null && offset.getOffset() != null) {
                consumer.seek(partition, offset.getOffset());
            } else {
                logger.info("初始时库没有值");
            }
        }

        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(1000);
                for (ConsumerRecord<String, String> record : records) {
                    //模拟异常
                   /* if (record.value().equals("hello world 10")) {
                        throw new RuntimeException(String.format("hello world 10处理异常,offset:%s,partition:%s",record.offset(),record.partition()));
                    }*/
                    /**
                     *1. 消息处理(要考虑去重，如果消息成功，但是存储偏移量失败或者宕机，此时数据库存储的消息偏移量不是最新的)
                     *2. 如果消息处理是数据库，最好将消息处理与存储offset放在一个事务当中
                     */
                    logger.info("key:{},value:{},offset:{}", record.key(), record.value(), record.offset());
                    offsetAndMetadataMap.put(
                            new TopicPartition(record.topic(), record.partition()),
                            new OffsetAndMetadata(record.offset() + 1, "")
                    );
                    // 2.存储偏移量到DB，这里采用单次更新，当然也可以批量
                    offsetService.insertOffset(groupId, record.topic(), record.partition(), record.offset() + 1);
                }

            }
        } catch (WakeupException e) {
            // 不处理异常
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            consumer.close();
        }
    }
}

  6. rebalance代码

    public class SaveOffsetsRebalance implements ConsumerRebalanceListener {

    private Logger logger = LoggerFactory.getLogger(SaveOffsetsRebalance.class);

    private Consumer consumer;
    private Map<TopicPartition, OffsetAndMetadata> map;
    private String groupId;
    OffsetService offsetService = new OffsetService();

    public SaveOffsetsRebalance(Consumer consumer, Map<TopicPartition, OffsetAndMetadata> map, String groupId) {
        this.consumer = consumer;
        this.map = map;
        this.groupId = groupId;
    }

    /**
     * 此方法在rebalance操作之前调用，用于我们提交消费者偏移，
     * 这里不提交消费偏移，因为consumer中每处理一次消息就保存一次偏移，
     * consumer去做重复消费处理
     */
    @Override
    public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
        int size = partitions.size();
        logger.info("rebalance 之前触发.....{}", size);
        Iterator<TopicPartition> iterator = partitions.iterator();
        while (iterator.hasNext()) {
            TopicPartition topicPartition = iterator.next();
            long position = consumer.position(topicPartition);
            OffsetAndMetadata offsetAndMetadata = map.get(topicPartition);
            if (offsetAndMetadata != null) {
                long offset = offsetAndMetadata.offset();
                logger.info("position:{},offset:{}", position, offset);
            } else {
                logger.info("position:{},offset:{}", position, null);
            }
        }
    }

    /**
     * 此方法在rebalance操作之后调用，用于我们拉取新的分配区的偏移量。
     */
    @Override
    public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
        logger.info("rebalance 之后触发.....");
        for (TopicPartition partition : partitions) {
            //从数据库获取当前分区的偏移量
            Offset offset = offsetService.getOffset(this.groupId, partition.topic(), partition.partition());
            if (offset != null && offset.getOffset() != null) {
                consumer.seek(partition, offset.getOffset());
            }
        }
    }
}

  7. 数据库sql

    DROP TABLE IF EXISTS `t_offset`;
CREATE TABLE `t_offset` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `group_id` varchar(50) CHARACTER SET latin1 NOT NULL,
  `topic` varchar(50) CHARACTER SET latin1 NOT NULL COMMENT 'topic',
  `partition` int(11) NOT NULL,
  `offset` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_gtp` (`group_id`,`topic`,`partition`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='偏移量保存';

  8. 添加依赖

    compile group: 'commons-dbutils', name: 'commons-dbutils', version: '1.7'
compile group: 'mysql', name: 'mysql-connector-java', version: '5.1.30'
compile group: 'org.aeonbits.owner', name: 'owner', version: '1.0.9'

  9. 数据库工具

    public class JdbcUtils {
    public static Connection getConnection(String driverClass, String url, String username, String password) throws SQLException, ClassNotFoundException {
        Class.forName(driverClass);
        return DriverManager.getConnection(url, username, password);
    }
}

@Sources({"classpath:config.properties"})
public interface MysqlJdbcConfig extends Reloadable {
    @Key("config.mysql.url")
    public String url();

    @Key("config.mysql.username")
    public String username();

    @Key("config.mysql.password")
    public String password();

    @Key("config.mysql.driverClass")
    public String driverClass();

    public final static class ServerConfigInner {
        public final static MysqlJdbcConfig config = ConfigFactory.create(MysqlJdbcConfig.class);
    }

    public static final MysqlJdbcConfig instance = ServerConfigInner.config;

}

  10. 配置config.properties

    config.mysql.url=jdbc:mysql://jannal.mac.com:3306/test
config.mysql.username=root
config.mysql.password=root
config.mysql.driverClass=com.mysql.jdbc.Driver

  11. 偏移量处理类

    public class Offset {
    private Long id;

    private String groupId;

    private String topic;

    private String partition;

    private Long offset;
		...省略getter setter toString..
}

public class OffsetService {
    
    public Offset getOffset(String groupId, String topic, int partition) {
        QueryRunner queryRunner = new QueryRunner();
        Offset offset = null;
        Connection connection = null;
        try {
            connection = JdbcUtils.getConnection(MysqlJdbcConfig.instance.driverClass(), //
                    MysqlJdbcConfig.instance.url(),//
                    MysqlJdbcConfig.instance.username(),//
                    MysqlJdbcConfig.instance.password());//
            String sql = "select `topic`,`partition`,`offset` from `t_offset` where `group_id`=? and  `topic` = ? and  `partition` = ?";
            offset = queryRunner.query(connection, sql, new BeanHandler<Offset>(Offset.class), new Object[]{groupId, topic, partition});
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return offset;
    }


    public void insertOffset(String groupId, String topic, int partition, long offset) {
        QueryRunner queryRunner = new QueryRunner();
        Connection connection = null;
        try {
            connection = JdbcUtils.getConnection(MysqlJdbcConfig.instance.driverClass(), //
                    MysqlJdbcConfig.instance.url(),//
                    MysqlJdbcConfig.instance.username(),//
                    MysqlJdbcConfig.instance.password());//
            String sql = " insert into `t_offset`( `group_id`,`topic`, `partition`,`offset`) values ( ?,?, ?,?) on duplicate key update `offset` =VALUES(offset);";
            Object[] params = {groupId, topic, partition, offset};
            connection.setAutoCommit(false);
            queryRunner.update(connection, sql, params);
            connection.commit();
        } catch (Exception e) {
            try {
                if (connection != null) {
                    connection.rollback();
                }
            } catch (SQLException e1) {
                throw new RuntimeException(e.getMessage(), e);
            }
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

    }


    public void batchInsertOffset(Object[][] params) {
        QueryRunner queryRunner = new QueryRunner();
        Connection connection = null;
        try {
            connection = JdbcUtils.getConnection(MysqlJdbcConfig.instance.driverClass(), //
                    MysqlJdbcConfig.instance.url(),//
                    MysqlJdbcConfig.instance.username(),//
                    MysqlJdbcConfig.instance.password());//
            String sql = " insert into `t_offset`(`group_id`, `topic`, `partition`,`offset`) values (?, ?, ?,?) on duplicate key update `offset`=VALUES(offset);";
            connection.setAutoCommit(false);
            queryRunner.batch(connection, sql, params);
            connection.commit();
        } catch (Exception e) {
            try {
                if (connection != null) {
                    connection.rollback();
                }
            } catch (SQLException e1) {
                throw new RuntimeException(e.getMessage(), e);
            }
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
jannals
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pentaho-kafka-consumer.zip
03-16
kettle kafka 消费者插件，在plugins 下新建steps文件夹，把zip文件解压放到里面。
Kafka Rebalance机制和选举策略总结
Jeffrey的博客
05-10 350
自建博客地址：https://www.bytelife.net，欢迎访问！ 本文为博客同步发表文章，为了更好的阅读体验，建议您移步至我的博客???? 本文作者： Jeffrey 本文链接： https://www.bytelife.net/articles/62460.html 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！ Kafka作为大数据领域常用的消息中间件，其核心原理相对于其它消息中间件而言更为复杂，本文主要介绍Kafka消费者的rebalance
Kafka的rebalance
wangzhicheng2013的专栏
11-04 976
rebalance是一种协议，它规定了消费组consumer group下所有的consumer如何使用topic相关的分区。 1.触发rebalance条件： （1）组内成员发生变更； （2）订阅topic发生变更； （3）topic关联的分区数发生变更。 2.rebalance决策者 coordinator，按照一定算法产生的broker。 3.五种协议 （1）Heartbeat请求：consumer需要定期给coordinator发送心跳来表明自己还活着； （2）LeaveGroup
kafka消费者（六）：Rebalance
lianggx3的博客
08-03 1282
触发rebalance的条件： 1. 有新的消费者加入消费者组 2. 有消费者宕机下线。例如长时间的GC。网络延迟导致消费者长时间没有向GroupCoordinator发送心跳请求。 3. 消费者退出消费者组 4. 消费者组订阅的任意一个topic发生了分区数量的变化 5. 消费者调用unsubscribe()取消订阅。 rebalance的操作分为三个阶段，下面分别介绍： 第一阶段 1. 查找G...
kafka触发rebalance
清晨qc的博客
04-12 799
Kafka Rebalance是一个重要的机制，它确保了每个消费者接收相等数量的分区，从而实现了负载均衡和高可用性。在Rebalance期间，消费者需要重新分配分区，并重新连接和重新消费先前未消费的消息。为了更好地了解Rebalance机制的工作原理，我们可以使用ConsumerRebalanceListener接口来处理Rebalance事件，并在Rebalance期间打印出日志消息。
第6章 Rebalance详解
留不住斜阳的博客
05-31 3097
kafka rebalance详解
kafkaConsumerDemo.zip
04-24
这是使用java操作kafka consumer api的一个demo，欢迎下载交流，博客地址：https://blog.csdn.net/qq_26803795
图解 Kafka 之实战指南
03-29
图解 Kafka 之实战指南.pdf
Kafka设计解析（五）-KafkaConsumer设计解析
02-25
很多时候，客户程序只是希望从Kafka读取数据，不太关心消息offset的处理。同时也希望提供一些语义，例如同一条消息只被某一个Consumer消费（单播）或被所有Consumer消费（广播）。因此，KafkaHightL
kafka-consumer
05-16
卡夫卡消费者Kafka-consumer是kafka的大数据消息阅读器。特征使用Kafka的高级/低级API连续接收Kafka数据。 在故障过程中，我们只需在每个批次间隔的开始确定要消耗的偏移量范围是多少。 从Kakfa读取与偏移范围相对应...
【kafka】Kafka 之 Group 状态变化分析及 Rebalance 过程
九师兄
02-01 2722
文章目录1.概述2. Group 状态机3.offset 那些事4.Topic __consumer_offsets5.GroupCoordinator6.状态转移图7.Consumer 初始化8.Consumer poll 过程解析9.Consumer 初始化时 group 状态变化10.Consumer Rebalance 1.概述 转载：Kafka 之 Group 状态变化分析及 Rebalance 过程 前段时间看一下 Kafka 的部分源码（0.10.1.0 版），对一些地方做了一些相应的总结。
【Kafka】kafka 重平衡（Rebalance）
热门推荐
九师兄
09-21 1万+
说完消费者组，再来说说与消费者组息息相关的重平衡机制。重平衡可以说是kafka为人诟病最多的一个点了。重平衡其实就是一个协议，它规定了如何让消费者组下的所有消费者来分配topic中的每一个分区。比如一个topic有100个分区，一个消费者组内有20个消费者，在协调者的控制下让组内每一个消费者分配到5个分区，这个分配的过程就是重平衡。重平衡的触发条件主要有三个：消费者组内成员发生变更，这个变更包括了增加和减少消费者。注意这里的减少有很大的可能是被动的，就是某个消费者崩溃退出了。
Kafka——Rebalance重平衡
最新发布
吴声子夜歌的博客
08-15 597
如图所示，Generation1时group有3个成员，随后成员2退出组，coordinator触发rebalance,consumer group进入到Generation2时代，之后成员4加入，再次触发rebalance,group进入到Generation3时代。针对rebalance过程中的分区分配，下面举一个简单的例子，加以说明。由此可见，原先A和B分别处理3个分区的数据，rebalance之后A、B和C各自承担2个分区的消费，可以说这个分配方案非常公平，每个consumer上的负载是相同的。
Kafka的ReBalance机制和高水位机制
pengweismile的专栏
06-20 544
分区与消费者的分配平衡机制。 partition.assignment.strategy range - round-robin sticky
Kafka 再均衡(rebalance)触发的条件
juanqiao7497的博客
10-21 5578
新版的消费者客户端对此进行了重新设计，将全部消费组分成多个子集，每个消费组的子集在服务端对应一个GroupCoordinator对其进行管理，GroupCoordinator是Kafka服务端中用于管理消费组的组件。而消费者客户端中的ConsumerCoordinator组件负责与GroupCoordinator进行交互。 ConsumerCoordinator与GroupCoordinator之间最重要的职责就是负责执行消费者再均衡的操作，包括前面提及的分区分配的工作也是在...
kafka的rebalance机制
qq_40322236的博客
11-10 4884
Reblance就像他的名称一样，意思是再平衡，平衡什么？平衡和之间的对应关系。本质上来讲，Reblance是一种协议，规定了一个Consumer Group下所有Consumer如何达成一致，来分配订阅Topic的每个分区，尽量让每个消费者分配到相对均匀的分区，使Consumer的资源都能得到充分利用，防止有些Consumer比较忙，有的Consumer比较闲。
Kafka Rebalance测试
qq_41203483的博客
11-23 1135
Kafka Rebalance测试 关于kafka的Rebalance机制，其实就是规定同一个consumer group下所有的consumer如何协调工作的，分配订阅Topic分区的。Rebalance发生时，Group 下所有 consumer 实例都会协调在一起共同参与，kafka 能够保证尽量达到最公平的分配。但是 Rebalance 过程对 consumer group 会造成比较严重的影响。在 Rebalance 的过程中 consumer group 下的所有消费者实例都会停止工作，等待
kafka rebalance ConsumerRebalanceListener
金溪的博客
11-04 1696
kafka在有新消费者加入或者撤出时，会触发rebalance操作，在subscribe订阅主题的时候，我们可以编写回掉函数，在触发rebalance操作之前和之后，提交相应偏移量和获取偏移量。 consumer.subscribe(Collections.singletonList(topic), new SaveOffsetOnRebalance(mulConsumer)); clas...
Kafka消费组rebalance原理
xinyuan的专栏
12-29 944
Kafka消费组rebalance原理
kafka rebalance
06-02
Kafka rebalance是指在Kafka集群中，当消费者加入或退出消费组时，重新分配分区的过程。在Kafka中，每个消费者可以订阅一个或多个主题的一个或多个分区进行消费。当消费者加入或退出消费组时，需要重新分配分区以确保消费组内的消费者数量均匀，并且每个消费者消费的分区数量也应该尽可能均匀。Kafka rebalance的过程是自动的，由Kafka Consumer Group管理器完成。在rebalance期间，消费者可能暂停消费和提交偏移量，因此需要在代码中处理好rebalance的情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值