David Landup

Introduction

In our previous chapter, we discussed the usage and need for Kafka in various architectures, examining Kafka externally. Now, let's take an internal look at the framework and become familiar with what actually goes on within the ecosystem. We will cover several concepts, starting with a holistic view of them, and then exploring each one by one, building on the intuition. There's a lot of terminology here, and if you haven't worked with distributed systems or Kafka before, you might not be familiar with some terms. We'll set up reminders from time to time to reinforce the terminology. If something doesn't make sense right away, it might help to finish the rest of the chapter and review the concept from a different perspective once it's discussed in relation to other components.
In the preceding chapter, we used terms such as &quot;scalability&quot;, &quot;fault-tolerance&quot;, &quot;resiliency&quot;, and &quot;high availability&quot;. While these can be used as buzzwords to make a framework/library sound advanced and useful, they're ultimately the effects of good architecture design. These same adjectives can be applied to various other systems, including regular web applications, if their architecture allows them to scale (horizontally or vertically) without suffering performance loss, recover from exceptional states (not just exception handling, but full recovery), etc. These are the effects of good design, which is not easy to achieve, as any software engineer has painfully learned while trying to create a complex system. In this chapter, we'll revisit the terminology, but this time, we'll explore the mechanisms at play that allow Kafka to use these buzzwords in their documentation and marketing copy.

Arpendu Kumar Garai

Getting Started with Kafka's Cluster Architecture

Welcome to the chapter on Kafka Installation and Setup. While most of this book is about using and understanding Kafka, it's also important to know how to install and configure this powerful streaming platform is the first and crucial step. In this chapter, we will explore the various prerequisites you need, look into different methods for installing Kafka, and help you configure and optimize the installation.
<h2 id="prerequisites">Prerequisites</h2>
Before we get started with the actual installation process, it's important to make sure that your system meets the necessary requirements. This will help ensure a smooth installation and operation of Kafka.
<h3 id="hardwarerequirements">Hardware Requirements</h3>
Processor: A modern, multi-core processor, preferably with at least 4 cores for development and testing purposes.
Memory: Minimum 4GB RAM for development and testing. Production setups usually require at least 16GB.
Disk Space: A minimum of 5GB free disk space for a basic setup. However, the disk requirements can grow substantially depending on the volume of data you plan to manage.
Network: A stable network connection. High network latency can significantly impact Kafka’s performance.
<h3 id="softwarerequirements">Software Requirements</h3>
Operating System: Apache Kafka is compatible with Linux, macOS, and Windows (using Windows Subsystem for Linux). However, a Linux-based OS is generally recommended for production.

Kafka Installation and Setup

As discussed in Chapter 2, the Producer is an application that publishes records or messages to Kafka. In order to explore and try out this functionality, we are going to use the Kafka Producer API to publish some messages to the Kafka topics. We will primarily use the Kafka Client API library, which is a thread-safe module. So let's quickly start by implementing a basic Producer example.
Before we start with the basic implementation, as promised in our first chapter, we are going to help Steve and Jane convert their monolithic application to a message-driven architecture. So let's pick a basic microservice that we can use to start with.
<img src="https://s3.stackabuse.com/media/ebooks/hands-on-apache-kafka/lesson-4-1.png" alt="Microservice E-commerce Event-Driven app">
Since we will be focusing on a simple Publisher module, we will start with the Notification Service, where some applications would notify a User with a message for a given Order.
<h2 id="simplekafkaproducerimplementation">Simple Kafka Producer Implementation</h2>
Let's create our simple Maven based Java application in one of our favorite IDEs. We will add the following libraries as part of the initial POM:
<pre><code class="hljs">	&lt;dependencies&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt;
 &lt;artifactId&gt;kafka_2.13&lt;/artifactId&gt;
 &lt;version&gt;3.1.0&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt;
 &lt;artifactId&gt;kafka-clients&lt;/artifactId&gt;
 &lt;version&gt;3.1.0&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
 &lt;artifactId&gt;slf4j-api&lt;/artifactId&gt;
 &lt;version&gt;1.7.36&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
 &lt;artifactId&gt;slf4j-log4j12&lt;/artifactId&gt;
 &lt;version&gt;1.7.36&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt;
 &lt;version&gt;2.13.1&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;com.github.javafaker&lt;/groupId&gt;
 &lt;artifactId&gt;javafaker&lt;/artifactId&gt;
 &lt;version&gt;1.0.2&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;/dependencies&gt;
</code></pre>

The Producer API

We will continue from where we left off in the previous chapter. In this chapter, we will focus on consuming the same Notification messages in our application. As discussed in Chapter 2, a Consumer is an application that reads data from Kafka topics by subscribing to them.
Consumers maintain connectivity to the Kafka cluster using the concept of heartbeat. This heartbeat allows the Zookeeper or Broker coordinator to be aware of whether the consumer is constantly connected to the cluster or not. In the absence of a heartbeat, the broker coordinator knows that the consumer is no longer connected and needs to rebalance the load among other consumers.
As discussed in Chapter 2, consumers are also grouped into Consumer Groups so that they can share the partitions of the topics they subscribe to. We have already discussed the different strategies that can be adapted based on various use-cases in Chapter 2. So let's try the practical implementation of the same here.
<h2 id="kafkaconsumerimplementation">Kafka Consumer Implementation</h2>
Let's create a simple Maven-based Java application in any of our favorite IDEs. We will add the following libraries as part of the initial POM:
<pre><code class="hljs"> &lt;dependencies&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt;
 &lt;artifactId&gt;kafka_2.13&lt;/artifactId&gt;
 &lt;version&gt;3.1.0&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt;
 &lt;artifactId&gt;kafka-clients&lt;/artifactId&gt;
 &lt;version&gt;3.1.0&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
 &lt;artifactId&gt;slf4j-api&lt;/artifactId&gt;
 &lt;version&gt;1.7.36&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
 &lt;artifactId&gt;slf4j-log4j12&lt;/artifactId&gt;
 &lt;version&gt;1.7.36&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;com.fasterxml.jackson.core&lt;/groupId&gt;
 &lt;artifactId&gt;jackson-databind&lt;/artifactId&gt;
 &lt;version&gt;2.13.1&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;dependency&gt;
 &lt;groupId&gt;com.github.javafaker&lt;/groupId&gt;
 &lt;artifactId&gt;javafaker&lt;/artifactId&gt;
 &lt;version&gt;1.0.2&lt;/version&gt;
 &lt;/dependency&gt;
 &lt;/dependencies&gt;
</code></pre>

The Consumer API

After exploring the basic Producer and Consumer APIs, let's delve into the Kafka Streams API. With the explosion of big data frameworks and data streaming technologies, client-side architecture and technologies required significant power to process massive clusters of data every day. This led to the introduction of the ability to process large quantities of data in bulk. However, this concept of bulk processing was not enough for the industry. There was a constant need for real-time event processing beyond the usual batch processing. Thus, a new strategy known as micro batching was introduced. Micro batching is similar to actual batch processing, but it handles smaller quantities of data. By reducing the size of the data, it usually produces results more quickly at faster intervals but doesn't provide real-time per-event processing power.
This prompted everyone to start looking for stream processing so that data could be processed as and when it arrived into the system. Many streaming libraries were introduced in the market, such as Spark Streaming, Nifi, Flink, Storm, Samza, and others. Most of them were either micro-batching processes or per-event processing frameworks. Therefore, Kafka introduced the Kafka Streams library, which was the only streaming library in the world of streaming that processes data exactly once. It is a true streaming framework as it processes one record at a time rather than micro-batches.

The Streams API - Writing the Processor and the KStreams API

Kafka Connect is a data pipeline that was introduced in Kafka 0.9.x to provide a runtime component that can be used to connect, convert, and perform transformations of the data before pushing it to a Kafka topic or to an application or data source. All these components are pluggable and configurable to provide the best of its use-cases. In this chapter, we are going to take a look at each of these components and understand a high-level overview of how they work and how we can use them together to create a useful data pipeline.
<h2 id="kafkaconnectarchitecture">Kafka Connect Architecture</h2>
Kafka Connect is a distributed, fault-tolerant, and scalable service, which is being used as a data pipeline to reliably stream series of data between Kafka and other systems. Kafka Connect at its core deals with three major components:
<ul>
<li>Connector - It primarily performs three operations. Firstly, it copies data by having the users define jobs at the Connector level, which are then further broken into smaller tasks. Secondly, it provides data parallelism and asks the connector to consider how the jobs could be broken down into smaller subtasks with selective granularity on the immediate receipt of data. Finally, by providing an API to register source and sink interfaces, it makes integration of a variety of data streams much easier.</li>
<li>Worker - It enables scaling the application. It can either run on a single worker standalone process where it itself acts as its own coordinator or in a distributed or clustered environment where connectors and tasks are dynamically scheduled on workers.</li>
<li>Data - Kafka Connect primarily focuses on simply copying the data. There are lots of streaming tools available that can be integrated or used as an ETL process for further processing. This makes Kafka Connect simple both from the conceptual and implementation perspectives.</li>
</ul>

The Connect API - Building a Pipeline to Connect, Convert and Transform

Until now, in our previous chapters, we have used the official libraries and APIs provided by Apache Kafka. We integrated those libraries in plain old Java and defined our use-cases. Going forward in all our upcoming chapters, we will be using Spring Boot and adding the relevant libraries to integrate Kafka.
<h2 id="introducingspringboot">Introducing Spring Boot</h2>
Spring Boot is an open-source framework developed and maintained by a company called Pivotal. It provides a platform for Java developers to create stand-alone, auto-configurable, production-grade Spring applications where we can focus on our business implementation rather than low-level logic. Spring Boot is also opinionated, as it determines the default values for our configuration. It takes care of the underlying packages and libraries to install for the features or dependencies we require.
Spring Boot is designed to achieve the following goals:
<ul>
<li>To host and develop production-grade code easily.</li>
<li>To reduce development time and run the application independently of infrastructure and framework.</li>
<li>To avoid complex XML configurations provided by Spring.</li>
<li>To provide a flexible way to define Java beans and database transactions.</li>
<li>To offer powerful batch processing and manage REST APIs.</li>
<li>To ease dependency management and include an Embedded Servlet Container.</li>
</ul>
With that said, let's quickly jump into our development and start defining our dependencies to publish and consume Kafka messages.

Introducing Kafka to Spring Boot

In the previous chapter, we did a quick start with Kafka in Spring Boot. In this chapter, we are going to deep-dive into each of its components and offerings to understand if we can use it to implement our own use case. To connect with Kafka, we need to focus primarily on the following beans provided by Kafka:
<ul>
<li><code>KafkaAdmin</code> - To configure topics in Kafka programmatically</li>
<li><code>ProducerFactory</code> - To define or override configurations for producing messages to Kafka</li>
<li><code>ConsumerFactory</code> - To define or override configurations for consuming messages from Kafka</li>
</ul>
Now, before we start looking into each of the components, we are going to revisit Steve and Jane's e-commerce app that we discussed in our previous chapters and select a basic microservice that we can use for implementation.
<img src="https://s3.stackabuse.com/media/ebooks/hands-on-apache-kafka/lesson-9-1.png" alt="Microservice E-commerce Event-Driven app">
Since we will be focusing on a simple pub-sub module, let's choose the Inventory Service where we will publish new items added to the inventory list into the Kafka topic and then consume it to update or forward that information to other services or topics.
<h2 id="configurationofkafkatopics">Configuration of Kafka Topics</h2>
Let's begin with our first component as part of Kafka in Spring Boot. Until now, if you have noticed, we have used command-line tools to create topics in Kafka. For example, in the previous chapter, we ran something like this:

Deep-Dive into Spring Boot Kafka Components

In this chapter, we are going to understand and use Spring Cloud Stream. It is a framework built on top of the core Spring Boot and Spring Integration. It helps us build an event-driven or message-driven microservice. We will take a deep look into its various concepts and usage.
But before we start with the Spring Cloud Stream concepts, we must first understand and review our core understanding of functional programming and its components. So let's explore some of the concepts we will use in this chapter.
<h2 id="conceptoffewusefulfunctionalinterfaces">Concept of Few Useful Functional Interfaces</h2>
Functional Programming is a programming paradigm where the basic unit of computation is a function. These functions are treated as mathematical functions, where we map inputs to outputs to produce a result. Java 8 introduced a new syntactic improvement as lambda functions. A lambda is an anonymous function that is used as a first-class citizen.
Any interface with a Single Abstract Method is considered a functional interface. The implementation of these functional interfaces is treated as lambda expressions. The <code>java.util.function</code> package introduced more than 40 functional interfaces. Here, we will discuss only Function, Consumer, Supplier, Predicate, BiFunction, and BiConsumer.
<ul>
<li>
Function - It is one of the simplest and most generic forms of functional interfaces that accepts one argument and returns a result. This kind of interface is usually used to convert or transform from one form to another.
<pre><code class="hljs">@FunctionalInterface
public interface Function&lt;T, R&gt; {
 R apply(T t);
}
</code></pre>
Example Usage:
<pre><code class="hljs">Function&lt;Long, String&gt; longToString = Object::toString;
Function&lt;String, String&gt; stringToUC = String::toUpperCase;
</code></pre>
</li>
<li>
Consumer - This represents functional interfaces that accept a single input argument and return no result. The final outcome is the side effect that it produces.
<pre><code class="hljs">@FunctionalInterface
public interface Consumer&lt;T&gt; {
 void accept(T t);

}
</code></pre>
Example Usage:
<pre><code class="hljs">User user = new User();
Consumer&lt;User&gt; updateUser = u -&gt; u.setName(&quot;John&quot;);
</code></pre>
</li>
<li>
Supplier - This functional interface does the exact opposite of the Consumer. It takes no arguments but returns some result or value.
<pre><code class="hljs">@FunctionalInterface
public interface Supplier&lt;T&gt; {
 void get(T t);
}
</code></pre>
Example Usage:
<pre><code class="hljs">Supplier&lt;Double&gt; randomDouble = () -&gt; Math.random();
</code></pre>
</li>
<li>
Predicate - It is a statement that can return true or false based on the value of its variables. It essentially acts as a function that returns a Boolean value.
<pre><code class="hljs">@FunctionalInterface
public interface Predicate&lt;T&gt; {
 boolean test(T t);
}
</code></pre>
Example Usage:
<pre><code class="hljs">Predicate&lt;String&gt; predicateCheck = x -&gt; x.length() &gt; 5;
</code></pre>
</li>
<li>
BiFunction - This accepts two arguments as input and returns a result. While declaring a BiFunction, we should define the type of argument that needs to be passed and its return type. We can then apply our business logic with those two values and return the result.
<pre><code class="hljs">@FunctionalInterface
public interface Function&lt;T, U, R&gt; {
 R apply(T t, U u);
}
</code></pre>
Example Usage:
<pre><code class="hljs">BiFunction&lt;Integer, Integer, String&gt; biFunctionExample = (n1, n2) -&gt; String.valueOf(n1 + n2);
</code></pre>
</li>
<li>
BiConsumer - It accepts two parameters as arguments but returns no result.
<pre><code class="hljs">@FunctionalInterface
public interface BiConsumer&lt;T, U&gt; {
 void accept(T t, U u);
}
</code></pre>
Example Usage:
<pre><code class="hljs">BiConsumer&lt;Integer,String&gt; biConsumer = (key, value) -&gt; log.info(&quot;Key:{} Value:{}&quot;, key, value);
</code></pre>
</li>
</ul>

Introduction to Spring Cloud Stream Kafka

In the previous chapter, we took a look at the Spring Cloud Stream binders for Kafka. In this chapter, we will familiarize ourselves with the “reactive” architecture pattern and explore Reactive Kafka.
Traditional applications often deal with blocking calls, or synchronous calls, which means if we want to access a particular entity or information from a system where most of the threads are busy, the application would block the new one or wait until the previous threads complete processing their requests. When handling large streams of data, it is essential to process them with tremendous speed and agility. That's when software developers realized they needed a multi-threaded environment capable of handling asynchronous and non-blocking calls to make the best use of processing data streams.
<h2 id="overviewofreactiveprogrammingparadigm">Overview of Reactive Programming Paradigm</h2>
A Stream of data is a sequential set of information or records that are transferred from one system to another. They are usually processed using the FIFO (First-In-First-Out) pattern. The same blocking methodology of data streaming often prevents a system from processing real-time data while streaming records. As a result, a group of prominent developers realized they needed an approach to build a “reactive” systems architecture that would facilitate data processing while streaming. Hence, they signed a manifesto, popularly known as the <a href="https://www.reactivemanifesto.org/">Reactive Manifesto</a>.

Introduction to Reactive Kafka

The concept of a data pipeline is not new, and many firms have utilized them for years (sometimes without their knowledge), albeit in different configurations than the ones we see today. Data pipelines are crucial for firms to have, as the expansion of company data continues to grow exponentially year after year.
Data pipelines are vital in the fields of data analytics and business analysis, but they also offer numerous advantages and applications beyond business intelligence. Today, we'll discuss the benefits of data pipelines, what a data pipeline entails, and provide a high-level technical overview of its essential components.
A data pipeline, simply put, is a set of actions that transfer unprocessed, structured, or unstructured data from a source to a destination. There can be various types of sources, but in this context, a source can be a transactional database, whereas the typical destination can be a data lake or a data warehouse. The final location is where the data is examined for business insights. In this entire journey from source to destination, various types of transformation logic are applied to the extracted data at different levels to make it ready for quick analysis and presentation or visualization in the User Interface.

Guided Project: Data Pipeline in Spring Boot using Kafka

As we discussed in Lesson 11, where we were introduced to Reactive Kafka, we delved into the term “reactive systems”. Systems that are flexible, loosely-coupled, scalable, and highly responsive are referred to as reactive systems. Applications must display elasticity, resilience, and responsiveness through a foundation of asynchronous, non-blocking communication in order to achieve this condition. This asynchronous communication establishes a boundary between components that ensures loose coupling, isolation, and location transparency.
Receivers of non-blocking communication can only use resources when they are actively engaged, which reduces system overhead. When explicit message-passing is employed, the system's message queues are shaped, monitored, and, when necessary, backpressure is applied to assist with load management, elasticity, and flow control.
Basically, a Stream of data is sequential information or a record that is transferred from one system to another. They are usually processed using the FIFO (First-In-First-Out) pattern. However, the traditional blocking methodology of data streaming often prohibits a system from processing real-time data while streaming records. Thus, a group of prominent developers gradually realized that they would need an approach to build a “reactive” systems architecture that would facilitate the processing of data while streaming. Consequently, they signed a manifesto, popularly known as the <a href="https://www.reactivemanifesto.org/">Reactive Manifesto</a>.

Scott Robinson

Guided Project: Reactive Stream Processing with Kafka

How often do you see your Kafka cluster unreachable or going down? There can be numerous reasons why a cluster may go down. However, if we manage and monitor the cluster with due diligence, we can prevent any downtime in our application.
Kafka is used by various companies to process billions of events and messages every day. Despite its popularity and robustness, monitoring Kafka is critical to ensure its smooth functioning and to prevent any potential problems. Monitoring Kafka helps in detecting and fixing issues before they become critical and affect the performance of the system.
In this guided project, we will discuss the importance of monitoring Kafka, the different types of monitoring, and the various tools and techniques available for monitoring a Kafka cluster.
<h2 id="whymonitorkafka">Why Monitor Kafka?</h2>
<ul>
<li>
Maintain system health: Monitoring Kafka helps ensure the health of the system by detecting potential issues and fixing them before they become critical. This includes monitoring the Kafka broker, the Zookeeper, and the consumers.
<ul>
<li>Monitoring the broker ensures that it functions properly and can handle incoming and outgoing messages.</li>
<li>Monitoring the Zookeeper ensures that configuration changes are applied and that the cluster operates as expected.</li>
<li>Monitoring the consumers ensures that they consume messages as expected and that there are no issues with message processing.</li>
</ul>
</li>
<li>
Improves Performance: Monitoring Kafka helps improve the performance of the system by detecting and fixing performance issues. This includes monitoring the number of messages being processed, the rate of messages being processed, and the latency of the system.
</li>
<li>
By monitoring the number of messages being processed, it is possible to determine whether the system can handle the volume of messages.
</li>
<li>
Monitoring the rate of messages being processed aids in determining if the system can process messages quickly enough.
</li>
<li>
Monitoring the system's latency helps in determining if it can process messages in real-time.
</li>
<li>
Detects Potential Issues: Monitoring Kafka helps in detecting potential issues before they become critical. This includes monitoring the broker, the Zookeeper, and the consumers.
</li>
<li>
Prevents Data Loss: Monitoring Kafka helps in preventing data loss by detecting any issues with the storage of messages. This includes monitoring the broker, the Zookeeper, and the consumers.
</li>
</ul>

Guided Project: Monitoring your own Kafka Cluster

<h1 id="presale20off">PRESALE - 20% off!</h1>
Don't miss out on our limited-time presale offer! For a limited time only, secure your spot in this comprehensive course at a special discounted price! Secure your spot now and unlock your potential with &quot;Hands On: Apache Kafka&quot; at a special presale discount!
Unlock the power of real-time data streaming and processing with our comprehensive and practical course, &quot;Hands-on: Apache Kafka&quot;. This all-encompassing course is designed to take you from beginner to expert in Apache Kafka, one of the most popular open-source distributed streaming platforms in the industry.
Kafka is a highly scalable, distributed, and fault-tolerant open-source streaming platform that enables the handling of real-time data processing and streaming. Developed by the Apache Software Foundation, Kafka was designed to provide a unified, high-throughput, and low-latency platform for managing real-time data feeds. It quickly gained popularity due to its exceptional performance, durability, and the ability to handle millions of events per second, making it the go-to choice for many large-scale, data-intensive applications.
Kafka's versatile nature allows it to be used in a wide variety of applications, such as real-time analytics, log aggregation, event sourcing, and messaging systems. With its robust architecture and flexible APIs, it has become the backbone for many modern data-driven applications, empowering businesses to make data-driven decisions and adapt to ever-evolving needs.
Throughout 14+ lessons, you'll gain a strong foundation in Kafka's cluster architecture, learn how to install and set up your own Kafka environment, and delve into the essential APIs that enable you to produce, consume, and process data streams effectively. The course also features a deep-dive into integrating Kafka with Spring Boot, a widely-used framework for building Java-based applications.
By the end of this course, you'll have hands-on experience with creating efficient data pipelines using Spring Boot and Kafka, as well as implementing reactive stream processing in real-world scenarios. You'll be equipped with the skills to tackle modern data challenges head-on, enabling you to build scalable, fault-tolerant, and high-performing applications.
Key takeaways from this course include:
<ul>
<li>Comprehensive understanding of Kafka's cluster architecture and its components</li>
<li>Proficiency in using the Producer, Consumer, Streams, and Connect APIs</li>
<li>Expertise in integrating Kafka with Spring Boot and Spring Cloud Stream Kafka</li>
<li>Insights into reactive Kafka and real-time data streaming using Spark and Kafka</li>
<li>Three guided projects that provide hands-on experience in building data pipelines, reactive stream processing, and real-time data streaming solutions</li>
</ul>
Whether you're a software engineer, data engineer, or an aspiring developer, &quot;Hands-on: Apache Kafka&quot; is the perfect course to help you harness the potential of real-time data streaming and processing. Join us on this journey to transform your skillset and stay ahead of the curve in the fast-paced world of data-driven technologies.