In this module, we will delve into the core concepts of Kafka Streams, covering essential terminologies and providing an overview of the KStreams API. This foundational knowledge will prepare you for more advanced topics in the following sections.

In this module, we will guide you through building a simple Kafka Streams application, focusing on setting up and coding a topology that transforms messages. You’ll also learn how to test your application locally to ensure it functions correctly.

In this module, we will explore various operators provided by the KStreams API, demonstrating how to apply filtering, transformation, and merging operations. You’ll also learn techniques to debug your streams effectively.

In this module, we will dive into the mechanics of serialization and deserialization within Kafka Streams. You’ll learn how to configure default SerDes, create custom serializers/deserializers, and apply them in your streams application.

In this module, we will focus on creating a generic serializer/deserializer that can be reused across multiple Kafka Streams applications. You’ll learn how to integrate this generic SerDes into your applications to streamline data processing.

In this module, we will build a real-time Kafka Streams application for order management. You’ll create a topology that processes and transforms orders, applying branching logic to handle different types of orders in a retail environment.

In this module, we will take a deep dive into the internal architecture of Kafka Streams, examining how topology, streams, and tasks operate. You’ll also learn how adjusting stream threads can affect your application's performance.

In this module, we will focus on the various failure scenarios in Kafka Streams and how to handle them. You’ll learn to create custom error handlers for different stages of the stream processing pipeline, ensuring robust application behavior even under failure conditions.

In this module, we will introduce KTable and GlobalKTable, key components in Kafka Streams for handling stateful data. You’ll build topologies that use these components and explore how they function under the hood to manage state across distributed systems.

In this module, we will cover the essential stateful operations in Kafka Streams, including aggregation, joining, and windowing events. You’ll learn how to use different aggregation operators and materialized views to manage state effectively in stream processing.

In this module, we will explore various strategies for accessing the results of stateful operations in Kafka Streams. You’ll learn how to expose these results to external systems, enabling broader use of your processed data.

In this module, we will apply aggregation techniques in a real-time Order Management application. You’ll learn how to count orders and calculate revenue by store, leveraging Kafka Streams for real-time data processing in a retail context.

In this module, we will dive into the concept of rekeying in Kafka Streams. You’ll learn how null keys affect stateful operations and how to effectively repartition your data using the selectKey operator to ensure accurate processing.

In this module, we will focus on join operations in Kafka Streams, covering inner, left, and outer joins across KStreams, KTables, and GlobalKTables. You’ll learn how to implement these joins in real-world scenarios and understand the internal mechanics behind them.

In this module, we will apply join operations to a real-time Order Management application. You’ll implement a join between aggregated revenue data and store details, demonstrating the practical use of joins in Kafka Streams.

In this module, we will explore the concept of windowing in Kafka Streams, an essential technique for managing time-based stateful operations. You’ll learn how to implement various window types and control the timing of results using advanced operators.

In this module, we will extend the Order Management application to include windowing functionality. You’ll implement custom timestamp extractors, aggregate data by windows, and learn how to perform joins on windowed data for real-time insights.

In this module, we will examine how Kafka Streams processes records with timestamps that deviate from the current time window. You’ll learn how to manage these out-of-order records and ensure accurate windowed operations in your streams.

In this module, we will guide you through building a Kafka Streams application using Spring Boot. You’ll learn how to configure your application, build a simple stream topology, and test it locally to ensure it meets your needs.

In this module, we will delve into the internals of how Spring Boot automatically configures Kafka Streams applications. You’ll gain insights into the mechanisms that simplify application setup and learn how to leverage this feature for efficient development.

In this module, we will focus on handling JSON data within Kafka Streams using Spring Boot. You’ll learn how to implement serialization and deserialization with JsonSerde, and how to customize the ObjectMapper for more complex JSON processing needs.

In this module, we will explore various strategies for error handling in Spring Kafka Streams applications. You’ll learn how to manage deserialization errors, handle uncaught exceptions in topologies, and deal with production errors to ensure robust application performance.

In this module, we will guide you through building a Kafka Streams application for managing orders using Spring Boot. You’ll set up the project and implement the OrdersTopology, which will handle and process real-time order data efficiently.

In this module, we will cover how to query Kafka Streams state stores using RESTful APIs. You’ll learn to build endpoints for retrieving order counts and revenue, and how to implement global error handling to improve the client experience.

In this module, we will explore querying windowed state stores via RESTful APIs in Kafka Streams. You’ll build endpoints to retrieve order counts and revenue within specified time ranges, providing a complete picture of windowed data in your application.

In this module, we will focus on testing Kafka Streams applications using TopologyTestDriver and JUnit5. You’ll learn to write unit tests for various scenarios, ensuring that your Kafka Streams application behaves as expected under different conditions.

In this module, we will guide you through the process of testing Kafka Streams applications built with Spring Boot. You’ll learn how to integrate TopologyTestDriver for testing and ensure that your Spring Boot-based Kafka Streams topologies perform correctly.

In this module, we will cover the setup and execution of integration tests for Kafka Streams applications using @EmbeddedKafka. You’ll learn how to test critical functionalities such as order counting and revenue aggregation to validate your application's end-to-end performance.

In this module, we will introduce you to the concept of grace periods in Kafka Streams, explaining how they are used to handle late-arriving events within windows. You’ll learn when and how to apply grace periods to improve the accuracy of your stream processing.

In this module, we will show you how to package your Spring Boot Kafka Streams application as an executable jar file. You’ll learn how to build the jar and run your application locally, preparing it for deployment.

In this module, we will explore exactly-once processing semantics in Kafka Streams. You’ll learn how to implement these semantics, including managing transactions and idempotent producers, and assess the trade-offs involved in using exactly-once processing.

In this module, we will delve into running Kafka Streams applications as multiple instances using Spring Boot. You’ll learn how to manage distributed Kafka Streams applications, implement key-based queries, and aggregate data across multiple instances for a scalable and robust streaming solution.