Kafka为Consumer分派分区:RangeAssignor和RoundRobinAssignor

版权声明:hulu内推,可以和我联系:583424568@qq.com. 转载需注明csdn原文出处! https://blog.csdn.net/zhanyuanlin/article/details/76021614

看过Kafka关于消费者的join Group的代码以后,我们可以知道,每一个Consumer的代理对象ConsumerCoordinator代表这个Consumer进行join Group操作,实际上是向GroupCoordinator发起JoinGroup请求。GroupCoordinator只负责告知Consumer其角色信息,即成为Leader还是Follower,并不负责分区分配,即管理Consumer和TopicPartition的对应关系。这种管理是被选举为Leader 的ConsumerCoordinator根据配置的分区分派规则来决定的。我们一起来从代码层面分析Kafka内置的分区分派算法RangeAssigner和RoundRobinAssigner。

为了不让读者感觉突兀,我们从ConsumerCoordinator收到JoinGroupResponse开始分析代码,即我们创建了一个消费者对象,开始消费消息的时候,底层会向远程的GroupCoordinator发起joinGroup请求,GroupCoordinator会进行处理并响应:

private class JoinGroupResponseHandler extends CoordinatorResponseHandler<JoinGroupResponse, ByteBuffer> {

            @Override
            public JoinGroupResponse parse(ClientResponse response) {
                return new JoinGroupResponse(response.responseBody());
            }

            //收到JoinGroup响应以后的回调方法
            @Override
            public void handle(JoinGroupResponse joinResponse, RequestFuture<ByteBuffer> future) {
                Errors error = Errors.forCode(joinResponse.errorCode());
                if (error == Errors.NONE) {//没有发生错误
                    log.debug("Received successful join group response for group {}: {}", groupId, joinResponse.toStruct());
                    AbstractCoordinator.this.memberId = joinResponse.memberId();
                    AbstractCoordinator.this.generation = joinResponse.generationId();
                    AbstractCoordinator.this.rejoinNeeded = false;
                    AbstractCoordinator.this.protocol = joinResponse.groupProtocol();
                    sensors.joinLatency.record(response.requestLatencyMs());
                    if (joinResponse.isLeader()) {
                        //责任链模式,将future加入到当前这个RequestFuture所维护的List<Listener>中
                        onJoinLeader(joinResponse).chain(future);//我是leader

                    } else {
                        onJoinFollower().chain(future);
                    }
                } 
            }
            else{//存在错误
              //略
           }
        }

在发送ConsumerCoordinator发送JoinGroup的时候,会保存一个回调,用来对JoinGroup的响应进行处理。JoinGroup的response信息携带了以下信息:

  • memberId:远程的GroupCoordinator分配给这个Consumer的唯一id;
  • generationId:年代信息,由于每当有一个consumer加入group都会发生一次rebalance,每次rebalance叫做一个generation并且generationId自增1,因此response中携带该generationId,用来防止由于丢包、重复包等信息,造成ConsumerCoordinator和GroupCoordinator之间发生误解;
  • groupProtocol:组协议,看似非常抽象,其实就是指远程的GroupCoordinator确定下来的分区分派方法,即协商一致的分区分派算法。远程的GroupCoordinator会从ConsumerCoordinator的JoinGroup请求中提取该Consumer所支持的分区分派算法,然后选择一个大多数Consumer都支持的算法。如果我们在配置文件里面不进行显式配置,则使用RangeAssigner;
  • isLeader:是否为leader,只有Leader 才有资格根据返回的分区分派规则为所有的consumer分配分区;
  • leaderId:leaderId代表了被选举为leader的consumer的memberId;
  • members 如果这个Consumer被选举为leader,它会收到group中所有成员的信息(上帝视角),即所有的memberId以及每个member订阅的topic的信息都会告知这个Leader Consumer。

如果当前选举为leader,则会执行onJoinLeader()进行分区分配:

      /**
         *  Consumer Group Leader收到response并且自己是leader 的时候会被调用
         *  与onJoinFollower的区别是,此时SyncGroupRequest请求中的groupAssignment不是空的
         * @param joinResponse
         * @return
         */
        private RequestFuture<ByteBuffer> onJoinLeader(JoinGroupResponse joinResponse) {
            try {
                // perform the leader synchronization and send back the assignment for the group
                //join group成功以后,如果自己是leader,那么 joinResponse.groupProtocol()中应该保存了assignor的名字,
                //根据该名字获取对应的assignor,然后进行分区分配,查看ConsumerCoordinator.performAssignment()
                Map<String, ByteBuffer> groupAssignment = performAssignment(joinResponse.leaderId(), joinResponse.groupProtocol(),
                        joinResponse.members());

                SyncGroupRequest request = new SyncGroupRequest(groupId, generation, memberId, groupAssignment);
                log.debug("Sending leader SyncGroup for group {} to coordinator {}: {}", groupId, this.coordinator, request);
                return sendSyncGroupRequest(request);
            } catch (RuntimeException e) {
                return RequestFuture.failure(e);
            }
        }
    /**
         * 这个方法会在AbstractCoordinator.onJoinLeader()中被调用,即只有leader身份的coordinator才会调用这个方法
         */
        @Override
        protected Map<String, ByteBuffer> performAssignment(String leaderId,
                                                            String assignmentStrategy,
                                                            Map<String, ByteBuffer> allSubscriptions) {
            //从配置的assignors中,寻找名字为assignmentStrategy 的assignor
            //查看KafkaConsumer的构造函数中可以看到,this.assignors来自配置项@code ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG
            PartitionAssignor assignor = lookupAssignor(assignmentStrategy);
            if (assignor == null)
                throw new IllegalStateException("Coordinator selected invalid assignment protocol: " + assignmentStrategy);

          //将所有consumer订阅的topic的集合加入到allSubscribedTopics中
            Set<String> allSubscribedTopics = new HashSet<>();
            Map<String, Subscription> subscriptions = new HashMap<>();
            for (Map.Entry<String, ByteBuffer> subscriptionEntry : allSubscriptions.entrySet()) {
                Subscription subscription = ConsumerProtocol.deserializeSubscription(subscriptionEntry.getValue());
                subscriptions.put(subscriptionEntry.getKey(), subscription);
                allSubscribedTopics.addAll(subscription.topics());
            }

            // the leader will begin watching for changes to any of the topics the group is interested in,
            // which ensures that all metadata changes will eventually be seen
            this.subscriptions.groupSubscribe(allSubscribedTopics);
            metadata.setTopics(this.subscriptions.groupSubscription());

            // update metadata (if needed) and keep track of the metadata used for assignment so that
            // we can check after rebalance completion whether anything has changed
            client.ensureFreshMetadata();
            assignmentSnapshot = metadataSnapshot;//分区分配以前备份当前的元数据

            log.debug("Performing assignment for group {} using strategy {} with subscriptions {}",
                    groupId, assignor.name(), subscriptions);

            Map<String, Assignment> assignment = assignor.assign(metadata.fetch(), subscriptions);

            log.debug("Finished assignment for group {}: {}", groupId, assignment);

            Map<String, ByteBuffer> groupAssignment = new HashMap<>();
            for (Map.Entry<String, Assignment> assignmentEntry : assignment.entrySet()) {
                ByteBuffer buffer = ConsumerProtocol.serializeAssignment(assignmentEntry.getValue());
                groupAssignment.put(assignmentEntry.getKey(), buffer);
            }

            return groupAssignment;
        }

performAssignment()方法的第三个参数记录了group中所有的成员的Subscription信息,ConsumerProtocol.deserializeSubscription用来把字节码解析成对应的Subcription对象,具体解析方式读者有兴趣自行阅读代码。我们只需看一下Subscription的代码就可以知道这个对象所代表的含义:

    class Subscription {
            private final List<String> topics;//某个member订阅的topic集合
            private final ByteBuffer userData;//用户自定义数据,在subscription()中,用户可以添加自定义数据

            public Subscription(List<String> topics, ByteBuffer userData) {
                this.topics = topics;
                this.userData = userData;
            }

           //getter and setter
        }

每一个Subscription对象代表了这个consumer的订阅信息,即所订阅的topic的集合以及一些额外数据userData。userData与Partition分派无关,不做讲解。

方法lookupAssignor()用来根据协商一致的分区分派协议的名字,获得这个分派协议的对象:

        //查找assignor
        private PartitionAssignor lookupAssignor(String name) {
            for (PartitionAssignor assignor : this.assignors) {
                if (assignor.name().equals(name))
                    return assignor;
            }
            return null;
        }

this.assignors是我们在构造KafkaConsumer对象的时候读取配置文件所配置的分区分派算法后初始化的assignor对象。大多数情况下,我们不进行任何配置,则会使用内置的RangeAssigner。无论是什么assigner,都必须实现PartitionAssignor

接口中的方法 Map<String, Assignment> assign(Cluster metadata, Map<String, Subscription> subscriptions);是核心方法,用来执行分区分派。metadata是集群的元数据信息,subscriptions则是group中所有的member的订阅信息,key为memberId,value为记录订阅信息的Subscription对象。关于Subscription对象,上面已经讲解。

AbstractPartitionAssignor对接口中定义的Map<String, Assignment> assign(Cluster metadata, Map<String, Subscription> subscriptions);方法进行了实现:

    @Override
        public Map<String, Assignment> assign(Cluster metadata, Map<String, Subscription> subscriptions) {
            Set<String> allSubscribedTopics = new HashSet<>();//保存所有member订阅的topic
            Map<String, List<String>> topicSubscriptions = new HashMap<>();
            for (Map.Entry<String, Subscription> subscriptionEntry : subscriptions.entrySet()) {
                List<String> topics = subscriptionEntry.getValue().topics();
                allSubscribedTopics.addAll(topics);
                topicSubscriptions.put(subscriptionEntry.getKey(), topics);//取出userData信息
            }

            Map<String, Integer> partitionsPerTopic = new HashMap<>();//每个topic的partition数量信息
            for (String topic : allSubscribedTopics) {//对于这个group里面所有member订阅的所有的topic
                Integer numPartitions = metadata.partitionCountForTopic(topic);
                if (numPartitions != null && numPartitions > 0)
                    partitionsPerTopic.put(topic, numPartitions);
                else
                    log.debug("Skipping assignment for topic {} since no metadata is available", topic);
            }


            Map<String, List<TopicPartition>> rawAssignments = assign(partitionsPerTopic, topicSubscriptions);

            // this class has maintains no user data, so just wrap the results
            Map<String, Assignment> assignments = new HashMap<>();
            for (Map.Entry<String, List<TopicPartition>> assignmentEntry : rawAssignments.entrySet())
                assignments.put(assignmentEntry.getKey(), new Assignment(assignmentEntry.getValue()));
            return assignments;
        }

assign()方法的主要逻辑,就是从集群元数据metadata中提取Group 中所有的topic的partition数目,同时,从所有topic的订阅信息subscriptions中获取每一个topic所订阅的topic的list,根据这两个数据,进行分区分配。我们很直观地想一下,进行分区分配,的确需要并且仅仅需要这两个信息:

  • 每个topic的分区数目;
  • 每个consumer所订阅的分区

其实,AbstractPartitionAssignor.assign()方法没有执行具体的分配算法,具体算法是通过定义了一个抽象方法:

    public abstract Map<String, List<TopicPartition>> assign(Map<String, Integer> partitionsPerTopic,
                                                        Map<String, List<String>> subscriptions);

然后交给具体的分区分派算法RangeAssigner和RoundRobinAssigner去实现的。

由于是抽象方法,因此强制RangeAssigner和RoundRobinAssignor实现这个抽象方法。我们看RangeAssigner.assign():

        public Map<String, List<TopicPartition>> assign(Map<String, Integer> partitionsPerTopic,
                                                        Map<String, List<String>> subscriptions) {

            Map<String, List<String>> consumersPerTopic = consumersPerTopic(subscriptions);
            Map<String, List<TopicPartition>> assignment = new HashMap<>();//key为consumerID,value为分配给该consumer的TopicPartition
            for (String memberId : subscriptions.keySet())//对于每一个consumer
                assignment.put(memberId, new ArrayList<TopicPartition>());//初始化

            //对于每一个topic,进行分配
            for (Map.Entry<String, List<String>> topicEntry : consumersPerTopic.entrySet()) {
                String topic = topicEntry.getKey();
                List<String> consumersForTopic = topicEntry.getValue();

                //这个topic的partition数量
                Integer numPartitionsForTopic = partitionsPerTopic.get(topic);
                if (numPartitionsForTopic == null)//partition数量为null,直接跳过,忽略
                    continue;

                Collections.sort(consumersForTopic);//对consumer进行排序

                //计算每个consumer分到的partition数量
                int numPartitionsPerConsumer = numPartitionsForTopic / consumersForTopic.size();
                //计算平均以后剩余partition数量
                int consumersWithExtraPartition = numPartitionsForTopic % consumersForTopic.size();

                //从0开始作为Partition Index, 构造TopicPartition对象
                List<TopicPartition> partitions = AbstractPartitionAssignor.partitions(topic, numPartitionsForTopic);
                for (int i = 0, n = consumersForTopic.size(); i < n; i++) {//对于当前这个topic的每一个consumer
                    //一定是前面几个consumer会被分配一个额外的TopicPartitiion
                    int start = numPartitionsPerConsumer * i + Math.min(i, consumersWithExtraPartition);
                    int length = numPartitionsPerConsumer + (i + 1 > consumersWithExtraPartition ? 0 : 1);
                    assignment.get(consumersForTopic.get(i)).addAll(partitions.subList(start, start + length));
                }
            }
            return assignment;
        }

RangeAssignor的伪代码为:

       将consumer-topicList的映射转换为topic -> consumerList的映射
       for(每一个topic):
          获取订阅了这个topic的consumerList
          对consumer进行排序
          计算每个consumer平均至少分配到的partition数量 numPartitionsPerConsumer = numPartitionsForTopic / consumersForTopic.size();
          计算平均分配以后的剩余partition数量 consumersWithExtraPartition = numPartitionsForTopic % consumersForTopic.size();
          for(该topic对应的每一个consumer)
            从partitions中顺序领取自己的最少分排量numPartitionsPerConsumer
            if(剩余分排量consumersWithExtraPartition没有领取完)
               从剩余分排量中领取一个额外的partition
             end
          end
       end

RangeAssignor是逐个topic进行分区计算的。因此,我们可以拿一个topic为例,直观演示其分派过程:

topic的名字为t,含有5个分区(tp0,tp1,tp2,tp3,tp4 ),消费者3个( c0,c1,c2 ):

单个consumer所分配到的最小分区数量:numPartitionsPerConsumer = 5/3 = 1

平均分配以后的剩余partition数量 consumersWithExtraPartition = 5 % 3 = 2

下面逐个消费者开始分配

  • c0 :领取最小分区数量1,由于此时存在剩余额外分区,因此也从中领取一个,因c0会被分配tp0,tp1两个分区
  • c1:由于c0已经领取了tp0,tp1,因此c1会从tp_2开始领取,同样,剩余分区consumersWithExtraPartition还有一个没有领取,因此c1领取。这样,c1会被分配tp2,tp3
  • c2:由于c1已经领取到了tp2,tp3,因2c1会首先领取属于自己的最小分区数1,即领取分区tp4,同时由于consumersWithExtraPartition中的剩余分区已经全部被领取,因此不用领取剩余分区。
    最终,分区分配结果为:

    C0:[tp0,tp1]
    C1:[tp2,tp3]
    C2:[tp4]

现在,我们接着来看RoundRobinAssignor的分区算法,并将其与RangeAssigner进行对比:

     @Override
        public Map<String, List<TopicPartition>> assign(Map<String, Integer> partitionsPerTopic,
                                                        Map<String, List<String>> subscriptions) {
            Map<String, List<TopicPartition>> assignment = new HashMap<>();
            for (String memberId : subscriptions.keySet())
                assignment.put(memberId, new ArrayList<TopicPartition>());//初始化分配规则

            CircularIterator<String> assigner = new CircularIterator<>(Utils.sorted(subscriptions.keySet()));//assigner存放了所有的consumer
            for (TopicPartition partition : allPartitionsSorted(partitionsPerTopic, subscriptions)) {//所有的consumer订阅的所有的TopicPartition的List
                final String topic = partition.topic();
                while (!subscriptions.get(assigner.peek()).contains(topic))// 如果当前这个assigner(consumer)没有订阅这个topic,直接跳过
                    assigner.next();
                //跳出循环,表示终于找到了订阅过这个TopicPartition对应的topic的assigner
                //将这个partition分派给对应的assigner
                assignment.get(assigner.next()).add(partition);
            }
            return assignment;
        }
        public List<TopicPartition> allPartitionsSorted(Map<String, Integer> partitionsPerTopic,
                                                        Map<String, List<String>> subscriptions) {
            SortedSet<String> topics = new TreeSet<>();
            for (List<String> subscription : subscriptions.values())//对于所有的订阅的topic的list
                topics.addAll(subscription);//收集所有的topic,并去重

            List<TopicPartition> allPartitions = new ArrayList<>();
            for (String topic : topics) {
                Integer numPartitionsForTopic = partitionsPerTopic.get(topic);// 当前这个topic的数量
                if (numPartitionsForTopic != null)
                    allPartitions.addAll(AbstractPartitionAssignor.partitions(topic, numPartitionsForTopic));
            }
            return allPartitions;//所有的partition的List
        }

      group中所有consumer订阅的topic求并集
      for(每一个topic)
         根据topic的partition数量,构造TopicPartition对象,partitition序号从0开始
      end
      归并所有TopicPartition
      for(每一个TopicPartition)
        以RoundRobin的方式选择一个订阅了这个Topic的Consumer,将这个TopicPartition分派给这个Consumer
      end

在assign()方法中,CircularIterator是一个封装类,让一个有限大小的list变成一个RoundRobin方式的无限遍历。有兴趣的读者可以自行阅读代码。

RoundRobinAssignor与RangeAssignor最大的区别,是进行分区分配的时候不再逐个topic进行,即不是为某个topic完成了分区分派以后,再进行下一个topic的分区分派,而是首先将这个group中的所有consumer订阅的所有的topic-partition按顺序展开,然后,依次对于每一个topic-partition,在consumer进行round robin,为这个topic-partition选择一个consumer。

加入我们有两个topic :t0和t1,每个topic都有3个分区,分区编号从0开始,因此展开以后得到的TopicPartition的List是:[t0p0,t0p1,t0p2,t1p0,t1p1,t1p2]

我们有两个consumer C0,C1,他们都同时订阅了这两个topic。

然后,在这个展开的TopicParititon的List开始进行分派:

  • t0p0 分配给C0
  • t0p1 分配给C1
  • t0p2 分配给C0
  • t1p0 分配给C1
  • t1p1 分配给C0
  • t1p1 分配给C1

从以上分配流程,我们可以很清楚地看到RoundRobinAssignor的两个基本特征:

  1. 对所有topic的topic partition求并集
  2. 基于consumer进行RoundRobin轮询

最终分配结果是:

C0: [t0p0, t0p2, t1p1]
C1: [t0p1, t1p0, t1p2]

RoundRobinAssignor与RangeAssignor的重大区别,就是RoundRobinAssignor是在Group中所有consumer所关注的全体topic中进行分派,而RangeAssignor则是依次对每个topic进行分派。

假如现在有两个Topic:Ta和Tb ,每个topic都有两个partition,同时,有两个消费者Ca和Cb与Cc,这三个消费者全部订阅了这两个主题,那么,通过两种不同的分区分派算法得到的结果将是:

RangeAssignor:

先对Ta进行处理:会将TaP0分派给Ca,将TaP1分派给Cb

在对Tb进行处理:会将TbP0分派给Ca,将TbP1分派给Cb

最终结果是:

Ca:[TaP0,TbP0]
Cb:[TaP1,TbP1]
Cc:[]

RoundRobinAssignor:

将所有TopicPartition展开,变成:[TaP0,TaP1,TbP0,TbP1]

将TaP0分派给Ca,将TaP1分派给Cb,将TbP0分派给Cc,将TbP1分派给Ca

最终分派结果是:

Ca:[TaP0,TbP1]
Cb:[TaP1]
Cc:[TbP0]

可见,RoundRobinAssignor更能够在整个Group的范围内将所有的TopicPartition尽量分散,而RangeAssignor由于是逐个Topic单独进行分派,因此有可能让某些Consumer被分派到较多的partition而另外一些consumer却十分空闲。

阅读更多
博主设置当前文章不允许评论。
换一批

没有更多推荐了,返回首页