Apache Kafka for Developers using Spring Boot

Packt via Coursera

Go to class Write review

Details

Go to class

Provider

Coursera
Pricing

Paid Course
Languages

English
Certificate

Paid Certificate Available
Duration & workload

13 hours 34 minutes
Sessions

On-Demand
Subtitles

English

Found in

Overview

Coursera Flash Sale

40% Off Coursera Plus for 3 Months!

Grab it

This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. In this hands-on course, you will dive deep into Apache Kafka and Spring Boot, mastering how to integrate these technologies for high-performance messaging and event-driven architectures. You'll gain practical skills in Kafka's fundamentals, including topics, partitions, and consumer groups, while learning to build and deploy real-world applications with Spring Boot. The course takes you step-by-step through setting up Kafka locally, building producers and consumers, and integrating Kafka with Spring Boot for smooth messaging and data streaming. You will also explore testing strategies, error handling, and SSL security for Kafka applications. Each module is packed with practical exercises, ensuring you gain a solid understanding of Apache Kafka's complex features and how to effectively use them in real-world projects. This course is ideal for developers who want to gain expertise in building robust and scalable data pipelines using Kafka and Spring Boot. The course assumes familiarity with Java and basic Spring Boot concepts, though detailed explanations are provided for all key concepts along the way. By the end of the course, you will be able to set up and configure Kafka clusters, create producers and consumers, implement message handling logic, perform integration tests, and ensure secure communication with SSL encryption in your Kafka-based applications.

Syllabus

Getting Started With the Course

In this module, we will introduce the course’s core objectives and what you can expect to achieve by the end of your journey. We’ll also cover the necessary prerequisites for the course and ensure you're set up to dive into the world of Kafka and Spring Boot.

Getting Started with Kafka

In this module, we will provide an introduction to Apache Kafka, exploring its origins and how it fits within data pipelines. You’ll also get familiar with essential Kafka terminology and its client APIs that are fundamental for messaging and stream processing.

Understanding Kafka Components and its Internals - (Theory + Hands On)

In this module, we will dive deep into Kafka's internal components, such as topics, partitions, and replication. You’ll learn how to set up a Kafka broker environment locally and explore Kafka’s distributed architecture for high-throughput stream processing.

Application Overview

In this module, we will introduce the Library Inventory application that serves as the basis for Kafka integration throughout the course. You’ll learn how Kafka is leveraged to streamline and manage events within the system.

Build Spring Boot Kafka Producer - Hands On

In this module, we will guide you through building a Kafka producer using Spring Boot. You’ll start by setting up the base project and then proceed to develop the logic for producing messages, including using KafkaTemplate for message publishing.

Integration Testing using JUnit5 - Hands On

In this module, we will explore the importance of integration testing for Kafka applications. You’ll learn how to write and configure tests for the Kafka producer and consumer, leveraging Embedded Kafka for a reliable and isolated testing environment.

Unit Testing using JUnit5 - Hands On

In this module, we will cover the essentials of unit testing for Spring Boot applications. You’ll learn how to write unit tests for your REST APIs and implement error handling for invalid requests, ensuring robust error management.

Kafka Producer - Sending Message With Key - Hands On

In this module, we will focus on creating a PUT endpoint to update Library Events and send messages with specific keys. You’ll understand how key-based partitioning works in Kafka and its importance for data distribution.

Kafka Producer - Important Configurations

In this module, we will explore Kafka producer configurations that impact performance and reliability. You’ll learn how to adjust important settings like retry behavior to handle network issues or broker failures.

Build Spring Boot Kafka Consumer - Hands On

In this module, we will focus on setting up a Spring Boot Kafka consumer. You will configure Kafka consumers with Spring profiles, and use the @KafkaListener annotation to handle incoming Kafka messages.

Consumer Groups and Consumer Offset Management - Hands On

In this module, we will explore how Kafka consumer groups operate, and demonstrate the effects of rebalancing on message consumption. You’ll learn both default and manual offset management strategies in Spring Kafka, and configure concurrent consumers for parallel message processing to optimize your Kafka consumer setup.

Persisting Library Events in DB - Using H2 InMemory DataBase

In this module, we will set up an H2 in-memory database to persist Library Events. You will also learn to create JPA entities for LibraryEvent and Book, and develop the service layer to handle adding and modifying events, ensuring smooth database interactions for Library Events.

Integration Testing using Embedded Kafka - Kafka Consumer

In this module, we will configure Embedded Kafka to test consumer behavior in isolation. You will create integration tests to validate both new and updated Library Events, as well as handling error scenarios such as invalid updates. Additionally, we'll explore using TestContainers for database-driven integration tests.

Error Handling, Retry and Recovery - Kafka Consumers

In this module, we will dive into Kafka consumer error handling, building custom error handlers, and configuring retry policies with exponential backoff. You will also implement recovery strategies such as using retry topics, dead-letter topics, and saving failed messages to databases for manual intervention and further processing.

Error Handling, Retry and Recovery - Kafka Producer

In this module, we will focus on error handling and retry strategies for Kafka producers. You will learn how to configure retries when Kafka brokers are unavailable or when replication requirements are violated, and how to manage failed messages for recovery.

Kafka Security using SSL : Hands-On

In this module, we will cover Kafka security, specifically focusing on SSL encryption for secure data transmission. You will learn how SSL works in Kafka, how to set up SSL in a local cluster, and best practices for managing SSL certificates at an enterprise level.

Accessing SSL Secured Kafka Cluster using Spring Boot

In this module, we will guide you through securing your Spring Boot applications to interact with an SSL-enabled Kafka cluster. You’ll learn how to configure both the Kafka producer and consumer to securely connect and exchange data with the Kafka cluster using SSL encryption.