Delve into Kafka Streams for real-time data processing. Gain insights into Kafka concepts, CLI tools, complex topologies, and Spring Boot integration, enabling you to build scalable, resilient applications.

kafka-streams-course.tar.gz

hello-world

stateless-topology

stateless-topology-test

stateful-topology

springboot

Kafka Streams is a Java library designed to develop applications and microservices tailored for real-time data stream processing. Harnessing Kafka’s capabilities, applications constructed using Kafka Streams exhibit exceptional scalability and fault tolerance. This versatile tool finds applications in various scenarios and domains.

The course starts with an introduction to Kafka Streams. Next, you will learn important Kafka concepts and gain experience using Kafka CLI tools. Then, you will learn how to build complex Kafka Streams topologies using stateless operators, error handling, and stateful operations. Finally, you will learn how to integrate Kafka Streams in Spring Boot applications, including using Spring’s monitoring and metrics capabilities.

After completing this course, you can build data-intensive real-time stream processing applications and microservices using Kafka Streams, enabling you to build powerful, resilient, and scalable products.

Kafka Streams for Software Developers

All records without a key will be grouped and reduced together.

Records without keys will be filtered out by the `groupByKey` operator.

It is not possible to publish records without keys to this topology.

Given the following code:
```java
stream.groupByKey()
      .reduce((a, b) -> a + " " + b)
      .toStream()
      .peek((k, v) -> System.out.println(v));
```

What would happen if multiple records without key would be published to this topology?

Given the following code:
<pre><code class="language-java">stream.groupByKey()
 .reduce((a, b) -&gt; a + &quot; &quot; + b)
 .toStream()
 .peek((k, v) -&gt; System.out.println(v));
</code></pre>
What would happen if multiple records without key would be published to this topology?

Because by default Kafka Streams commits only every 30 seconds.

Because records are emitted only when the cache is full.

Because we need to explicitly commit the offset.

Because we did not set the value of `StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG` to `0`.

**(Select all that apply.)** We are running the following topology:
```java
stream.groupByKey()
      .reduce((a, b) -> a + " " + b)
      .toStream()
      .peek((k, v) -> System.out.println(v));
```

We don’t see the results of the `reduce` operator printed immediately after we published a record. Why?

(Select all that apply.) We are running the following topology:
<pre><code class="language-java">stream.groupByKey()
 .reduce((a, b) -&gt; a + &quot; &quot; + b)
 .toStream()
 .peek((k, v) -&gt; System.out.println(v));
</code></pre>
We don’t see the results of the <code>reduce</code> operator printed immediately after we published a record. Why?

We want to count the number of user events in intervals of 30 seconds. It is important not to count the same event more than once. What window type should we use?

We want to count the number of user events in intervals of 30 seconds. It is important not to count the same event more than once. What window type should we use?

When we want to skip aggregation in unbound streams.

When our windowed aggregation is optimized for low-latency.

When it is important that our windowed operation will only emit one result per window.

When our windowed aggregation is optimized for completeness.

**(Select all that apply.)** When should we use suppression?

(Select all that apply.) When should we use suppression?

Query the full state of the application even though it is distributed.

Receive a value stored in a different partition than the one associated with the application instance which received the query.

Query the state stores of every application connected to the same Kafka cluster.

Force a single instance to directly access the values stored in every partition.

**(Select all that apply.)** Given that our application has multiple instances, what would remote interactive queries allow us to do?

(Select all that apply.) Given that our application has multiple instances, what would remote interactive queries allow us to do?

Test your knowledge of stateful processing in Kafka Streams applications.

Kafka Streams Overview

Building Our Kafka Tool Belt

Stateless Processing

Error Handling

Stateful Processing

Kafka Streams with Spring Boot

Build an Order Processing Kafka Streams Application

Wrap Up

Quiz: Stateful Processing