Apache Kafka Fundamentals
Apache Kafka is a distributed event-streaming platform that stores and delivers high-throughput streams of records. Producers write events to topics partitioned across a cluster, and consumers read them independently, enabling decoupled real-time data pipelines and event-driven architectures.
itDistributed systems, messaging, and integration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Apache Kafka Fundamentals
Apache Kafka is a shared, durable record of events: a producer writes an event once, and several consumer groups can each read it without pulling it away from the others. That sounds suspiciously like a message broker with ambitions. The important difference is that Kafka keeps the event according to retention policy, so a consumer can return later and read history again.
The useful picture is a topic divided into partitions. A partition is an append-only log with its own order and offsets. Kafka has not misplaced the global order; it never promised one across partitions. A stable key sends related records to the same partition, which is how an order's created and paid events avoid becoming an interpretive dance.
A consumer group remembers its own position in each partition. Members of one group share partitions for parallel work; a different group receives an independent view of the same records. That gives billing and analytics separate subscriptions without building a direct connection from every producer to every destination. It also means offsets matter: commit before work and a failure can skip it; commit after work and a failure can repeat it.
Replication makes a partition survive broker failures when the replication, acknowledgments, and in-sync-replica settings agree. No single setting gets to wear the whole durability hat. Retention and compaction answer a different question: how much past remains available for replay or rebuilding keyed state. Reading is not deletion, which is wonderfully useful until a replay repeats a payment or an email.
Kafka Connect moves records between Kafka and outside systems when the flow is reusable. Kafka Streams runs transformations, joins, and aggregations in a Java application. KRaft controllers manage metadata while brokers handle partition data and client traffic. Those pieces are related, but they are not interchangeable boxes with unusually confident names.
Read the Intro for the complete architecture and failure behavior. Use the Slides when the producer-to-partition-to-group path needs a visual reset. Keep the Cheatsheet nearby for settings and decision rules. Then run the Practice Reference and Exercise to watch partitions, groups, offsets, and replay behave in a local broker before any external side effect is invited to the party.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://kafka.apache.org/
Supports
- Apache Kafka identity as an event streaming platform
- Official project and documentation entry point
- https://kafka.apache.org/intro
Supports
- Events, producers, consumers, topics, partitions, brokers, and replication
- Per-partition ordering and key-based partition placement
- Independent reading by multiple consumers and retained event history
- Core publish, store, and process capabilities
- https://github.com/apache/kafka/blob/trunk/docs/getting-started/introduction.md
Supports
- Official source text for the Kafka introduction
- Topic partitioning, ordering, replication, and producer-consumer concepts
- https://kafka.apache.org/uses
Supports
- Messaging, activity tracking, metrics, log aggregation, stream processing, and event sourcing examples
- Workload-fit discussion in the introduction and slides
- https://kafka.apache.org/quickstart
Supports
- Local startup, topic creation, command-line production, and command-line consumption
- First practical step in the learning path
- https://github.com/apache/kafka/blob/trunk/docs/getting-started/quickstart.md
Supports
- Topic description fields for partition count, replication factor, leader, replicas, and in-sync replicas
- Official quickstart command sequence
- https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/clients/consumer/KafkaConsumer.java
Supports
- Consumer groups, partition assignment, group rebalancing, and manual assignment
- Offset commits, poll behavior, pause and resume, and processing-position tradeoffs
- At-least-once behavior and atomic storage of offsets with external results
- Consumer parallelism bounded by assigned partitions
- https://github.com/apache/kafka/blob/trunk/docs/implementation/distribution.md
Supports
- Consumer offset commits stored in the compacted internal offsets topic
- Replication and acknowledgment of committed group offsets
- https://github.com/apache/kafka/blob/trunk/clients/src/main/java/org/apache/kafka/common/config/TopicConfig.java
Supports
- Delete as the default cleanup policy
- Compaction retaining the latest value for each key
- Combined delete and compact cleanup policy
- Time and size controls for segment deletion
- https://kafka.apache.org/documentation/#compaction
Supports
- Log compaction behavior and keyed state reconstruction
- Delayed cleanup behavior rather than immediate table-style replacement
- https://kafka.apache.org/documentation/#producerconfigs
Supports
- Producer acknowledgments, retries, idempotence, batching, compression, and timeouts
- https://kafka.apache.org/documentation/#brokerconfigs_log.retention.ms
Supports
- Time-based log retention configuration
- Record lifetime controlled independently from consumer reads
- https://kafka.apache.org/documentation/#producerconfigs_acks
Supports
- Producer acknowledgment levels and their durability tradeoffs
- All acknowledgments waiting for the full in-sync replica set
- https://kafka.apache.org/documentation/#brokerconfigs_min.insync.replicas
Supports
- Minimum in-sync replicas interacting with all acknowledgments
- Write rejection when the required in-sync replica count is unavailable
- https://kafka.apache.org/documentation/#semantics
Supports
- At-most-once, at-least-once, and exactly-once delivery semantics
- Idempotent producer and transactional processing boundaries
- https://github.com/apache/kafka/blob/trunk/examples/src/main/java/kafka/examples/TransactionalClientDemo.java
Supports
- Idempotent producer and transactional producer configuration
- Atomic production and sending consumed offsets to a transaction
- Read-committed consumer isolation
- https://kafka.apache.org/documentation/#design
Supports
- Persistence, replication, delivery semantics, compaction, quotas, and distributed design
- Durability as an interaction among replication and client settings
- https://kafka.apache.org/documentation/#connect
Supports
- Kafka Connect connectors, workers, tasks, source connectors, and sink connectors
- Connect as a framework for reusable movement between Kafka and external systems
- https://github.com/apache/kafka/blob/trunk/connect/api/src/main/java/org/apache/kafka/connect/sink/SinkTask.java
Supports
- Sink task partition assignment, batching, flush, rebalancing, and shutdown lifecycle
- https://kafka.apache.org/documentation/streams/
Supports
- Kafka Streams as a Java client library
- Stateful transformations, joins, aggregations, local state, and recovery
- https://github.com/apache/kafka/blob/trunk/streams/src/main/java/org/apache/kafka/streams/StreamsConfig.java
Supports
- At-least-once and exactly-once version two processing guarantees
- Kafka transaction requirements for exactly-once stream processing
- https://kafka.apache.org/documentation/#kraft
Supports
- KRaft controller, broker, and combined process roles
- Metadata quorum concepts and deployment guidance
- https://kafka.apache.org/documentation/#consumerconfigs
Supports
- Group identity, offset commit, poll timing, assignment, and isolation configuration
- https://kafka.apache.org/documentation/#security
Supports
- Encryption, authentication, and authorization study path
- https://cwiki.apache.org/confluence/display/KAFKA/Changes%2Bin%2BKafka%2B0.8
Supports
- Kafka 0.8 replication milestone in the timeline
- https://kafka.apache.org/community/downloads/
Supports
- Kafka 0.8, 0.8.1, and 0.9 release dates in the timeline
- https://kafka.apache.org/10/getting-started/upgrade/
Supports
- Kafka Streams introduction in Kafka 0.10
- https://kafka.apache.org/0110/javadoc/org/apache/kafka/clients/producer/KafkaProducer.html
Supports
- Kafka 0.11 idempotent and transactional producer capabilities
- https://blogsarchive.apache.org/kafka/entry/what-s-new-in-apache6
Supports
- Kafka 3.0 KRaft improvements
- https://kafka.apache.org/35/getting-started/upgrade/
Supports
- KRaft production readiness for new clusters in Kafka 3.3
- https://kafka.apache.org/34/operations/kraft/
Supports
- Kafka 3.4 ZooKeeper-to-KRaft migration milestone
- https://kafka.apache.org/blog/2025/03/18/apache-kafka-4.0.0-release-announcement/
Supports
- Kafka 4.0 ZooKeeper-free operation
- https://www.confluent.io/en-gb/blog/cooperative-rebalancing-in-kafka-streams-consumer-ksqldb/
Supports
- Consumer rebalancing disruption and incremental cooperative rebalancing
- https://www.confluent.io/confluent-cloud/
Supports
- Confluent Cloud as a managed Kafka platform
- https://aws.amazon.com/documentation-overview/msk/
Supports
- Amazon MSK as managed Apache Kafka
- https://aiven.io/docs/products/kafka
Supports
- Aiven managed Kafka and Connect capabilities
- https://www.redpanda.com/redpanda-cloud
Supports
- Redpanda Cloud Kafka API compatibility and managed deployment
- https://learn.microsoft.com/en-us/azure/event-hubs/azure-event-hubs-apache-kafka-overview
Supports
- Azure Event Hubs Kafka protocol endpoint
