Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
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.
More
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.
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.
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.
The concepts that you will be learning and implementing are:
Spring boot microservices
Clean Architecture
Hexagonal Architecture
Domain Driven Design
Event-driven services using Apache Kafka
SAGA Architecture Pattern
Outbox Architecture Pattern
CQRS Architecture Pattern
Kubernetes on local using Docker desktop
Kubernetes on Google Cloud using Google Kubernetes Engine(GKE)
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.
You will also have multiple choice quizzes in each section to check your progress throughout the course.
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.
Watch Online Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
| # | Title | Duration |
|---|---|---|
| 1 | Structure of the course | 14:19 |
| 2 | Project overview - Part 1 | 12:45 |
| 3 | Project overview - Part 2 | 10:42 |
| 4 | Setting up the environment | 05:53 |
| 5 | Introduction to Clean and Hexagonal Architectures | 15:55 |
| 6 | Designing components for Order Service using Clean Architecture | 11:43 |
| 7 | Creating Order Service modules using Clean Architecture - PART 1 | 12:07 |
| 8 | Creating Order Service modules using Clean Architecture - PART 2 | 07:58 |
| 9 | Introduction to Domain Driven Design | 12:36 |
| 10 | Designing Order Service domain logic components | 12:15 |
| 11 | Creating common domain module with base Entity and Aggregate Root classes | 05:20 |
| 12 | Adding value objects and domain events to common domain module | 13:27 |
| 13 | Implementing Order Service domain logic using DDD - Order Aggregate Root | 16:01 |
| 14 | Adding Order Entity implementation methods | 11:30 |
| 15 | Adding state changing methods to Order Entity | 10:06 |
| 16 | Implemeting Domain Events in Order Service domain layer | 09:21 |
| 17 | Implementing Order Domain Service | 12:34 |
| 18 | Implementing Order Application Service - DTO classes | 12:28 |
| 19 | Adding Mapper class and port definitions to Order Application Service | 12:37 |
| 20 | Implementing input ports in Order Application Service | 21:37 |
| 21 | Implementing message publisher in Order Application Service to fire the events | 12:39 |
| 22 | Implementing Order Track Command Handler | 06:15 |
| 23 | Testing Order Service domain logic - Part 1 | 13:55 |
| 24 | Testing Order Service domain logic - Part 2 | 07:28 |
| 25 | Introduction to Apache Kafka | 06:19 |
| 26 | Running Apache Kafka using Docker | 12:58 |
| 27 | Implementing Kafka config data generic module | 08:42 |
| 28 | Implementing Kafka model generic module | 07:01 |
| 29 | Implementing Kafka producer generic module | 08:27 |
| 30 | Implementing Kafka consumer generic module | 05:17 |
| 31 | Application module: Adding Web Controller | 06:20 |
| 32 | Application module: Adding Controller Advice | 11:00 |
| 33 | Data access module: Adding Order JPA Entity | 10:46 |
| 34 | Data access module: Adding JPA Repository & Adapter implementation | 12:04 |
| 35 | Data access module: Adding Customer and Restaurant implementations | 13:27 |
| 36 | Messaging module: Adding Mapper and Config Data | 06:20 |
| 37 | Messaging module: Adding Publisher implementations | 14:32 |
| 38 | Messaging module: Adding Listener implementations | 11:37 |
| 39 | Container module: Adding spring boot starter class and config | 13:50 |
| 40 | Container module: Explaining kafka consumer properties | 09:08 |
| 41 | Container module: Adding Order database schema file | 05:22 |
| 42 | Creating Customer Service & Running Order Service | 10:33 |
| 43 | Domain core module: Adding Aggregate Root, Entity and Value objects | 12:28 |
| 44 | Domain core module: Adding Exception and Domain events | 02:48 |
| 45 | Domain core module: Implementing Payment Domain Service | 12:44 |
| 46 | Application Service domain module: Adding Mapper, Config and Ports | 10:38 |
| 47 | Application Service domain module: Implementing input ports - Part 1 | 10:52 |
| 48 | Application Service domain module: Implementing input ports - Part 2 | 02:47 |
| 49 | Application Service domain module: Refactoring fire event process | 12:23 |
| 50 | Implementing Data Access module | 12:28 |
| 51 | Implementing Messaging module: Adding Mapper and Publishers | 11:37 |
| 52 | Implementing Messaging module: Adding Listeners | 05:08 |
| 53 | Implementing Container module | 11:11 |
| 54 | Domain core module: Adding Aggregate Root and Entities | 12:44 |
| 55 | Domain core module: Adding Exception, Domain events and Domain Service | 07:14 |
| 56 | Application Service domain module: Adding Mapper, DTO and Ports | 08:44 |
| 57 | Application Service domain module: Implementing input ports | 09:43 |
| 58 | Implementing Data Access module | 11:33 |
| 59 | Implementing Messaging module | 09:06 |
| 60 | Implementing Container module | 10:39 |
| 61 | Introduction to SAGA pattern | 02:54 |
| 62 | Implementing Order Payment Saga | 13:03 |
| 63 | Using Order Payment Saga in Messaging & Implementing Order Approval Saga | 09:31 |
| 64 | Testing the application end-to-end with SAGA pattern changes | 11:01 |
| 65 | Testing failure scenarios | 09:00 |
| 66 | Introduction to Outbox pattern | 03:57 |
| 67 | Updating Order Service database schema and config for Outbox Pattern | 07:35 |
| 68 | Refactoring Order domain layer: Adding Outbox models & Updating ports | 15:09 |
| 69 | Refactoring Order domain layer: Adding Outbox scheduler | 16:55 |
| 70 | Refactoring Order domain layer: Adding Outbox cleaner scheduler for Payment | 04:19 |
| 71 | Refactoring Order domain layer: Adding Outbox schedulers for Approval | 11:04 |
| 72 | Refactoring Order domain layer: Updating OrderCreate Command Handler | 10:29 |
| 73 | Refactoring Order domain layer: Updating Order Payment Saga - Part 1 | 18:32 |
| 74 | Refactoring Order domain layer: Updating Order Payment Saga - Part 2 | 14:23 |
| 75 | Refactoring Order domain layer: Updating Order Approval Saga | 12:33 |
| 76 | Updating the Order Application Service Test for Outbox pattern changes | 04:15 |
| 77 | Refactoring Order Data Access module for Outbox pattern | 09:28 |
| 78 | Refactoring Order Messaging module for Outbox pattern - Part 1 | 10:15 |
| 79 | Refactoring Order Messaging module for Outbox pattern - Part 2 | 10:56 |
| 80 | Testing Order Payment Saga | 13:37 |
| 81 | Updating Payment database schema, config and package structure for Outbox | 07:14 |
| 82 | Refactoring Payment domain layer: Adding Outbox schedulers | 16:00 |
| 83 | Refactoring Payment domain layer: Updating Message listener implementation | 08:11 |
| 84 | Refactoring Payment Data Access module for Outbox pattern | 06:22 |
| 85 | Refactoring Payment Messaging module for Outbox pattern | 09:51 |
| 86 | Testing Payment Request Message Listener for double payment | 09:41 |
| 87 | Refactoring Restaurant Service for Outbox pattern - Part 1 | 13:58 |
| 88 | Refactoring Restaurant Service for Outbox pattern - Part 2 | 05:48 |
| 89 | Testing the application end-to-end with Outbox pattern changes | 14:51 |
| 90 | Testing failure scenarios | 04:19 |
| 91 | Introduction to CQRS pattern | 02:33 |
| 92 | Creating Customer Kafka topic & Customer modules | 14:34 |
| 93 | Implementing Customer Service modules | 14:48 |
| 94 | Updating Order Service to use local database table with CQRS pattern | 10:22 |
| 95 | Running Order and Customer Services to test CQRS pattern | 06:39 |
| 96 | Introduction to Kubernetes and running a local Kubernetes using Docker Desktop | 05:57 |
| 97 | Deploying Confluent Kafka to local Kubernetes using cp-helm-charts | 11:55 |
| 98 | Creating Kubernetes deployment files for Microservices | 11:28 |
| 99 | Deploying Microservices into local Kubernetes | 09:31 |
| 100 | Deploying Postgres to local Kubernetes using Postgres docker image | 05:12 |
| 101 | Creating Google Cloud account & Creating a Kubernetes cluster in GKE | 07:47 |
| 102 | Pushing docker images to Google Artifact Registry | 10:02 |
| 103 | Running the Application on Google Kubernetes Engine - Part 1 | 08:43 |
| 104 | Running the Application on Google Kubernetes Engine - Part 2 | 07:56 |
| 105 | Adding horizontal scaling to services | 08:51 |
| 106 | Next steps & Thank you! | 01:19 |
| 107 | Update to spring boot 2.7.5 | 09:45 |
Similar courses to Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
Algorithms in Java: Live problem solving & Design Techniques
Data Structures in Java
Master Spring Boot 3 & Spring Framework 6 with Java
Python for Financial Analysis and Algorithmic Trading
![React & TypeScript Chrome Extension Development [2021]](https://cdn.courseflix.net/courses/200x112/react-typescript-chrome-extension-development-2021.webp)
React & TypeScript Chrome Extension Development [2021]
Advanced Radix UI
