Kafka MicroServices with Spring Boot, Docker, Kubernetes, AI (Udemy.com)

Build real-world, event-driven microservices using Apache Kafka, Spring Boot, Docker, Kubernetes, PostgreSQL, OpenAPI, Spring Boot Actuator, and AI-assisted development.

This course is designed to take you from the fundamentals of Kafka all the way to building, testing, securing, monitoring, containerizing, and deploying production-style Kafka microservices.

You will start by learning the core concepts of Apache Kafka, including topics, partitions, producers, consumers, offsets, consumer groups, brokers, replication, leader election, ISR, and retention. Then, you will move into hands-on development by building a complete Library Events Producer and Library Events Consumer microservice using Spring Boot and Spring Kafka.

Along the way, you will use modern AI-assisted coding workflows such as GitHub Copilot, spec-driven development, PRD documents, implementation plans, AGENTS . md, and reusable coding skills to build applications more efficiently and consistently.

By the end of this course, you will have built a complete Kafka-based microservices system that includes REST APIs, Kafka producer and consumer flows, PostgreSQL persistence, error handling, retries, recovery strategies, transactions, health checks, Docker images, and Kubernetes deployment.

Course Introduction

Welcome to this hands-on course on building event-driven Kafka microservices using Spring Boot, Docker, Kubernetes, and AI-assisted development.

In this course, we are going to start from the fundamentals of Apache Kafka and gradually move toward building a complete real-world microservices application. You will first learn the core Kafka concepts such as topics, partitions, producers, consumers, offsets, consumer groups, brokers, replication, leader election, and retention policies.

Once the Kafka foundation is clear, we will move into hands-on development by building a complete Library Events Producer and Library Events Consumer application using Spring Boot and Spring Kafka. The producer service will expose REST APIs and publish events to Kafka, while the consumer service will consume those events, process them, and persist the data into a PostgreSQL database.

This course also introduces a modern way of building software using AI-assisted development. We will use ideas like PRD documents, implementation plans, GitHub Copilot, AGENTS . md, and reusable AI skills to guide development in a more structured and productive way.

As we progress, we will cover important real-world engineering topics such as unit testing, integration testing, Embedded Kafka testing, Swagger/OpenAPI documentation, producer reliability, consumer retry and recovery, Dead Letter Topics, Kafka transactions, exactly-once semantics, health checks, monitoring, Docker containerization, and Kubernetes deployment.

By the end of this course, you will have built a complete production-style Kafka microservices system from scratch and gained the confidence to design, develop, test, monitor, package, containerize, and deploy Kafka-based applications in the real world.

Quick Breakdown by Section

Getting Started with the Course

• Get a complete overview of what this course is about.

• Understand the main goals and learning outcomes of the course.

• Review the prerequisites needed before starting the course.

• Set the right expectations for the tools, technologies, and hands-on projects covered.

Getting Started with Kafka

• Understand what Apache Kafka is and why it is widely used in modern applications.

• Learn how Kafka fits into event-driven architecture and microservices.

• Explore core Kafka terminologies such as topics, partitions, brokers, producers, consumers, and client APIs.

• Build a strong conceptual foundation before moving into hands-on Kafka development.

Docker Installation

• Install Docker on your local machine.

• Understand why Docker is useful for running Kafka and supporting services locally.

• Prepare your development environment for the hands-on sections in the course.

• Learners who already have Docker installed can quickly verify their setup and move forward.

Kafka Components and Internals

• Learn how Kafka topics and partitions organize data for scalability.

• Set up Kafka locally using KRaft and understand how Kafka works without ZooKeeper.

• Create topics and produce/consume messages using Kafka CLI commands.

• Understand how message keys affect partition selection and ordering.

• Explore how Kafka producers and consumers work under the hood.

• Learn about consumer offsets, consumer groups, rebalancing, commit logs, and retention policies.

• Set up a local multi-broker Kafka cluster and understand replication, leader election, ISR, and fault tolerance.

Application Overview

• Get introduced to the Library Inventory Service application.

• Understand the producer and consumer microservices that will be built in the course.

• See how REST APIs, Kafka, PostgreSQL, and Spring Boot fit together.

• Establish the end-to-end architecture before starting the implementation.

AI-Driven Development and Agentic Engineering

• Understand how software development is changing with AI coding assistants.

• Learn the difference between vibe coding and agentic engineering.

• Explore how AI can help with planning, coding, testing, and documentation.

• Use AI-assisted workflows to build applications faster while still understanding the underlying concepts.

Local Setup: IDE

• Install and configure IntelliJ IDEA.

• Prepare the IDE for Spring Boot and Kafka development.

• Set up the development environment needed for building both producer and consumer services.

• Make sure the local machine is ready for hands-on coding.

Build Library Events Kafka Producer Microservice

• Create the base Spring Boot project for the producer service.

• Set up GitHub Copilot and use AI-assisted coding during development.

• Create PRD and implementation plan documents before writing code.

• Build the Library Event domain model.

• Create REST endpoints to publish events to Kafka.

• Use KafkaTemplate to send messages to Kafka.