Domain Driven Design & Microservices for Architects

Domain Driven Design & Microservices for Architects, available at $74.99, has an average rating of 4.51, with 115 lectures, based on 2476 reviews, and has 20527 subscribers.

You will learn about Domain Driven Design Architecting Microservices Application Design Patterns for building Microservices & Distributed systems Event Driven Architecture Developing API for Microservices Event Storming Develop a Business case for Microservices This course is ideal for individuals who are Software Developers or Software Architects or Product Managers or Students interested in Microservices It is particularly useful for Software Developers or Software Architects or Product Managers or Students interested in Microservices.

Enroll now: Domain Driven Design & Microservices for Architects

Summary

Title: Domain Driven Design & Microservices for Architects

Price: $74.99

Average Rating: 4.51

Number of Lectures: 115

Number of Published Lectures: 115

Number of Curriculum Items: 115

Number of Published Curriculum Objects: 115

Original Price: $34.99

Quality Status: approved

Status: Live

What You Will Learn

Domain Driven Design
Architecting Microservices Application
Design Patterns for building Microservices & Distributed systems
Event Driven Architecture
Developing API for Microservices
Event Storming
Develop a Business case for Microservices

Who Should Attend

Software Developers
Software Architects
Product Managers
Students interested in Microservices

Target Audiences

Software Developers
Software Architects
Product Managers
Students interested in Microservices

PS: Focus is on designing Microservices not coding

No specific Microservices framework in use
All sample code is in plain JAVA to demonstrate/clarify understanding of DDD patterns, etc.
Models are developed in UML – using the PlantUML tool
PostgreSQL/MongDB/RabbitMQ/Kafka – free instances created on the cloud for demos & walkthroughs

PLEASE Do NOT join the course if you are looking for tutorials on Microservices Coding or specific framework!!!

What is this course about?

Microservices is a new way of building software in which an application is composed of an independentset of services. The biggest benefit of Microservices is that it enables an organization to transform at a very rapid pace. This speed to market is achieved due to the independentnature of the services that make up a Microservices application. Companies like Amazon, Netflix and Etsy have proven the value of Microservices beyond doubt.

Many organizations today are looking to adopt Microservices. These organizations are investing in technologies, tools, skills and are changing their software development and delivery processes as well. But still many organizations are failing to achieve the full benefits of Microservices; in fact many organizations feel that they have created technical debt by adopting Microservices.

So why is it that some organizations have been successful in adopting Microservices while others are not. One common aspect I have observed in companies that fail to adopt Microservices is that they treat Microservices as a purely technology initiative. They do not spend time in understanding the business aspects of their Microservices applications !!!

Microservices is NOT just about technology

The key element of the Microservices architecture is that services are Independent. This independent aspect of the service is what makes it possible for Microservices to change independently of other services. If scope of the microservices is leading to inter-dependencies between services then it would lead to a need for change coordination between teams which in turn will lead to the same problems we have with Monolithic applications !!! Release cycles will be longer and there will be no benefit of the adoption of Microservices.

To ensure that these is no interdependencies between Microservices, a Microservices architect needs to understand the domain and then decide on the boundary and scope of the Microservices. This is where Domain Driven Design comes into picture. Once the Microservices business boundaries are defined the services should be built using appropriate Microservices design patterns and technologies.

Teams working on Microservices should not just look at the technical aspects of the service but MUST keep in mind that there are other considerations that play a critical part in the success of Microservices initiative. In order to

Role of a Microservices Architect

An IT professional working in the role of Microservices architect is responsible for may aspects depending on the maturity of Microservices adoption in their organization. Here are the list of activities that the architects is responsible for:

Evaluate the business benefits of Microservices for their specific organization
Build a Business case for Microservices
Educate the Business & IT stakeholders on pros/cons of Microservices
Apply Domain Driven Design to demarcate the boundaries of Microservices
Define the domain model for the Microservices
Do the technical design of Microservices
Guide and Mentor the Microservices teams
Evaluate the technologies | frameworks for the realization of Microservices
Build proof of concepts to show how things work

How will this course help?

This course will help developers & architects in building skills needed for successful implementation of Microservices applications. It consists of a combination of concepts, UML modelling and working code to demonstrate the implementation of Microservices. Students will learn the concepts of Domain driven design by way of common industry examples and a case study (ACME travels).

Focus is on Architecture, Design and Development of Microservices.

1. Transformation & Microservices

2. Domain Driven Design

3. Applying the DDD strategic & tactical pattern

4. Event Driven Architecture

5. Event Storming

6. Data Management

7. Messaging

8. Distributed Transactions

9. API

IMPORTANT:

Code Samples

Focus is on the Microservices design not coding.

All of the sample code is in plain JAVA
Course does NOT cover any specific framework
SpringBoot is used in samples for API/GraphQL section

Please check out the course preview lectures before enrolling the course.

Review the topics covered
Make sure you understand instructor’s accent

Pre-Requisites

Basic understanding of JAVA or any other programming language
Some experience with software development practices

PS:

Hand on part is optional but students are encouraged to do hands on tasks to get a better feel of the design patterns.

Course Curriculum

Chapter 1: Course Ouline

Lecture 1: Author introductions and Course outline

Lecture 2: Development tools and setup

Chapter 2: Microservices Architecture

Lecture 1: Microservices Architecture

Lecture 2: Business & Digital Transformation

Lecture 3: A Business Perspective of Microservices

Lecture 4: A Technical Perspective of Microservices

Lecture 5: Adoption of Microservices Architecture

Chapter 3: Introduction to Domain Driven Design

Lecture 1: Domain, Sub-Domain and Domain Experts

Lecture 2: Conceptual models, Architecture and Design

Lecture 3: Modeling techniques & Architectural Styles

Lecture 4: Domain Models

Lecture 5: Modeling techniques & Architectural Styles

Chapter 4: Understanding the Business Domain

Lecture 1: Why understand the Business?

Lecture 2: Introduction to Business Model Canvas

Lecture 3: Exercise : ACME Travels Business Model Canvas

Chapter 5: Domain Driven Design : Strategic Patterns

Lecture 1: Introduction to DDD and Patterns

Lecture 2: Business Subdomain Types

Lecture 3: Exercise : ACME Subdomain Type Assignment

Lecture 4: Understanding the Business Context

Lecture 5: Business Domain Language

Lecture 6: Strategic Pattern : Ubiquitous Language

Lecture 7: Exercise : Define ACME's Ubiquitous Language

Lecture 8: Strategic Pattern : Bounded Context

Lecture 9: Discovering the Bounded Contexts in a Domain

Lecture 10: Exercise : Identify ACME's Bounded Contexts

Chapter 6: Bounded Context Relationships

Lecture 1: Intro to DDD Integration Patterns

Lecture 2: Managing BC Relationships using Context Maps

Lecture 3: Symmetric Relationship Patterns

Lecture 4: Asymmetric Relationship Patterns

Lecture 5: One to Many Relationship Patterns

Lecture 6: Exercise : Context Mapping for a Bank

Chapter 7: Domain Driven Design – Tactical Patterns

Lecture 1: Intro to DDD Tactical Patterns

Lecture 2: Entity Object – Pattern

Lecture 3: Value Object – Pattern

Lecture 4: Exercise : Identify Entity & VO in ACME Sales Model

Lecture 5: Hands On : Building the ACME Sales Entities & VO in JAVA

Lecture 6: Aggregate & Factory – Pattern

Lecture 7: Exercise : ACME Sales Use Case

Lecture 8: Hands On : UML for ACME Sales Aggregates

Lecture 9: Model Behavior : Anemic & Rich Models

Lecture 10: Repository Object – Pattern

Lecture 11: Hands On : ACME model Repository in UML & JAVA

Lecture 12: Domain Service – Pattern

Lecture 13: Application Services – Pattern

Lecture 14: Infrastructure Services – Pattern

Lecture 15: Hands On : ACME Domain Service, UML & JAVA

Lecture 16: Hands On : Application and Infrastructure Services, UML & JAVA

Chapter 8: Events Driven Architecture & Domain Events

Lecture 1: Intro to Events in Microservices

Lecture 2: Monolithic & Distributed Communication Patterns

Lecture 3: Microservices Interaction Patterns

Lecture 4: Event Driven Architecture

Lecture 5: Hands On : Pub Sub with AMQP/RabbitMQ

Lecture 6: Domain Events – Pattern

Lecture 7: Hands On : Static Class Broker Pattern

Lecture 8: Exercise : ACME Sales Domain Events

Lecture 9: Hands On : Realization of ACME Domain Events

Lecture 10: Integration Events – Pattern

Lecture 11: Exercise : ACME Sales Integration Events

Lecture 12: Hands On : Realization of ACME Integration Events (1 of 2)

Lecture 13: Hands On : Realization of ACME Integration Events (2 of 2)

Chapter 9: Event Storming for creating shared knowledge

Lecture 1: Learning Objectives : Discovering the Events in a Domain

Lecture 2: Introduction to Event Storming

Lecture 3: Elements of Event Storming

Lecture 4: Preparing for the ES Workshop

Lecture 5: Conducting the ES Workshop

Lecture 6: Exercise : ACME Sales ES Workshop

Chapter 10: Microservices Data Management Patterns

Lecture 1: Introduction to Microservices Data Persistence

Lecture 2: Monolithic Apps – Shared Persistence Storage

Lecture 3: Service Oriented Architecture (SOA)

Lecture 4: Separate Database pattern

Lecture 5: Brownfield Microservices : Database patterns | options

Lecture 6: Shared Database Pattern

Lecture 7: Shared Database : Challenges & Solutions

Chapter 11: Microservices DB Performance Management

Lecture 1: Need for more Data Patterns

Lecture 2: Commands Query Separation (CQS)

Lecture 3: Hands On : PostgreSQL Database for backend

Lecture 4: Realization of Commands & Queries

Lecture 5: Hands On : Build the CQS Pattern

Lecture 6: Command Query Responsibility Segregation (CQRS)

Lecture 7: Data Replication between WRITE-READ sides

Lecture 8: Exercise : ACME CQRS for Proposal

Lecture 9: Hands On : ACME CQRS command implementation

Lecture 10: Event Sourcing and Event Store considerations

Lecture 11: Hands On : MongoDB for ACME Sales READ side

Lecture 12: Hands On : CQRS-v1 Proposal Subscriber

Lecture 13: Hands On : CQRS-v2 Read side Query

Chapter 12: Microservices Managing the Data Integrity

Lecture 1: Introduction to Reliable Messaging

Lecture 2: Designing for Failure

Instructors

Rajeev Sakhuja
11xAWS Certified, Consultant, Mentor, Innovation evangelist

Rating Distribution

1 stars: 19 votes
2 stars: 46 votes
3 stars: 237 votes
4 stars: 957 votes
5 stars: 1217 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu