Introduction to the Course

About this course

In today’s world of real-time data processing, it has become increasingly important for businesses to be able to make quick and informed decisions based on incoming data. This is where Kafka Streams comes into play, providing a powerful and intuitive way to process and analyze data in real time.

As software developers, we are responsible for building scalable, reliable, and high-performance data processing systems, and Kafka Streams is one tool that can help us achieve this goal. In this course, we’ll dive deep into the world of Kafka Streams, exploring its architecture, core concepts, and real-world use cases. By the end of this course, you’ll have a solid understanding of how to leverage Kafka Streams to build efficient and effective real-time data processing systems.

We will start with an introduction to the world of Kafka Streams and go over the basic concepts of Kafka Streams and processor topologies. Then, we will refresh our knowledge about Kafka concepts and CLI commands which are important for our work with Kafka Streams itself.

The heart of the course is designing and building two Kafka Streams applications—a stateless application and a stateful application. During the development of each application, we’ll learn how to use Kafka Streams high-level DSL and its operators. We will also touch on important subjects such as error handling, testing, and building Kafka Stream applications using Spring Boot.

Intended audience

This course is intended for software developers and software architects who are interested in building scalable and efficient real-time data processing systems. Specifically, this course is designed for individuals who want to:

• Stay ahead of the curve in the rapidly evolving world of real-time data processing.

• Enhance their skills in designing and implementing high-performance, scalable, and fault-tolerant real-time data processing systems using Kafka Streams.

Prerequisites for this course

We assume that you have working knowledge of Java 8+. Basic knowledge of Apache Kafka is recommended, but learners without prior knowledge of Kafka will also benefit from the course. For the Spring Boot part of the course, basic knowledge of Spring Boot is required. However, knowledge of Spring Boot is not required for any other part of the course.

Structure of this course

The course consists of seven chapters:

• Kafka Streams Overview: An overview of Kafka Streams, basic concepts, and processor topologies.

• Building Our Kafka Tool Belt: Hands-on introduction to basic Apache Kafka concepts and tools required for understanding and operating Kafka Streams applications. Learners with a strong background in Kafka might wish to skip this chapter.

• Stateless Processing: In this chapter, we’ll learn about stateless Kafka Streams applications by designing, writing, and running an actual Kafka Streams application.

• Error Handling: An important part of every production-ready application, we’ll discuss and learn what Kafka Streams offers us in terms of error handling.

• Testing Kafka Streams: We’ll learn how to test Kafka Streams topologies.

• Stateful Processing: We will learn about stateful Kafka Streams topologies by designing, writing, and running a stateful Kafka Streams application.

• Kafka Streams with Spring Boot: In this chapter, we’ll learn how Kafka Streams should be configured when using the popular Spring Boot framework. We will rewrite the stateless topology to work with Spring Boot.

Course strengths

We have identified certain strengths of this course that set it apart from other available courses. The table below provides a summary of these strengths and advantages: