Explore Kafka Streams for real-time data processing. Learn Kafka concepts, CLI tools, complex topologies, and Spring Boot integration 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

**(Select all that apply.)** Which category of errors can be handled by a Kafka Streams application?

(Select all that apply.) Which category of errors can be handled by a Kafka Streams application?

All instances of the application in the consumer group will shut down.

The instance in which the error occurred will shut down.

The application will log the error and continue without any change.

The thread in which the exception occurred will be replaced.

When an error is caught by an implementation of `StreamsUncaughtExceptionHandler`, which outcome is _not_ possible?

When an error is caught by an implementation of <code>StreamsUncaughtExceptionHandler</code>, which outcome is not possible?

Consider the following topology:
```java
stream
  .peek((k, v) -> foo(k))
  .mapValues(v -> bar(v));
```

If `foo` throws a `RuntimeException`, what category does this error belong to?

Consider the following topology:
<pre><code class="language-java">stream
 .peek((k, v) -&gt; foo(k))
 .mapValues(v -&gt; bar(v));
</code></pre>
If <code>foo</code> throws a <code>RuntimeException</code>, what category does this error belong to?

The application will try to reprocess the same message, fail again, and shut down.

The application will skip the message causing the error and wait for new messages.

The application will try to reprocess the same message, fail again, replace the thread, and so on.

The application will shut down until it is restarted.

Consider the following topology:
```java
stream
  .mapValues(v -> 5 / v);
```

The registered implementation of `StreamsUncaughtExceptionHandler` is set to return `REPLACE_THREAD`. 

We receive a record with a value of `0`, which causes an exception. 

What will happen when the thread is replaced?

Consider the following topology:
<pre><code class="language-java">stream
 .mapValues(v -&gt; 5 / v);
</code></pre>
The registered implementation of <code>StreamsUncaughtExceptionHandler</code> is set to return <code>REPLACE_THREAD</code>.
We receive a record with a value of <code>0</code>, which causes an exception.
What will happen when the thread is replaced?

Test your knowledge of error handing in Kafka Streams applications.

Kafka Streams Overview

Building Our Kafka Tool Belt

Stateless Processing

Error Handling

Stateful Processing

Setting up a Streaming Data Pipeline With Kafka

Kafka Streams with Spring Boot

Build an Order Processing Kafka Streams Application

Wrap Up

Quiz: Error Handling