What you would learn in Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka course?
Hello! Hello! My name's Ali Gelenler. I'm here for you to help understand the microservices design process while using Clean and Hexagonal architectural designs and Domain Driven Design.
In this course, you'll focus on the architectural aspects of microservices and employ Clean Architecture principles while developing each service. When you implement the domain layer, you will also be applying Domain Driven Design principles.
It is possible to make sure you are using the most recent versions of spring boot and other dependencies that are included in this course. I'll keep updating the dependency version during the last lecture of the section. You can for the required code and the configuration changes to reflect new versions.
You will be implementing SAGA, Outbox, and CQRS patterns by using the five Spring Boot Java microservices that you create with Clean and Hexagonal architectural principles.
Additionally, you will learn how to make use of Kafka as storage for events, as well as also use events to connect services and apply an architectural pattern.
The main concepts you'll be learning and applying include:
Event-driven services using Kafka
SAGA Architecture Pattern
Outbox Architecture Pattern
CQRS Architecture Pattern
Kubernetes locally using Docker desktop
Kubernetes on Google Cloud using Google Kubernetes Engine(GKE)
To interact with microservices' data stores, I'll use Spring Data JPA for PostgreSQL and Spring Kafka for Kafka.
You'll be taking an active approach to developing an entire project entirely from scratch. You will have five microservices that communicate through events using Kafka to store events.
There will be multiple-choice questions throughout each section to test your progress through the course.
By the end of the course, you will know how to manage an event-driven microservices model using Clean as well as Hexagonal Architecture principles and Domain Driven Design principles. The course will make use of Spring boot as well as Java to create the microservices. Additionally, you will learn how to implement microservices architecture patterns like SAGA, Outbox, and CQRS. At the end of the course, you'll be able to implement your app on Kubernetes by using Google Kubernetes Engine.
I've followed the same neat and hexagonal designs and domain-driven design principles to develop every microservice. If you you'd prefer not to do any repetitions, you could take a look at the code source I have provided before starting Saga as well as Outbox patterns and before beginning to deploy Kubernetes. Then, you can utilize it to complete the program.
You can look through the intro video and free lessons for more information about the course's progress. And if you choose to take part in this course, you're always welcome to inquire for clarification and discussion of the concepts and details of implementation in the questions and answers sections. I will be there from start to finish to ensure that you succeed in completing this course and get as much information and experience as possible.
Create Microservices Architecture using Spring Boot and Kafka
Know and apply clean architecture
Learn and apply Hexagonal Architecture
Know and Apply domain-driven Design(DDD)
Implement SAGA Architecture Pattern
Implement Outbox Architecture Pattern
Implement CQRS Architecture Pattern
Study Kafka Architecture and program on Kafka
Learn with Kafka to serve as an Event Store that provides Event-Driven Service
Learn Kubernetes basics & Run a local cluster using Docker desktop
Microservices can be deployed locally to the Kubernetes Cluster
Run Confluent Kafka on Kubernetes using cp-helm-charts
Run Postgres on Kubernetes
Learn about Google Cloud as well as Google Kubernetes Engine(GKE)