Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka from Udemy

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 & Hexagonal 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. 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
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)

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.

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.

What's inside

Learning objectives

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
Learn change data capture(cdc) with debezium and kafka
Show more
Show less

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
Learn change data capture(cdc) with debezium and kafka
Show more
Show less

Syllabus

Learn structure of the course and the project overview

Structure of the course

Clean & Hexagonal architectures

Project overview - Part 1

Project overview - Part 2

SAGA Pattern

Setting up the environment

The source code provided as GitHub links and zip files!

Understand Clean and Hexagonal Architectures

Introduction to Clean and Hexagonal Architectures

Hexagonal Architecture

Designing components for Order Service using Clean Architecture

Creating Order Service modules using Clean Architecture - PART 1

Creating Order Service modules using Clean Architecture - PART 2

Dependency Inversion Principle

Learn and Implement Domain Driven Design concepts

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

Learn Kafka basics and write generic Kafka modules

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

Complete Order Service with domain, application, dataaccess, messaging and container layers

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 Customer Service & Running Order Service

Implement Payment Service with domain, dataaccess, messaging and container layers

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

Implement Restaurant Service with domain, dataaccess, messaging and container layers

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 Messaging module

Implementing Container module

Learn SAGA Architecture Pattern and apply to the application to handle distributed transactions

Introduction to 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

Learn Outbox Architecture Pattern and apply to the application to complete SAGA pattern in a consistent way

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

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Teaches a comprehensive set of skills, including Spring Boot, Clean Architecture, Hexagonal Architecture, Domain Driven Design, Apache Kafka, SAGA, Outbox, CQRS, and Kubernetes

Develops expertise in microservices architecture, making learners highly valuable in the job market

Taught by Ali Gelenler, an experienced instructor with a proven track record in software development and architecture

Provides hands-on experience through project-based learning, ensuring practical application of concepts

Covers both theoretical foundations and practical implementation, providing a well-rounded understanding of microservices architecture

Leverages modern technologies and industry best practices, ensuring learners are up-to-date with the latest advancements

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka with these activities:

Read 'Clean Architecture: A Craftsman's Guide to Software Structure and Design' by Robert C. Martin

Show steps

Provides a foundation for understanding the principles of Clean Architecture and Hexagonal Architecture, which are fundamental concepts covered in this course.

View Clean Architecture on Amazon

Show steps

Read the book and take notes on key concepts and principles.
Identify how these principles can be applied to the microservices architecture you will be developing in this course.

Build a simple microservice using Spring Boot and Kafka

Show steps

Provides hands-on experience with the core technologies used in this course, helping you to build a solid foundation.

Browse courses on Microservices

Show steps

Set up a development environment with Spring Boot and Kafka.
Create a simple microservice that performs a basic operation, such as sending a message to a Kafka topic.
Test your microservice to ensure it is working as expected.

Complete coding challenges on LeetCode or HackerRank related to microservices and Kafka

Show steps

Sharpens your coding skills and reinforces your understanding of microservices and Kafka concepts.

Show steps

Identify coding challenges that are relevant to the topics covered in this course.
Attempt to solve the challenges on your own.
Review solutions and learn from your mistakes.

Five other activities

Expand to see all activities and additional details

Show all eight activities

Write a blog post summarizing the key concepts of Domain Driven Design (DDD)

Show steps

Enhances your understanding of DDD by requiring you to explain its concepts in your own words.

Browse courses on Domain Driven Design

Show steps

Research and gather information on DDD from the course materials and other sources.
Organize your thoughts and ideas into a coherent structure.
Write and edit your blog post, ensuring it is clear and informative.

Design and implement a SAGA pattern to handle distributed transactions in your microservices application

Show steps

Provides practical experience in implementing a critical architectural pattern that ensures data consistency across multiple services.

Show steps

Review the concepts and implementation of the SAGA pattern.
Design a SAGA pattern that meets the specific requirements of your microservices application.
Implement the SAGA pattern in your application code.
Test your implementation to ensure it is working correctly.

Follow tutorials on deploying microservices to Kubernetes using Docker

Show steps

Provides step-by-step guidance on deploying your microservices application to a production-like environment.

Browse courses on Kubernetes

Show steps

Find tutorials that cover the deployment of microservices to Kubernetes using Docker.
Follow the instructions in the tutorials carefully.
Deploy your own microservices application to Kubernetes using Docker.

Attend a workshop on event-driven architecture using Apache Kafka

Show steps

Offers an immersive learning experience where you can interact with experts and gain hands-on practice in implementing event-driven architectures.

Browse courses on Event-Driven Architecture

Show steps

Find a workshop on event-driven architecture using Apache Kafka.
Register and attend the workshop.
Actively participate and learn from the workshop materials and instructors.

Contribute to an open-source project related to microservices or Kafka

Show steps

Provides an opportunity to apply your skills in a real-world setting, contribute to the community, and enhance your understanding of microservices and Kafka.

Browse courses on Open Source

Show steps

Identify open-source projects related to microservices or Kafka that align with your interests.
Review the project documentation and codebase.
Make contributions, such as fixing bugs, implementing new features, or improving documentation.

Career center

Learners who complete Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka will develop knowledge and skills that may be useful to these careers:

Software Architect

Software Architects design, develop, and maintain the overall architecture of software systems. This course will help prepare one for this role by providing a deep dive into various architectural patterns such as SAGA, outbox, and CQRS. Understanding these concepts is essential for designing and implementing scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Software Architect

Principal Software Engineer

Principal Software Engineers are responsible for leading and mentoring other software engineers and for designing and developing complex software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Principal Software Engineer

Enterprise Architect

Enterprise Architects design, develop, and manage the overall architecture of an organization's IT systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable enterprise-wide IT systems.

See salaries and explore the career path for Enterprise Architect

Solutions Architect

Solutions Architects design, develop, and implement technology solutions that meet the needs of their clients. This course will help prepare one for this role by providing a comprehensive understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are becoming increasingly important in the development of modern, cloud-based applications.

See salaries and explore the career path for Solutions Architect

Software Development Manager

Software Development Managers are responsible for planning, organizing, and directing the development of software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for managing the development of scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Software Development Manager

Data Architect

Data Architects design, develop, and manage the architecture of an organization's data systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable data systems.

See salaries and explore the career path for Data Architect

Computer and Information Research Scientist

Computer and Information Research Scientists invent and develop new approaches to computing technology and find innovative uses for existing technology. Those interested in this career path should consider this course, which provides a strong foundation in software architecture and design principles. Learning about topics such as clean architecture, hexagonal architecture, and domain-driven design (DDD) will help prepare one for roles such as this that require an advanced level of technical knowledge and expertise.

See salaries and explore the career path for Computer and Information Research Scientist

Technical Project Manager

Technical Project Managers are responsible for planning, organizing, and directing the development of software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for managing the development of scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Technical Project Manager

Senior Software Engineer

Senior Software Engineers are responsible for designing and developing complex software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Senior Software Engineer

Database Administrator

Database Administrators are responsible for managing and maintaining the databases used by an organization's software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for managing and maintaining the databases used by scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Database Administrator

DevOps Engineer

DevOps Engineers are responsible for bridging the gap between software development and IT operations. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing, developing, and deploying scalable, reliable, and maintainable software systems.

See salaries and explore the career path for DevOps Engineer

Cloud Architect

Cloud Architects design, develop, and manage the architecture of an organization's cloud-based systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable cloud-based systems.

See salaries and explore the career path for Cloud Architect

Back-End Developer

Back End Developers are responsible for designing and developing the back end of software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Back-End Developer

Full-Stack Developer

Full Stack Developers are responsible for designing, developing, and deploying software systems. This course will help prepare one for this role by providing a deep understanding of microservices architecture, event-driven architecture, and the use of Apache Kafka as an event store. These concepts are essential for designing and implementing scalable, reliable, and maintainable software systems.

See salaries and explore the career path for Full-Stack Developer

Front-End Developer

Front End Developers are responsible for designing and developing the front end of software systems. While this course does not teach front end development skills, it may still be of interest to Front End Developers who want to learn more about microservices architecture, event-driven architecture, and the use of Apache Kafka.

See salaries and explore the career path for Front-End Developer