Microservices Clean Architecture DDD SAGA Outbox Kafka

Learn Spring boot microservices with Clean & Hexagonal architectures, DDD, SAGA, Outbox, CQRS, Kafka, Kubernetes & GKE
Microservices Clean Architecture DDD SAGA Outbox Kafka
File Size :
11.42 GB
Total length :
18h 12m



Ali Gelenler


Last update




Microservices Clean Architecture DDD SAGA Outbox Kafka

What you’ll learn

Develop Microservices Architecture using Spring Boot and Kafka
Understand and Apply Clean Architecture
Understand and Apply Hexagonal Architecture
Understand and Apply Domain Driven Design(DDD)
Implement SAGA Architecture Pattern
Implement Outbox Architecture Pattern
Implement CQRS Architecture Pattern
Learn Kafka Architecture and Programming on Kafka
Learn using Kafka as the Event Store for Event-Driven Services
Learn Kubernetes basics & Run a local cluster using Docker desktop
Deploy microservices to local Kubernetes Cluster
Run Confluent Kafka on Kubernetes using cp-helm-charts
Run Postgres on Kubernetes
Learn Google Cloud and Google Kubernetes Engine(GKE)
Deploy microservices to Google Kubernetes Engine

Microservices Clean Architecture DDD SAGA Outbox Kafka


Knowledge of Java
Knowledge of Spring Boot
Back-end development experience


Hi there! My name is Ali Gelenler. I’m here to help you learn microservices architecture while applying Clean and Hexagonal Architectures and using Domain Driven Design.In this course, you will focus on architectural aspects of microservices architecture and use Clean Architecture principles while developing each service. In the implementation of the domain layer you will also apply Domain Driven Design principles.You can always use the latest versions for spring boot, and other dependencies in this course. I will be constantly updating the dependency version in the last section’s lectures. You may check that to see the required code and configuration changes for updated versions. Also if you would like to use subtitles during the course, you can turn on the captions on videos as all lectures are updated with hand-written subtitles by choosing among over 20 different languages. I suggest using subtitles to make it easier to follow the lectures.Scott Knox: “As a working professional, I can already tell this is the holy grail of understanding modern architectures. If your company is struggling to grasp certain concepts, this course will help you help them. Thanks Ali for the excellent explanations!”You will implement SAGA, Outbox and CQRS patterns using the 5 Spring boot Java microservices that you will develop using Clean and Hexagonal architecture principles. Nick Goupinets: “Great course – gives a deep-dive into microservice development experience with Spring Boot. As an added bonus shows how to deploy it with Kubernetes. At times it felt too detailed, sort of making it hard to see the forest behind the trees. Also Hex. architecture resulted in what looked like an over-engineered overall solution. With that said, Ali did a fantastic job explaining all of the design decisions with clear architecture diagrams that offset that complexity!”You will also learn and use Apache Kafka as the event store, and use events to communicate between services, and to implement the architectural patterns.Nischal Jadhav: “If u are looking to become an high level developer or an architect, then this is the best course.!”The concepts that you will be learning and implementing are:Spring boot microservicesClean ArchitectureHexagonal ArchitectureDomain Driven DesignEvent-driven services using Apache KafkaSAGA Architecture PatternOutbox Architecture PatternCQRS Architecture PatternKubernetes on local using Docker desktopKubernetes on Google Cloud using Google Kubernetes Engine(GKE)Ali Aminian: “I really like this course. Thanks Ali for complete description and professional coding. I really enjoy to participate this course.”To communicate with the data stores in microservices you will use Spring Data JPA for PostgreSQL, and Spring Kafka for Kafka.You will be following a hands-on approach and  developing a project from scratch. You will have 5 microservices that communicate using events with Kafka as the event store.r j: “This is an amazing course. An architect from my team recommended this to me and he’s implemented something similar but bigger in our company, the biggest retailer on the planet.”You will also have multiple choice quizzes in each section to check your progress throughout the course. Arindam Majumdar: “This course helped me immensely to understand the Domain Driven Design approach on Microservices. Its so far the best hands on course I have come across in Udemy so far. Many thanks to Ali. Great job!! :)”At the end of the course you will understand how to run an event-driven microservices architecture with Clean and Hexagonal Architecture principles and with Domain Driven Design concepts. You will use Spring boot and Java to develop the microservices. You will also learn implementing architectural microservices patterns such as SAGA, Outbox and CQRS. In the end you will be able to deploy your application to Kubernetes on Google Cloud using Google Kubernetes Engine.Anurag tiwari: “Just started the course but i can already tell that this a good one Ali explains all the concepts like out box ,saga pattern so well. I would highly recommend this course for anyone who wants to take their knowledge about microservices to the next level using different patterns like hexagonal ,saga pattern. I would also recommend this course for beginners as youll learn a ton of stuff regarding microservices and patterns to create agile services as this course is very hands on”I have followed the same clean & hexagonal architectures and domain driven design principles in the implementation of each microservice. If you feel like you want to skip some repeating parts, you may download the source code that I provide in the first lecture of each section starting from section-3. You can then use the provided source code to continue with the section.Narendra Kumar A: “Its awesome course, I have ever come across in Udemy explaining the DDD, Clean architecture and usage of patterns concepts so cleanly.”For more detailed information on the progress of this course, you can check the introductory video and free lessons, and if you decide to enroll in this course, you are always welcome to ask and discuss the concepts and implementation details on Q/A and messages sections. I will guide you from start to finish to help you successfully complete the course and gain as much knowledge and experience as possible from this course.Jason: “This course is one of the best I ever had. There are many microsevices courses on Udemy, and most of them are like something that manufactured in the same factory. They all used the same framework and followed the same steps to teach microservices. They never talked about the important concepts behind the microservice. I felt like they just wanted to show off the latest version of frameworks and finish the long courses with them quickly and get paid. The impression after I watched first this lesson was amazing. He actually starts the project with the bare bone java plain object. It was like I’m flying with feather, not fully armed with numerous buzzword frameworks. It might be frustrated at first if you are really new to microservices and never heard of concepts like DDD before. But I’m pretty sure this is one of the courses that make you a “better” developer.”


Section 1: Introduction

Lecture 1 Structure of the course

Lecture 2 Project overview – Part 1

Lecture 3 Project overview – Part 2

Lecture 4 Setting up the environment

Section 2: Clean Architecture & Hexagonal Architecture

Lecture 5 Introduction to Clean and Hexagonal Architectures

Lecture 6 Designing components for Order Service using Clean Architecture

Lecture 7 Creating Order Service modules using Clean Architecture – PART 1

Lecture 8 Creating Order Service modules using Clean Architecture – PART 2

Section 3: Domain Driven Design (DDD)

Lecture 9 Introduction to Domain Driven Design

Lecture 10 Designing Order Service domain logic components

Lecture 11 Creating common domain module with base Entity and Aggregate Root classes

Lecture 12 Adding value objects and domain events to common domain module

Lecture 13 Implementing Order Service domain logic using DDD – Order Aggregate Root

Lecture 14 Adding Order Entity implementation methods

Lecture 15 Adding state changing methods to Order Entity

Lecture 16 Implemeting Domain Events in Order Service domain layer

Lecture 17 Implementing Order Domain Service

Lecture 18 Implementing Order Application Service – DTO classes

Lecture 19 Adding Mapper class and port definitions to Order Application Service

Lecture 20 Implementing input ports in Order Application Service

Lecture 21 Implementing message publisher in Order Application Service to fire the events

Lecture 22 Implementing Order Track Command Handler

Lecture 23 Testing Order Service domain logic – Part 1

Lecture 24 Testing Order Service domain logic – Part 2

Section 4: Apache Kafka

Lecture 25 Introduction to Apache Kafka

Lecture 26 Running Apache Kafka using Docker

Lecture 27 Implementing Kafka config data generic module

Lecture 28 Implementing Kafka model generic module

Lecture 29 Implementing Kafka producer generic module

Lecture 30 Implementing Kafka consumer generic module

Section 5: Completing Order service components

Lecture 31 Application module: Adding Web Controller

Lecture 32 Application module: Adding Controller Advice

Lecture 33 Data access module: Adding Order JPA Entity

Lecture 34 Data access module: Adding JPA Repository & Adapter implementation

Lecture 35 Data access module: Adding Customer and Restaurant implementations

Lecture 36 Messaging module: Adding Mapper and Config Data

Lecture 37 Messaging module: Adding Publisher implementations

Lecture 38 Messaging module: Adding Listener implementations

Lecture 39 Container module: Adding spring boot starter class and config

Lecture 40 Container module: Explaining kafka consumer properties

Lecture 41 Container module: Adding Order database schema file

Lecture 42 Creating Customer Service & Running Order Service

Section 6: Implementing Payment Service

Lecture 43 Domain core module: Adding Aggregate Root, Entity and Value objects

Lecture 44 Domain core module: Adding Exception and Domain events

Lecture 45 Domain core module: Implementing Payment Domain Service

Lecture 46 Application Service domain module: Adding Mapper, Config and Ports

Lecture 47 Application Service domain module: Implementing input ports – Part 1

Lecture 48 Application Service domain module: Implementing input ports – Part 2

Lecture 49 Application Service domain module: Refactoring fire event process

Lecture 50 Implementing Data Access module

Lecture 51 Implementing Messaging module: Adding Mapper and Publishers

Lecture 52 Implementing Messaging module: Adding Listeners

Lecture 53 Implementing Container module

Section 7: Implementing Restaurant Service

Lecture 54 Domain core module: Adding Aggregate Root and Entities

Lecture 55 Domain core module: Adding Exception, Domain events and Domain Service

Lecture 56 Application Service domain module: Adding Mapper, DTO and Ports

Lecture 57 Application Service domain module: Implementing input ports

Lecture 58 Implementing Data Access module

Lecture 59 Implementing Messaging module

Lecture 60 Implementing Container module

Section 8: SAGA Architecture Pattern

Lecture 61 Introduction to SAGA pattern

Lecture 62 Implementing Order Payment Saga

Lecture 63 Using Order Payment Saga in Messaging & Implementing Order Approval Saga

Lecture 64 Testing the application end-to-end with SAGA pattern changes

Lecture 65 Testing failure scenarios

Section 9: Outbox Architecture Pattern

Lecture 66 Introduction to Outbox pattern

Lecture 67 Updating Order Service database schema and config for Outbox Pattern

Lecture 68 Refactoring Order domain layer: Adding Outbox models & Updating ports

Lecture 69 Refactoring Order domain layer: Adding Outbox scheduler

Lecture 70 Refactoring Order domain layer: Adding Outbox cleaner scheduler for Payment

Lecture 71 Refactoring Order domain layer: Adding Outbox schedulers for Approval

Lecture 72 Refactoring Order domain layer: Updating OrderCreate Command Handler

Lecture 73 Refactoring Order domain layer: Updating Order Payment Saga – Part 1

Lecture 74 Refactoring Order domain layer: Updating Order Payment Saga – Part 2

Lecture 75 Refactoring Order domain layer: Updating Order Approval Saga

Lecture 76 Updating the Order Application Service Test for Outbox pattern changes

Lecture 77 Refactoring Order Data Access module for Outbox pattern

Lecture 78 Refactoring Order Messaging module for Outbox pattern – Part 1

Lecture 79 Refactoring Order Messaging module for Outbox pattern – Part 2

Lecture 80 Testing Order Payment Saga

Lecture 81 Updating Payment database schema, config and package structure for Outbox

Lecture 82 Refactoring Payment domain layer: Adding Outbox schedulers

Lecture 83 Refactoring Payment domain layer: Updating Message listener implementation

Lecture 84 Refactoring Payment Data Access module for Outbox pattern

Lecture 85 Refactoring Payment Messaging module for Outbox pattern

Lecture 86 Testing Payment Request Message Listener for double payment

Lecture 87 Refactoring Restaurant Service for Outbox pattern – Part 1

Lecture 88 Refactoring Restaurant Service for Outbox pattern – Part 2

Lecture 89 Testing the application end-to-end with Outbox pattern changes

Lecture 90 Testing failure scenarios

Section 10: CQRS Architecture Pattern

Lecture 91 Introduction to CQRS pattern

Lecture 92 Creating Customer Kafka topic & Customer modules

Lecture 93 Implementing Customer Service modules

Lecture 94 Updating Order Service to use local database table with CQRS pattern

Lecture 95 Running Order and Customer Services to test CQRS pattern

Section 11: Kubernetes(K8s)

Lecture 96 Introduction to Kubernetes and running a local Kubernetes using Docker Desktop

Lecture 97 Deploying Confluent Kafka to local Kubernetes using cp-helm-charts

Lecture 98 Creating Kubernetes deployment files for Microservices

Lecture 99 Deploying Microservices into local Kubernetes

Lecture 100 Deploying Postgres to local Kubernetes using Postgres docker image

Section 12: K8s & Google Kubernetes Engine(GKE)

Lecture 101 Creating Google Cloud account & Creating a Kubernetes cluster in GKE

Lecture 102 Pushing docker images to Google Artifact Registry

Lecture 103 Running the Application on Google Kubernetes Engine – Part 1

Lecture 104 Running the Application on Google Kubernetes Engine – Part 2

Lecture 105 Adding horizontal scaling to services

Lecture 106 Next steps & Thank you!

Section 13: Version updates: Update to latest Spring boot, Spring cloud & other dependencies

Lecture 107 Update to spring boot 2.7.5

Lecture 108 Update to spring boot 3.0.5

Developers and Architects want to see a practical approach to Clean and Hexagonal Architecture with Domain Driven Design,Developers and Architects want to learn architectural patterns, such as SAGA, Outbox and CQRS,Developers want to learn deploying a microservices architecture to Cloud using Google Kubernetes Engine,One that likes to learn with a hands-on approach

Course Information:

Udemy | English | 18h 12m | 11.42 GB
Created by: Ali Gelenler

You Can See More Courses in the IT & Software >> Greetings from CourseDown.com

New Courses

Scroll to Top