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
Intro
Apache Kafka Fundamentals
Apache Kafka moves event records between systems and retains them for later reading. It combines messaging with a distributed, replayable log.
That combination changes how you design data flows. A consumer does not remove a record when it reads it. Kafka keeps the record according to the topic's retention policy. Consumers track their own position and can reread retained records.
The problem Kafka solves
Applications often need the same event for different purposes. An order event might feed fulfillment, fraud detection, analytics, and customer notifications.
Direct point-to-point integrations couple every producer to every consumer. Each new destination adds another connection, failure mode, and deployment dependency.
Kafka puts a durable event stream between those systems. Producers write records without knowing every consumer. Consumers read records at their own pace and keep independent positions.
This model supports four common purposes:
- Publish and subscribe to event streams.
- Store event streams for a configured period.
- Process event streams as they arrive or after replay.
- Connect databases and services through reusable source and sink connectors.
The core path
Keep this path in mind:
Producer → topic → partition → broker → consumer group
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
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
