In the ever-evolving landscape of data processing and real-time analytics, Apache Kafka has emerged as a cornerstone technology. Kafka's ability to handle high-throughput, fault tolerance, and real-time data streaming makes it a crucial component of modern data architectures.
As organisations increasingly adopt Kafka, the demand for skilled Kafka professionals has skyrocketed. To prepare for Kafka interviews, it's essential to have a solid understanding of the technology and be ready to answer questions spanning various difficulty levels. In this article, we'll explore a range of Kafka interview questions, from basic to advanced, to help you shine during your Kafka-related interviews.
Understanding Kafka: A Brief Overview
Apache Kafka is an open-source, distributed event streaming platform used for building real-time data pipelines and streaming applications. It was developed by LinkedIn and later open-sourced as an Apache project.
Kafka is designed to handle high-throughput, fault tolerance, and scalability while providing a publish-subscribe model for data distribution. It serves as a reliable and efficient bridge between data producers and consumers, making it a critical component for data processing in modern software architectures.
It is replacing traditional messaging systems, because it preserves data records longer and provides higher availability. Its popularity continues to grow as more companies adopt it as a replacement for traditional message brokers.
Basic Kafka Interview Questions & Answers
1. What is the Messaging System?
A messaging system is a way of sending data between different applications. There are two main types of messaging systems: point to point and pub-sub. Here is a short and simple explanation of each one:
- Point to point: In this system, each message goes to one queue and one consumer. The message is removed from the queue after it is read by the consumer. This is good for tasks that need to be done by only one worker, such as processing an order.
- Pub-sub: In this system, each message goes to one topic and many subscribers. The message stays in the topic until all the subscribers have read it. This is good for tasks that need to be shared by many workers, such as watching a TV channel.
2. What is Kafka’s Main Use Case?
Apache Kafka is an open-source distributed event streaming platform that is used for building real-time data pipelines and streaming applications. It is horizontally scalable, fault-tolerant, and fast. Some of the popular use cases for Apache Kafka are:
- Messaging: Kafka works well as a replacement for a more traditional message broker. In comparison to most messaging systems, Kafka has better throughput, built-in partitioning, replication, and fault-tolerance which makes it a good solution for large scale message processing applications.
- Website Activity Tracking: The original use case for Kafka was to be able to rebuild a user activity tracking pipeline as a set of real-time publish-subscribe feeds. This means site activity (page views, searches, or other actions users may take) is published to central topics with one topic per activity type.
- Metrics: Kafka is often used for operational monitoring data. This involves aggregating statistics from distributed applications to produce centralized feeds of operational data.
- Log Aggregation: Many people use Kafka as a replacement for a log aggregation solution. Log aggregation typically collects physical log files off servers and puts them in a central place (a file server or HDFS perhaps) for processing. Kafka abstracts away the details of files and gives a cleaner abstraction of log or event data as a stream of messages.
- Stream Processing: Many users of Kafka process data in processing pipelines consisting of multiple stages, where raw input data is consumed from Kafka topics and then aggregated, enriched, or otherwise transformed into new topics for further consumption or follow-up processing.
3. Explain the Key Components of Kafka.
Apache Kafka is a distributed event streaming platform that has several key components:
- Broker: Apache Kafka runs as a cluster on one or more servers across multiple data centers. A broker is a Kafka cluster instance.
- Topics: Topics represent specific streams of records, where data is categorized and stored. Producers publish records to topics, and consumers read and process records from these topics.
- Producers: Producers in Kafka are responsible for publishing records to Kafka topics. They generate and send data to specific topics based on the desired criteria.
- Consumers: Consumers in Kafka read and process records from the Kafka topics they subscribe to. They consume the published data and perform various operations, such as data analysis, storage, or forwarding.
4. What is a Kafka Topic?
A Kafka topic is the most fundamental unit of organization in Apache Kafka. It is similar to a table in a relational database or a folder in a file system. Topics represent specific streams of records, where data is categorised and stored. Producers publish records to topics, and consumers read and process records from these topics. Topics are used to store and organise data according to different categories and use cases, allowing users to easily produce and consume messages to and from the Kafka servers.
5. Describe the role of a Kafka Broker?
A Kafka broker is a server that runs an instance of Kafka. It is responsible for maintaining the list of consumers for each topic, as well as managing the storage of messages for each topic1. A Kafka cluster typically consists of multiple brokers, all of which work together to provide a fault-tolerant and scalable messaging system.
The role of the broker is to receive and store messages from producers, and then forward them to consumers in real-time. It also handles the load balancing of consumers and manages the retention of messages based on configurable retention policies. Brokers also handle replication of partitions between each other to ensure that data is highly available and fault-tolerant.
6. What is the Role of the Offset in Kafka?
In Apache Kafka, an offset is a simple integer value that is used to maintain the current position of the consumer. The offset plays a very important role while consuming Kafka data. It is a way of tracking the sequential order in which messages are received by Kafka topics.
Keeping track of the offset, or position, is important for nearly all Kafka use cases and can be an absolute necessity in certain instances, such as financial services. The Kafka consumer offset allows processing to continue from where it last left off if the stream application is turned off or if there is an unexpected failure. In other words, by having the offsets persist in a data store (Kafka and/or ZooKeeper), data continuity is retained even when the stream application shuts down or fails.
7. Can Kafka be Used Without ZooKeeper?
Yes, Kafka can be used without ZooKeeper. Starting with version 2.8, Kafka can be run without ZooKeeper. The release of 2.8.0 in April 2021 provided all a chance to start using Kafka without ZooKeeper.
However, this version is not ready for use in production and is missing some core functionality1. One important component not yet available in this version is control of ACL. In this case, instead of storing all the metadata inside ZooKeeper, all the Kafka configuration data will be stored as a separate partition within Kafka itself.
8. Why are Replications Critical in Kafka?
Replication is a critical feature of Kafka that allows it to provide high durability and availability. It is enabled at the topic level, and when a new topic is created, the number of replicas can be specified explicitly or through defaults. Each partition of that topic will then be replicated that many times1. This number is referred to as the replication factor.
With a replication factor of N, in general, we can tolerate N-1 failures without data loss and while maintaining availability. Replication ensures that published messages are not lost and can be consumed in the event of any machine error, program error or frequent software upgrades.
9. What is a Partitioning Key in Kafka?
In Kafka, a partitioning key is used to determine the destination partition for a message. When a producer sends a message to a topic, it can specify a key for the message. The key is then passed through a hash function to determine the partition id2.
If no key is specified, the producer will use one of several methods to determine the target partition, such as round-robin or sticky partitioning1. By using a partitioning key, you can ensure that messages with the same key are sent to the same partition, which can be useful for maintaining message order for certain use cases.
10. What is the Critical Difference Between Flume and Kafka?
The critical difference between Apache Kafka and Apache Flume is that Kafka is a distributed streaming platform that is used for building real-time streaming data pipelines and applications, while Flume is a distributed, reliable, and available service for efficiently collecting, aggregating, and moving large amounts of streaming data into the Hadoop Distributed File System (HDFS).
Kafka runs as a cluster which handles the incoming high volume data streams in real time. It is optimised for ingesting and processing streaming data in real-time. On the other hand, Flume is a tool to collect log data from distributed web servers. It is designed to efficiently collect, aggregate and move large amounts of log data from many different sources to a centralised data store.
11. When Does QueueFullException Occur in the Producer?
A QueueFullException typically occurs when the Kafka Producer attempts to send messages at a pace that the Broker cannot handle at that time. To collaboratively handle the increased load, users will need to add enough brokers, since the Producer doesn’t block.
12. What is a Partition of a Topic in Kafka Cluster?
A partition is a subdivision of a Kafka topic. Partitioning is what enables messages to be split in parallel across several brokers in the cluster. In partitioning a topic, Kafka breaks it into fractions and stores each of them in different nodes of its distributed system. The number of fractions is determined by us or by the cluster default configurations. Kafka guarantees the order of the events between the partitions of the same topic. Thus, consuming from a partitioned topic should be the same as consuming from that topic without partitioning
13. Explain Geo-Replication in Kafka.
Geo-replication in Kafka is a process by which you can duplicate messages in one cluster across other data centres or cloud regions. Geo-replication involves copying all the files and allows them to be stored across the globe if required.
In Kafka, Geo-replication can be achieved by using Kafka’s MirrorMaker Tool. Many organisations use Apache Kafka to support data pipelines that span multiple geographically distributed data centres, for use cases ranging from high availability and disaster recovery to data aggregation and regulatory compliance.
14. What are the Traditional Methods of Message Transfer?
The traditional methods of message transfer include two methods:
- Queuing: In a queuing, a pool of consumers may read a message from the server and each message goes to one of them1.
- Publish-Subscribe: In this model, messages are broadcasted to all consumers.
Moderate Kafka Interview Questions & Answers
15. Explain the Concept of a Kafka Partition?
A Kafka partition is a subdivision of a Kafka topic. Partitioning is what enables messages to be split in parallel across several brokers in the cluster. In partitioning a topic, Kafka breaks it into fractions and stores each of them in different nodes of its distributed system. The number of fractions is determined by us or by the cluster default configurations. Kafka guarantees the order of the events between the partitions of the same topic. Thus, consuming from a partitioned topic should be the same as consuming from that topic without partitioning.
16. How is Kafka Better than Traditional Methods?
Apache Kafka is a distributed streaming platform that is designed to handle high-throughput data in real-time.
- It is often compared to traditional messaging systems such as Enterprise Service Bus (ESB), but there are some key differences between the two
- ESBs focus on the integration of legacy and off-the-shelf systems, using an ephemeral and comparably low-throughput messaging layer, which encourages request-response protocols.
- Kafka, however, puts emphasis on high-throughput events and stream processing.
- A Kafka cluster is a distributed system at heart, providing high availability, storage, and high performance with linear scale-out as comparison benchmarks show.
- This is quite different from traditional messaging systems, which are limited to a single machine, or if they do scale outward, those scalability properties do not stretch from end to end.
- Kafka also has tools like its Kafka Streams library and the streaming database ksqlDB that allow you to write applications that manipulate events as they move and evolve.
- These make the processing capabilities of a database available in the application layer, via an API, and outside the confines of the shared broker.
17. Explain the Four Core API Architectures that Kafka uses.
Apache Kafka is a distributed streaming platform that offers four core APIs: the Producer API, Consumer API, Streams API, and Connector API.
- Producer API: The Producer API allows applications to send streams of data to topics in the Kafka cluster.
- Consumer API: The Consumer API allows applications to read streams of data from topics in the Kafka cluster.
- Streams API: The Streams API allows applications to effectively transform input streams to output streams. It acts as a stream processor that consumes input streams from one or more topics, processes them, and produces output streams to one or more output topics.
- Connector API: The Connector API allows building and running reusable producers or consumers that connect Kafka topics to existing applications or data systems. It can ingest entire databases and stream table updates to Kafka topics, making the data available for stream processing with low latency.
18. How Does Kafka Ensure Fault Tolerance?
Apache Kafka ensures fault tolerance through several mechanisms, including partition replication, leader election, and controller election. These mechanisms work together to ensure that Kafka can continue to operate even in the pace of failures.
- Partition Replication: Kafka achieves fault tolerance by replicating each partition over a number of servers. This is done by specifying a replication factor, which determines how many copies of the partition data are stored on different brokers. If one broker fails, the data is still available on the other brokers.
- Leader Election: Each partition has a leader broker that handles all reads and writes to the partition. If the leader broker fails, a new leader is elected from among the in-sync replicas (ISRs) of the partition. The ISRs are replica brokers that are fully caught up with the changes of the leader broker.
- Controller Election: The controller broker is responsible for electing the leader broker for each partition. If the controller broker fails, a new controller is elected from among the remaining brokers.
19. What is the Role of the Kafka Producer?
The primary role of a Kafka producer is to take producer properties and records as inputs and write them to an appropriate Kafka broker. Producers serialise, partition, compress, and load balance data across brokers based on partitions. They automatically know to which broker and partition to write based on the message, and in case there is a Kafka broker failure in the cluster, the producers will automatically recover from it, making Kafka resilient.
Producers can use message keys to determine how to send data to a topic partition. If a key is not sent with the message, the data will be sent in a round-robin fashion. However, if a key is sent with the message, all messages that share the same key will always go to the same partition. This is an important property of Kafka because it means that if you need ordering for a specific field, you can ensure that all messages with the same key are written to the same partition in the order received.
20. Explain the Concept of Leader and Follower in Kafka.
Apache Kafka follows the Leader-Follower concept to ensure the availability of data in every case. In Kafka, for each topic partition, one broker is chosen as the leader for the other brokers (the followers). The goal of the followers is to copy the updated log from the leader, and the leader is the one that can write to the log.
One of the chief duties of the leader is to assign replication of topic partitions to the follower brokers. Kafka guarantees that every partition replica resides on a different broker (whether if it’s the leader or a follower), so the maximum replication factor is the number of brokers in the cluster.
Every partition follower is reading messages from the partition leader (acts like a kind of consumer) and does not serve any consumers of that partition (only the partition leader serves read/writes). When a partition leader shuts down for any reason (e.g. a broker shuts down), one of its in-sync partition followers becomes the new leader.
21. Why is Topic Replication Important in Kafka? What Does ISR Mean in Kafka?
Topic replication is an important feature in Apache Kafka that ensures the availability and reliability of data in the event of individual node failures. Replication is the process of having multiple copies of the data available across different servers for the purpose of availability in case one of the brokers goes down. In Kafka, replication happens at the partition level, i.e., copies of the partition are maintained at multiple broker instances.
When a topic has a replication factor of 3, this means that there will be three copies of each of its partitions. Kafka considers that a record is committed when all replicas in the In-Sync Replica set (ISR) have confirmed that they have taken the record into account. While creating a Kafka topic, we can define the number of copies we want to have for the data.
ISR refers to the replicas of a partition that are “in sync” with the leader. The leader is the replica to which all client and broker requests are directed. The definition of “in-sync” depends on the topic configuration, but by default, it means that a replica is or has been fully caught up with the leader in the last 10 seconds.
22. Explain in Depth Kafka's Consumer Group Concept
In Apache Kafka, a consumer group is a group of consumers that work together to consume and process messages from one or more topics in parallel. Consumer groups allow Kafka consumers to work together and process events from a topic in parallel. Consumers are assigned a subset of partitions from a topic or set of topics and can parallelise the processing of those events.
All the Consumers in a group have the same group.id. Only one Consumer reads each partition in the topic. The maximum number of Consumers is equal to the number of partitions in the topic. When consumers are added or removed from a consumer group—either because of a changing workload requirement, a rolling machine, or a consumer failure—the Kafka brokers will redistribute the topic-partitions across the new or remaining active members within the group2.
To start using consumer groups, just give multiple consumers the same group.id. The group.id can use any string you like, and all the consumers with the same string will be in the same group. For example, you might have 5 consumers all running with group.id=invoice-emails, and they will work-share; at the same time, a single consumer can read the same events from the same topic with group.id=sales-analytics and it will work completely independently.
23. What is the Maximum Message Size that Kafka Can Receive?
The maximum size of a message that can be received by Kafka is determined by the message.max.bytes attribute. By default, this limit is 1MB. However, this value can be increased by modifying the message.max.bytes attribute in the broker configuration and the max.partition.fetch.bytes attribute in the consumer configuration.
It is important to note that the fetch.message.max.bytes property of the consumer must be at least as large as the maximum message size, otherwise there could be a situation where producers can send messages larger than the consumer can consume/fetch.
Advanced Kafka Interview Questions & Answers
24. Discuss Kafka's Exactly-Once Message Processing Semantics
Kafka’s exactly-once message processing semantics is a feature that ensures that messages are delivered exactly once between producer and consumer applications. This is achieved through the use of the Transactional API, which was introduced in Kafka 0.11 release and Confluent Platform 3.3.
In a distributed publish-subscribe messaging system like Kafka, the computers that make up the system can always fail independently of one another. Depending on the action the producer takes to handle such a failure, you can get different semantics: At-least-once semantics, At-most-once semantics, and Exactly-once semantics.
Initially, Kafka only supported at-most-once and at-least-once message delivery. However, the introduction of Transactions between Kafka brokers and client applications ensures exactly-once delivery in Kafka. To achieve Exactly-Once semantics, Apache Kafka uses a combination of producer settings and Kafka Streams APIs. The producer must set the ‘acks’ property to ‘all’ to ensure all cluster (source) brokers acknowledge the message.
25. Differentiate Features Between Rabbitmq and Kafka.
|Architecture||General-purpose message broker supporting request/reply, point-to-point, and pub-sub communication patterns. Smart broker/dumb consumer model.||Message and stream platform for high-volume publish-subscribe messages and streams. Durable, fast, and scalable. Dumb broker/smart consumer model.|
|Handling of Messages||Does not support message ordering. Allows for specifying priorities for messages.||Enables message ordering through partitions and the use of message keys. Does not support message prioritization|
|Approach||Push paradigm with prefetch limit on consumers to prevent them from becoming overwhelmed.||Pull model where consumers request batches of messages from a given offset. Allows for long-pooling to eliminate tight loops|
|Performance||Can handle a high volume of messages but requires more resources to do so.||Provides significantly better performance by using sequential disc I/O. Can achieve high throughput with limited resources, making it suitable for large data use cases.|
26. What are the Parameters That You Should Look for While Optimising Kafka for Optimal Performance?
There are several parameters that you should consider while optimising Kafka for optimal performance. According to a Red Hat Developer article, the performance of your Apache Kafka environment will be affected by many factors, including choices such as the number of partitions, number of replicas, producer acknowledgments, and message batch sizes you provision. Different applications have different requirements. Some prioritise latency over throughput, and some do the opposite. Similarly, some applications put a premium on durability, whereas others care more about availability. The article introduces a way of thinking about the trade-offs and how to design your message flows using a model called the Kafka optimisation theorem.
Another article explains that there are three major components of Apache Kafka: producers, consumers, and brokers. Understanding their functions will help you optimize Kafka’s performance. Even though Kafka is already optimized out of the box, there is some tuning you can do to improve cluster performance. When doing so, there are two main metrics to consider: Throughput (the number of messages that arrive in a given amount of time) and Latency (the amount of time it takes to process each message). Most systems focus on optimising one or the other, but Kafka seeks to optimize both.
27. Differentiate Features Between Redis and Kafka
|Redis is an in-memory, key-value data store which is also open source||Apache Kafka is a messaging system that allows you to publish and subscribe to streams of messages that are based on topics and partition|
|Redis pub/sub is mostly like a fire and forget system where all the messages you produced will be delivered to all the consumers at once and the data is kept nowhere||Kafka, on the other hand, is a high throughput, distributed log that can be used as a queue. Here any number of users can produce and consumers can consume at any time they want. It also provides persistence for the messages sent through the queue.|
|Redis Pub/Sub is push based while Kafka Pub/Sub is pull based. That means messages published to Redis will be automatically delivered to subscribers||Data/messages are never pushed out to consumers, the consumer will ask for messages when the consumer is ready to handle the message.|
|Use Redis if you want a fire and forget kind of system, where all the messages that you produce are delivered instantly to consumers. If speed is most concerned. If you can live up with data loss. If you don’t want your system to hold the message that has been sent. The amount of data that is gonna be dealt with is not huge||Use Kafka if you want reliability. If you want your system to have a copy of messages that has been sent even after consumption. If you can’t live up with data loss. If Speed is not a big concern. data size is huge|
28. Differentiate Between Kafka and Java Messaging Service (JMS)
|Kafka||Java Messaging Service (JMS)|
|Kafka is a distributed streaming platform that provides a lot of scalability and is useful for real-time data processing||JMS is a long-standing Java API used generally for developing messaging applications, with its primary function of being able to send messages between two or more clients|
|Kafka is an implementation rather than a standard||JMS is a standard where you have different vendors|
|Kafka is a messaging broker, storage system, data integration platform with Kafka Connect, and stream-processing platform with Kafka Streams||JMS has been successfully solving a lot of problems for the last 20 years. It works relatively well on the cloud, on things like Kubernetes or in containers, because it doesn’t have any consumer limits when you have queues|
|Kafka can process large amounts of data because of its distributive nature||JMS is not a distributive system and hence only a small amount of data can be processed.|
29. What are Kafka Streams and KSQL?
Kafka Streams is a client library for building applications and microservices, where the input and output data are stored in an Apache Kafka® cluster. It is a powerful tool that allows developers to interact with Kafka in an easier way.
KSQL, on the other hand, is a streaming SQL engine for Apache Kafka that you can use to perform stream processing tasks using SQL statements. It is built on top of Kafka Streams and provides anyone who knows SQL with a simpler alternative to process the data coming into Kafka2. KSQL lowers the entry bar to the world of stream processing, providing a simple and completely interactive SQL interface for processing data in Kafka. You no longer need to write code in a programming language such as Java or Python! KSQL is distributed, scalable, reliable, and real-time. It supports a wide range of powerful stream processing operations including aggregations, joins, windowing, and much more.
30. Explain How Kafka Handles Data Retention and Compaction
Kafka handles data retention using two methods: time-based retention and key-based retention (also known as compaction).
Time-based retention is specified by setting the cleanup.policy to delete and setting the retention.ms to some number of milliseconds. With this set, events will be kept in the topics at least until they have reached that time limit. Once they have hit that limit, they may not be deleted right away. This is because event deletion happens at the segment level. A segment will be marked for deletion once its youngest event has passed the time threshold.
Compaction, on the other hand, is a key-based retention mechanism. To set a topic to use compaction, set its cleanup.policy to compact. The goal of compaction is to keep the most recent value for a given key. This might work well for maintaining the current location of a vehicle in your fleet, or the current balance of an account. However, historical data will be lost, so it may not always be the best choice. Compaction also provides a way to completely remove a key, by appending an event with that key and a null value. If this null value, also known as a tombstone, is the most recent value for that key, then it will be marked for deletion along with any older occurrences of that key.
31. What do you Know About Kafka MirrorMaker?
Kafka MirrorMaker is a tool that enables the “mirroring” of a stream. Given source and destination Kafka clusters, MirrorMaker ensures any messages sent to the source cluster are received by both the source and destination clusters. It is a tool for mirroring data between Apache Kafka clusters. It leverages the Kafka Connect framework to replicate data, which improves resiliency. MirrorMaker 2 (MM2) became available in Kafka 2.4.0 (see KIP-382) and leverages the Kafka Connect framework to simplify its configuration and operations.
32. What is Confluent Kafka and What are its Advantages?
Confluent Kafka is a fully managed, cloud-native data streaming platform that is built on top of Apache Kafka. It provides a complete set of enterprise-grade features to unleash developer productivity, operate efficiently at scale, and meet all of your architectural requirements before moving to production.
Some of the advantages of using Confluent Kafka are:
- It manages data streaming and provides an open-source platform.
- It streamlines admin operations and empowers cloud technology.
- It provides a truly cloud-native experience, completing Kafka with a holistic set of enterprise-grade features.
- It offers a 99.99% uptime SLA and committer-driven expertise, providing support and services from the team with over one million hours of technical experience with Kafka.
33. Explain How Kafka Handles Message Compression, its Need, and Any Potential Disadvantages?
Message compression in Kafka is a feature that allows you to reduce the size of your messages as they are sent and stored in Kafka. This can help you save network bandwidth and disk space, as well as improve the performance and scalability of your Kafka cluster. However, message compression also comes with some trade-offs, such as increased CPU usage and latency.
There are four types of compression algorithms that Kafka supports: gzip, snappy, lz4, and zstd. Each of them has different characteristics in terms of compression ratio, speed, and CPU consumption. You can choose the compression type that suits your application needs by setting the compression.type property in your producer configuration.
The need for message compression in Kafka depends on the nature and volume of your data. If you have large amounts of data that are fairly repetitive, such as JSON or XML messages, server logs, or sensor readings, then compression can significantly reduce the size of your messages and improve your throughput. However, if you have small amounts of data that are unique or already compressed, such as images or encrypted strings, then compression may not be very effective or even increase the size of your messages. Also, if you have very time-sensitive applications that require low latency, then compression may introduce some delay in message delivery.
Some of the disadvantages of message compression in Kafka are:
- Compression consumes CPU resources on both the producer and the consumer side. This can affect the performance of other tasks or processes running on the same machines.
- Compression introduces some latency in message dispatch, as the producer has to compress the messages before sending them to Kafka. This can affect the responsiveness of your application.
- Compression depends on the batching of messages by the producer. If the producer does not send enough messages to fill up a batch, then the compression ratio may be low and not worth the overhead. Therefore, compression works better when you have high throughput and large batch sizes
As Apache Kafka continues to be a pivotal technology in the world of real-time data processing, being well-prepared for Kafka-related interviews is essential for success. From the basics of Kafka's architecture to advanced concepts like exactly-once processing and Kafka Streams, a strong grasp of these topics will set you apart during interviews. By familiarising yourself with the questions presented in this guide, you'll be better equipped to demonstrate your expertise and secure your role in the exciting realm of Kafka-based data architectures.