Microservice Implementation (with EDA, Hexagonal, DDD)

Complete in one lecture
The 3 major microservice implementation architectures!

* We are working on improving it, but some videos may have poor audio quality and there may be bugs (typos) in the code. Please let us know if there are any typos or areas for improvement so we can continue to improve.

Learn by seeing actual code
MSA Core 3 Architectures

(1) Hexagonal architecture, (2) Domain-driven design, and (3) Event-driven architecture are used to learn about the implementation of microservices that are flexible in technology, focused on business logic, highly maintainable, and have low dependencies and can be deployed independently.

Many developers are conceptually/theoretically familiar with the most talked about domain-driven design, hexagonal architecture, and event-driven architecture in MSA architecture. However, when it comes to actually applying them, it can be overwhelming.

This lecture is a hands-on lecture that concludes the previous lecture that explained MSA concepts and architecture/design methods.

• Introduction to Microservice Concepts & MSA Patterns
• Microservice Internal Architecture & Design (DDD, Event Storming)

Based on the above practical architecture and design model defined in the previous lecture, we will implement and explain with actual code how to effectively integrate DDD, hexagonal architecture, and EDA. In the end, we will also apply the SAGA pattern for distributed transactions, which is a realistic problem in EDA implementation.

3 Hottest Techniques in Microservices Implementation 🌳

Only for this lecture
Check out the features 📗

• I will teach you vivid, raw information based on the experience of a long-time practitioner. 😁
• We aim for the ideal of hexagonal architecture/domain-driven design, but present an approach that reflects reality.
• This course focuses on practical implementation of a book rental system using a microservice architecture rather than concepts.
• We introduce hot on-site standards and judgment(?) techniques applied in actual microservice development .

So, this is helpful for these people! 🏃‍♀️

_{Technology/design leaders looking to adopt a flexible and scalable microservices architecture}

_{Microservice developers who want to apply hexagonal architecture to microservices}

_{Backend developer interested in domain-driven design (DDD) and implementation}

Okay, now let's implement it!
Microservices Development 💻

Understand the implementation architecture through the microservices composition diagram of the practice domain.

Let's learn about the characteristics, configuration specifications, and communication relationships between microservices for each microservice in the practice domain.

Highly available and highly scalable: Event Broker

Describes the characteristics of an event broker, an essential element for implementing an event-driven architecture, and explains how to utilize it for communication between microservices.

Suggesting a direction for implementing hexagonal architecture

Describes the three hexagonal types of hexagonal architecture and explains the Spring Boot package structure for applying the architecture.

Implementing a hexagonal architecture that allows defining the most flexible microservice internal structure

We will explain how to implement a hexagonal architecture that overcomes the limitations of traditional layered architectures by combining it with domain-driven design, and take a closer look at its main components.

Implementing the domain model

We will explain the domain model for each microservice modeled using domain-driven design (tactical design) with the topic of a book rental system, and then implement it with actual code.

Implementing an event-driven architecture

We organize the asynchronous communication relationships between microservices identified through event storming, design them as event flows, and implement them using Kafka.

SAGA implementation

To solve the problem of distributed transactions between microservices, we will implement the SAGA pattern, a representative MSA pattern, using the Kafka event broker.

So, you can do something like this! 😎

In this lecture
Knowledge sharer is 💁‍♂️

23-year developer, han jeong heon

• Current SI software engineer at a large corporation
• Leading development methodology and design method for multiple large-scale next-generation projects
• Lectures on SW courses at Myongji University and Seoul National University of Science and Technology, Korea Information Technology Research Institute (KITRI), and LG Electronics MSA course
• Multicampus, Korea Standards Association, Korea Quality Association MSA Course Mentoring
• Areas of expertise: Development methodology, software architecture/design/development techniques
• Wikibooks “Microservice Development Starting with Domain-Driven Design” (2022)
• National Institute for Lifelong Education K-MOOC “Microservice Design and Implementation” Course

_{Development of “Microservice Design and Implementation” course}

_{Author of “Microservice Development Starting with Domain-Driven Design”}

Q&A 💬

Great lectures to watch together 📺