Tagged articles
Consumer Group
39 articles · Page 1 of 1
This article analyzes Kafka's consumer group rebalance mechanisms, comparing eager and cooperative protocols, explaining why partition transfers cause consumption pauses, detailing configuration parameters like session.timeout.ms and max.poll.interval.ms, and providing troubleshooting steps for lag spikes during rolling deployments.
Configuration TuningConsumer GroupCooperative Protocol
0 likes · 22 min read

This guide demonstrates building a reliable message queue with Spring Boot and Redis Stream, covering persistence, consumer group rebalancing, idempotency, dead-letter handling, and operational monitoring, with practical code examples and comparisons to Kafka and RabbitMQ.
Consumer GroupDead Letter QueueIdempotency
0 likes · 23 min read

This guide walks through the essential Kafka command‑line tools for creating, listing, describing, and altering topics, producing and consuming messages, and managing consumer groups, providing concrete examples and key parameters for each operation.
ConsumerConsumer GroupKafka
0 likes · 5 min read

This article walks through the essential Kafka command‑line tools, covering how to check the Kafka version, create, list, describe, alter, and delete topics, manage partitions, produce and consume messages, inspect consumer groups, reset offsets, query broker metadata, view log directories, and run built‑in performance tests for both producers and consumers.
Consumer GroupKafkaTopic Management
0 likes · 6 min read

Kafka consumer group rebalances can trigger message backlogs, duplicate processing, and data loss; this article explains common rebalance triggers, their impact on consumption, and practical configuration and coding strategies—such as tuning timeout parameters, using manual offset commits, and sticky partition assignment—to minimize disruptions.
Consumer GroupKafkaMessage Duplication
0 likes · 12 min read

In a JD senior Java architect interview, a Kafka consumer‑group rebalance storm caused QPS to drop from 120k to zero, triggering massive message loss and latency spikes, and the article walks through the rebalance fundamentals, failure causes, impact analysis, cooperative sticky assignor migration, and comprehensive monitoring and mitigation strategies.
Consumer GroupKafkaRebalance
0 likes · 28 min read

When Kafka consumer groups rebalance, partitions are reassigned, often causing message backlog, duplicate processing, or loss; understanding the triggers, impact, and optimization techniques—like tuning timeouts, managing offset commits, and using sticky assignors—can keep your streaming pipelines reliable.
Consumer GroupKafkaPerformance Tuning
0 likes · 13 min read

Kafka consumer issues such as message backlog, duplicate processing, and data loss often stem from consumer group rebalances triggered by changes in consumer count, partition count, subscription topics, or heartbeat and poll timeouts, and can be mitigated by tuning timeout settings, managing offset commits, and using sticky partition assignment.
Consumer GroupKafkaMessage Duplication
0 likes · 13 min read


mikechenSep 11, 2025 · Backend Development
This article explains why message ordering is critical in scenarios such as financial transactions, e‑commerce order updates, audit logs, and IoT devices, then details Kafka’s core components—topics, partitions, offsets, producers, brokers, and consumer groups—and describes how single‑partition consumption and consistent key hashing ensure ordered processing while balancing throughput.
BackendConsumer GroupKafka
0 likes · 5 min read

This article shares practical Kafka production insights, covering architecture overview, producer throughput tuning, message loss prevention, broker and consumer configurations, duplicate consumption avoidance, backlog mitigation, ordering guarantees, and the mechanics of consumer group rebalancing, helping engineers build stable, high‑performance streaming pipelines.
Consumer GroupKafkaMessage Queue
0 likes · 15 min read

The article introduces Redis Streams as a Kafka‑like messaging structure, explains its fundamental concepts and seven core commands (XADD, XRANGE, XREAD, XGROUP CREATE, XREADGROUP, XACK, XTRIM), demonstrates integration with Spring Boot, and evaluates its fit for lightweight, low‑backlog queue scenarios.
Consumer GroupRedisRedis Commands
0 likes · 14 min read

This article explains Kafka’s fundamental role as a message system, detailing topics, partitions, producers, consumers, replica management, consumer groups, the controller, Zookeeper coordination, and performance optimizations such as sequential writes, zero‑copy, log segmentation, and network design, providing a comprehensive overview for big‑data practitioners.
Consumer GroupKafkaMessage Queue
0 likes · 11 min read

This article explains Kafka's role as a messaging system, covering core concepts such as topics, partitions, producers, consumers, messages, cluster architecture, replicas, consumer groups, controller coordination with Zookeeper, and performance optimizations like sequential writes and zero‑copy networking.
Consumer GroupKafkaMessage Queue
0 likes · 11 min read

This article provides a comprehensive overview of Kafka, covering its core architecture, message queue models, communication process, partition selection, consumer groups, rebalancing strategies, partition assignment algorithms, reliability guarantees, replica synchronization, and reasons for removing Zookeeper in newer versions.
Consumer GroupKafkaPartitioning
0 likes · 20 min read

This article provides a comprehensive overview of Kafka, covering its core value for decoupling and asynchronous processing, fundamental concepts such as producers, consumers, topics, partitions and replication, high‑performance mechanisms like zero‑copy and OS cache, detailed resource evaluation for CPU, memory, disk and network, operational tools, consumer‑group rebalance strategies, LEO/HW offsets, controller management, and delayed‑task scheduling.
BackendCluster PlanningConsumer Group
0 likes · 29 min read

When starting a new Kafka consumer group, an unexpected SyncGroup error occurs due to a RecordTooLargeException, and the article walks through log inspection, identifies the oversized __consumer_offsets record, and resolves the issue by increasing the message.max.bytes configuration.
Consumer GroupKafkaRecordTooLargeException
0 likes · 5 min read

The article explains the role of Kafka's consumer group coordinator and consumer coordinator, details how group coordinators are selected, and walks through the JoinGroup, SyncGroup, LeaveGroup, and heartbeat processes, as well as partition assignment strategies and common Q&A.
Consumer GroupGroupCoordinatorJoinGroup
0 likes · 11 min read

The article demonstrates how kafka-go implements consumer groups by creating readers that spawn poll goroutines per partition, explains heartbeat‑driven rebalancing, and compares automatic versus manual offset‑commit strategies, highlighting their impact on throughput, reliability, and message‑processing semantics.
Consumer GroupGoKafka
0 likes · 15 min read

This article provides a diagram‑driven walkthrough of Kafka’s fundamental concepts—including topics, partitions, producers, consumers, consumer groups, and cluster architecture—explaining how messages flow, are stored, and achieve reliability and ordering within a distributed streaming system.
Cluster ArchitectureConsumer GroupKafka
0 likes · 6 min read

This article uses the Plants vs Zombies game to illustrate why Kafka topics need partitions, how consumer groups work, and the benefits of partitioning, replication, and load balancing in a distributed messaging system.
Consumer GroupKafkaMessage Queue
0 likes · 9 min read

This article explains Kafka consumer group rebalance, covering core concepts, trigger conditions, detailed protocol steps, common pitfalls like long pause times, and modern improvements such as static membership and incremental cooperative rebalance, plus practical configuration tips to minimize disruptions.
BackendConsumer GroupIncremental Rebalance
0 likes · 13 min read

This article explains Kafka’s core architecture—including topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance tricks like sequential writes and zero‑copy—to show how it achieves high‑throughput, fault‑tolerant messaging for large‑scale systems.
Consumer GroupKafkaMessage Queue
0 likes · 11 min read

This article explains the core concepts and detailed design of a custom message queue built on a distributed key‑value store, covering terminology, architecture, broker metadata, topic metadata, message format, sending, storage, retrieval, delay handling, retry mechanisms, dead‑letter queues, and TTL policies.
Consumer GroupDelay MessageDistributed KV
0 likes · 13 min read

This article provides a clear, visual walkthrough of Kafka’s fundamental architecture, explaining how producers and consumers interact, the role of topics and partitions, consumer groups, and ZooKeeper’s coordination, helping readers grasp message flow, storage, ordering, and fault‑tolerance in a distributed streaming system.
Consumer GroupKafkaMessage Queue
0 likes · 6 min read

This article explains Kafka's role as a decoupling message buffer, describes topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance optimizations such as sequential writes, zero‑copy, log segmentation, and its reactor‑style network design.
Consumer GroupReplicationmessaging
0 likes · 10 min read

This article explains how Redis can be used as a lightweight message‑queue solution by leveraging its List, Pub/Sub, and Stream data structures, covering core commands, blocking consumption, acknowledgment mechanisms, consumer groups, and practical usage patterns for distributed systems.
Consumer GroupListMessage Queue
0 likes · 20 min read


JavaEdgeDec 3, 2020 · Backend Development
This article explains how Kafka clients can request data via RPC, compares the partition consumption mode with the consumer‑group mode, outlines their protocols, server‑side processing, advantages, drawbacks, and provides guidance on when to choose each approach.
Consumer Groupbackend-developmentconsumption-mode
0 likes · 4 min read

This article introduces RocketMQ’s core concepts, including its deployment architecture, naming server, broker and client roles, subscription model, consumption modes, queue allocation algorithms, rebalancing, offset storage, transaction and delayed messages, as well as filtering mechanisms, providing a solid foundation for further practice.
BackendConsumer GroupMessage Queue
0 likes · 13 min read

This article explains how Kafka consumer groups assign partitions, the four situations that trigger a rebalance, the impact of consumer poll timeouts, and practical ways to tune max.poll.interval.ms and max.poll.records to avoid rebalance‑related errors.
Consumer GroupKafkaRebalance
0 likes · 12 min read

This article explains how Kafka consumer groups accelerate message consumption by distributing partitions across multiple consumers, details the three key characteristics of consumer groups, and provides in‑depth guidance on partition assignment strategies and offset management with practical Java code examples.
Consumer GroupKafkaPartition Assignment
0 likes · 13 min read

This article explains the fundamentals of Apache Kafka's consumer group rebalance protocol, covering partitioning, group coordination, JoinGroup and SyncGroup requests, heartbeat handling, common pitfalls, and best‑practice warnings for reliable streaming data processing.
Consumer GroupRebalancedistributed-systems
0 likes · 13 min read

This article explains the relationship between Kafka consumers and consumer groups, when repartition occurs, how consumers interact with Zookeeper, the overall consumer workflow, and the three delivery semantics (at‑least‑once, at‑most‑once, exactly‑once) in a concise, technical overview.
BackendConsumer GroupKafka
0 likes · 8 min read

This article explains Kafka's core architecture, covering how topics and partitions are stored, the advantages of its consumption model, the internal network and threading design, and the high‑reliability distributed log storage and replication mechanisms that ensure data durability and scalability.
Consumer GroupDistributed MessagingHigh Availability
0 likes · 11 min read

The article explains Kafka's consumer‑group rebalance and Pulsar's unified queue/stream subscription models, compares their partition assignment strategies, and demonstrates both with Docker‑based Pulsar setups, Java consumer code, and practical failover and exclusive scenarios.
Consumer GroupFailoverKafka
0 likes · 6 min read

This article explains why duplicate message consumption occurs when using Spring Cloud Stream with RabbitMQ or Kafka, introduces the concept of consumer groups, and provides a step‑by‑step Java example showing how to configure and use consumer groups to ensure each message is processed by only one instance.
Consumer GroupKafkaspring-boot
0 likes · 6 min read

The article investigates a Kafka cluster outage where several brokers became unavailable and consumers could not join groups, explains the role of __consumer_offsets, analyzes the coordinator selection logic, identifies a stuck loadGroupsForPartition operation and compact thread failure, and documents the recovery steps taken.
Consumer GroupLog CompactionOFFSET
0 likes · 11 min read

This guide explains how to configure message partitioning in Spring Cloud Stream by adjusting consumer and producer properties—such as group, destination, partitioned flag, instanceCount, instanceIndex, partitionKeyExpression, and partitionCount—to ensure that messages with the same characteristics are consistently processed by the same instance across multiple service instances.
ConfigurationConsumer GroupMessage Partitioning
0 likes · 4 min read

This article explains how Spring Cloud Stream uses binders to isolate applications from messaging middleware, defines channels for input and output, demonstrates publish‑subscribe with RabbitMQ, shows how consumer groups prevent duplicate processing, and introduces message partitioning for ordered handling.
BinderConsumer GroupMessage Partitioning
0 likes · 11 min read

This article explains Kafka’s core concepts—including producers, consumers, topics, partitions, brokers, and consumer groups—describes its distributed architecture with leader‑follower replication, and provides three hands‑on kafka‑python experiments that demonstrate basic messaging, fault‑tolerant consumer groups, and offset management for reliable consumption.
Consumer GroupKafkaProducer-Consumer
0 likes · 9 min read
