Lompat ke konten Lompat ke sidebar Lompat ke footer

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

Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka - Learn Spring boot microservices with Clean & Hexagonal architectures, DDD, Saga, Outbox, CQRS, Kafka, Kubernetes & GKE
  • Highest rated

Preview this course GET COUPON CODE

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

  • 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.

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.

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 before starting Saga and Outbox patterns, and before starting to deploy to Kubernetes. You can then use it to continue with the course.

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.

Who this course is for:
  • 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
100% Off Udemy Coupon . Free Udemy Courses . Online Classes

Posting Komentar untuk "Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka"