Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka
Learn Spring boot microservices: Clean & Hexagonal architectures, DDD, SAGA, Outbox, CQRS, Kafka, Kubernetes, Spring AI
Lo que serás capaz de hacer
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 Software Architecture using Clean & Hexagonal Architecture principles while developing each service. In the implementation of the domain layer you will also apply Domain Driven Design principles. The course also includes a new section on adding AI functionality into the existing Order Service while still following Clean Architecture and Domain Driven Design principles. In this section, you will implement an AI-powered Order Note Interpreter that transforms raw customer order notes into structured order preferences. You will use Spring AI with both OpenAI and Ollama, apply system prompts as guardrails, use prompt templates for controlled and repeatable LLM calls, and connect LLM responses to business logic more safely using structured output. 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. You may choose 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 4 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 microservices Clean Architecture Hexagonal Architecture Software Architecture Domain Driven Design AI integration using Clean Architecture, Ports and Adapters, and Domain Driven Design principles Order Note Interpreter AI assistant using Spring AI, OpenAI, Ollama, LLMs, prompt templates, system prompts, guardrails, and structured output 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) 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 4 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. You will also learn how to add AI functionality effectively into an existing microservice using Ports and Adapters architecture. You will use Spring AI with OpenAI and Ollama and implement an AI assistant as a secondary adapter in Clean Architecture while using modern techniques such as prompt templates, system prompts, guardrails, and structured output. 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 or using the github links that I provided in the course resources. 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." Remember! There is a 30-day full money-back guarantee for this course! So you can safely press the 'Buy this course' button with zero risk and join this learning journey with me.
- 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
Temario
UNIDAD 1 - Introduction · 9 leccionesUNIDAD 1 - Introduction
UNIDAD 1 - Introduction
- Structure of the course
- Clean & Hexagonal architectures
- Project overview - Part 1
- Project overview - Part 2
- Adding AI into architecture
- SAGA Pattern
- Setting up the environment
- Providing the source code
- Understanding the project overview
UNIDAD 2 - Clean Architecture & Hexagonal Architecture · 8 leccionesUNIDAD 2 - Clean Architecture & Hexagonal Architecture
UNIDAD 2 - Clean Architecture & Hexagonal Architecture
- Introduction to Clean and Hexagonal Architectures
- Hexagonal Architecture
- Designing components for Order Service using Clean Architecture
- Adding AI port and adapter into Order Service design
- Creating Order Service modules using Clean Architecture - PART 1
- Creating Order Service modules using Clean Architecture - PART 2
- Dependency Inversion Principle
- Understanding Dependency Inversion and Hexagonal Architecture
UNIDAD 3 - Domain Driven Design (DDD) · 22 leccionesUNIDAD 3 - Domain Driven Design (DDD)
UNIDAD 3 - Domain Driven Design (DDD)
- Introduction to Domain Driven Design
- Domain Driven Design (DDD)
- Designing Order Service domain logic components
- Creating common domain module with base Entity and Aggregate Root classes
- Adding value objects and domain events to common domain module
- Implementing Order Service domain logic using DDD - Order Aggregate Root
- DDD concepts
- Adding Order Entity implementation methods
- Adding state changing methods to Order Entity
- Entity Classes
- Implemeting Domain Events in Order Service domain layer
- Implementing Order Domain Service
- Implementing Order Application Service - DTO classes
- Adding Mapper class and port definitions to Order Application Service
- Implementing input ports in Order Application Service
- First contact point to the domain layer
- Implementing message publisher in Order Application Service to fire the events
- TransactionalEventListener
- Implementing Order Track Command Handler
- Testing Order Service domain logic - Part 1
- Testing Order Service domain logic - Part 2
- Understanding Domain Driven Design
UNIDAD 4 - Adding AI into Order Service with Clean Architecture and Domain Driven Design · 5 leccionesUNIDAD 4 - Adding AI into Order Service with Clean Architecture and Domain Driven Design
UNIDAD 4 - Adding AI into Order Service with Clean Architecture and Domain Driven Design
- Introduction of AI integration into Clean architecture and DDD
- Setting up Open AI api key
- Updating domain logic of order service for AI integration
- Updating and running Order Application Service Test with AI integration
- Understanding how to integrate AI into Clean architecture using DDD
UNIDAD 5 - Apache Kafka · 9 leccionesUNIDAD 5 - Apache Kafka
UNIDAD 5 - Apache Kafka
- Introduction to Apache Kafka
- Resiliency of Kafka
- Running Apache Kafka using Docker
- Implementing Kafka config data generic module
- Implementing Kafka model generic module
- Implementing Kafka producer generic module
- Implementing Kafka consumer generic module
- Programming on Kafka
- Understanding Kafka Architecture and Components
UNIDAD 6 - Completing Order service components · 19 leccionesUNIDAD 6 - Completing Order service components
UNIDAD 6 - Completing Order service components
- Application module: Adding Web Controller
- Application module: Adding Controller Advice
- Spring annotations
- Data access module: Adding Order JPA Entity
- Data access module: Adding JPA Repository & Adapter implementation
- Data access module: Adding Customer and Restaurant implementations
- Messaging module: Adding Mapper and Config Data
- Messaging module: Adding Publisher implementations
- Messaging module: Adding Listener implementations
- Container module: Adding spring boot starter class and config
- Container module: Explaining kafka consumer properties
- Container module: Adding Order database schema file
- Creating a service with Hexagonal Architecture and DDD
- AI module: Adding Order Note Interpreter with OpenAI API - Part 1
- AI module: Adding Order Note Interpreter with OpenAI API - Part 2
- AI module: Updating Java and Spring Boot versions
- AI module: Updating data access layer for AI output
- Creating Customer Service & Running Order Service
- AI module: Using Ollama with a local LLM for Order Note Interpreter
UNIDAD 7 - Implementing Payment Service · 12 leccionesUNIDAD 7 - Implementing Payment Service
UNIDAD 7 - Implementing Payment Service
- Domain core module: Adding Aggregate Root, Entity and Value objects
- Domain core module: Adding Exception and Domain events
- Domain core module: Implementing Payment Domain Service
- Application Service domain module: Adding Mapper, Config and Ports
- Application Service domain module: Implementing input ports - Part 1
- Application Service domain module: Implementing input ports - Part 2
- Application Service domain module: Refactoring fire event process
- DDD Concepts
- Implementing Data Access module
- Implementing Messaging module: Adding Mapper and Publishers
- Implementing Messaging module: Adding Listeners
- Implementing Container module
UNIDAD 8 - Implementing Restaurant Service · 7 leccionesUNIDAD 8 - Implementing Restaurant Service
UNIDAD 8 - Implementing Restaurant Service
- Domain core module: Adding Aggregate Root and Entities
- Domain core module: Adding Exception, Domain events and Domain Service
- Application Service domain module: Adding Mapper, DTO and Ports
- Application Service domain module: Implementing input ports
- Implementing Data Access module
- Implementing Messaging module
- Implementing Container module
UNIDAD 9 - SAGA Architecture Pattern · 8 leccionesUNIDAD 9 - SAGA Architecture Pattern
UNIDAD 9 - SAGA Architecture Pattern
- Introduction to SAGA pattern
- SAGA Pattern
- Implementing Order Payment Saga
- Using Order Payment Saga in Messaging & Implementing Order Approval Saga
- Testing the application end-to-end with SAGA pattern changes
- Testing failure scenarios
- SAGA Pattern Implementation Considerations
- Understanding SAGA Pattern
UNIDAD 10 - Outbox Architecture Pattern · 26 leccionesUNIDAD 10 - Outbox Architecture Pattern
UNIDAD 10 - Outbox Architecture Pattern
- Introduction to Outbox pattern
- Outbox Pattern
- Updating Order Service database schema and config for Outbox Pattern
- Refactoring Order domain layer: Adding Outbox models & Updating ports
- Refactoring Order domain layer: Adding Outbox scheduler
- Refactoring Order domain layer: Adding Outbox cleaner scheduler for Payment
- Refactoring Order domain layer: Adding Outbox schedulers for Approval
- Refactoring Order domain layer: Updating OrderCreate Command Handler
- Refactoring Order domain layer: Updating Order Payment Saga - Part 1
- Refactoring Order domain layer: Updating Order Payment Saga - Part 2
- Refactoring Order domain layer: Updating Order Approval Saga
- Updating the Order Application Service Test for Outbox pattern changes
- Refactoring Order Data Access module for Outbox pattern
- Refactoring Order Messaging module for Outbox pattern - Part 1
- Refactoring Order Messaging module for Outbox pattern - Part 2
- Testing Order Payment Saga
- Updating Payment database schema, config and package structure for Outbox
- Refactoring Payment domain layer: Adding Outbox schedulers
- Refactoring Payment Data Access module for Outbox pattern
- Refactoring Payment Messaging module for Outbox pattern
- Refactoring Payment domain layer: Updating Message listener implementation
- Testing Payment Request Message Listener for double payment
- Refactoring Restaurant Service for Outbox pattern - Part 1
- Refactoring Restaurant Service for Outbox pattern - Part 2
- Testing the application end-to-end with Outbox pattern changes
- Understanding Outbox Pattern
UNIDAD 11 - CQRS Architecture Pattern · 7 leccionesUNIDAD 11 - CQRS Architecture Pattern
UNIDAD 11 - CQRS Architecture Pattern
- Introduction to CQRS pattern
- CQRS Pattern
- Creating Customer Kafka topic & Customer modules
- Testing failure scenarios
- Implementing Customer Service modules
- Updating Order Service to use local database table with CQRS pattern
- Running Order and Customer Services to test CQRS pattern
UNIDAD 12 - Kubernetes(K8s) · 6 leccionesUNIDAD 12 - Kubernetes(K8s)
UNIDAD 12 - Kubernetes(K8s)
- Introduction to Kubernetes and running a local Kubernetes using Docker Desktop
- Kubernetes concepts
- Deploying Confluent Kafka to local Kubernetes using cp-helm-charts
- Creating Kubernetes deployment files for Microservices
- Deploying Microservices into local Kubernetes
- Deploying Postgres to local Kubernetes using Postgres docker image
UNIDAD 13 - K8s & Google Kubernetes Engine(GKE) · 7 leccionesUNIDAD 13 - K8s & Google Kubernetes Engine(GKE)
UNIDAD 13 - K8s & Google Kubernetes Engine(GKE)
- Creating Google Cloud account & Creating a Kubernetes cluster in GKE
- Pushing docker images to Google Artifact Registry
- Steps to deploy Google Kubernetes Engine
- Running the Application on Google Kubernetes Engine - Part 1
- Running the Application on Google Kubernetes Engine - Part 2
- Adding horizontal scaling to services
- Next steps & Thank you!
UNIDAD 14 - NEW: Outbox pattern with Change Data Capture(CDC) and Debezium · 11 leccionesUNIDAD 14 - NEW: Outbox pattern with Change Data Capture(CDC) and Debezium
UNIDAD 14 - NEW: Outbox pattern with Change Data Capture(CDC) and Debezium
- Introduction to Change Data Capture
- Debezium Kafka Connector
- Configuring Postgresql for Change Data Capture
- Debezium source connector for Postgresql
- Creating the startup and shutdown scripts
- Implementation changes for Change Data Capture - Part 1
- Implementation changes for Change Data Capture - Part 2
- Implementation changes for Change Data Capture - Part 3
- Running multiple instances of services with a Jmeter performance scenario
- Using Optimistic locking & Comparing Lock strategies with Jmeter load test
- Comparing Change Data Capture & Pulling the Outbox table using Jmeter load test
UNIDAD 15 - Version updates: Update to latest Spring boot, Spring cloud & other dependencies · 4 leccionesUNIDAD 15 - Version updates: Update to latest Spring boot, Spring cloud & other dependencies
UNIDAD 15 - Version updates: Update to latest Spring boot, Spring cloud & other dependencies
- Update to spring boot 2.7.5
- Update to spring boot 3.0.5
- Update to spring boot 3.1.5
- Update to spring boot 3.3.2 & Kafka Kraft
UNIDAD 16 - What's next · 1 leccionesUNIDAD 16 - What's next
UNIDAD 16 - What's next
- Bonus Lecture
Tu certificado lo emite la SEP, no solo una plataforma
Al demostrar la competencia recibes un certificado emitido por la Secretaría de Educación Pública a través del Gobierno del Estado de México: un documento oficial que puedes presentar con confianza ante cualquier empleador o institución.
Tu certificado con INEC
- Lo emite la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México
- Documento oficial con folio verificable en línea
- Lo otorga la Universidad Tecnológica Fidel Velázquez
Otras plataformas en línea
- Constancia privada emitida por la misma plataforma
- Solo acredita horas cursadas o asistencia
- Sin respaldo de una autoridad educativa
Tu itinerario, de la inscripción al certificado
- 1
Inscripción con pago único
Pagas $2,800 MXN una sola vez y entras de inmediato al curso.
- 2
Estudias a tu ritmo
16 unidades con videos, lecturas y actividades, disponibles 24/7 durante 12 meses.
- 3
Cuestionarios por unidad
19 cuestionarios para comprobar lo aprendido.
- 4
Certificado
Emitido por la SEP a través del Gobierno del Estado de México, con folio verificable.
Un certificado oficial de la SEP
- Emitido por la Secretaría de Educación Pública (SEP), a través del Gobierno del Estado de México. No es una constancia privada: es un documento oficial, y ese respaldo marca la diferencia frente a otras plataformas en línea.
- Contenido impartido por Ali Gelenler.
- Folio y QR verificables para compartirlo con quien te contrate.
Empieza hoy, a tu ritmo
Un solo pago y acceso inmediato al curso completo durante 12 meses.
- 16 unidades · 161 lecciones · 60 h
- 12 meses de acceso
- 19 cuestionarios de evaluación
- Certificado emitido por la SEP (Gob. del Estado de México) con folio verificable
Sobre tu inscripción
¿Cómo es el pago?
Un solo pago de $2,800 MXN. No hay mensualidades ni cargos recurrentes.
¿Cuánto tiempo tengo acceso?
12 meses desde tu inscripción, 24/7, para avanzar a tu ritmo.
¿Quién imparte el contenido?
El curso es impartido por Ali Gelenler; INEC gestiona tu inscripción, evaluación y certificado.
¿Qué pasa cuando vence mi acceso?
Puedes renovar tu cuenta tú mismo desde la plataforma, sin trámites ni esperas.


