English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 12h 40m | 3.50 GB
Learn how to build Microservices applications starting with business analysis and domain driven design
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 independent set 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 independent nature 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
What you’ll 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
Table of Contents
Course Ouline
1 Author introductions and Course outline
2 Development tools and setup
Microservices Architecture
3 Microservices Architecture
4 Business & Digital Transformation
5 A Business Perspective of Microservices
6 A Technical Perspective of Microservices
7 Adoption of Microservices Architecture
Introduction to Domain Driven Design
8 Domain, Sub-Domain and Domain Experts
9 Conceptual models, Architecture and Design
10 Modeling techniques & Architectural Styles
11 Domain Models
12 Modeling techniques & Architectural Styles
Understanding the Business Domain
13 Why understand the Business
14 Introduction to Business Model Canvas
15 Exercise ACME Travels Business Model Canvas
Domain Driven Design Strategic Patterns
16 Introduction to DDD and Patterns
17 Business Subdomain Types
18 Exercise ACME Subdomain Type Assignment
19 Understanding the Business Context
20 Business Domain Language
21 Strategic Pattern Ubiquitous Language
22 Exercise Define ACME’s Ubiquitous Language
23 Strategic Pattern Bounded Context
24 Discovering the Bounded Contexts in a Domain
25 Exercise Identify ACME’s Bounded Contexts
Bounded Context Relationships
26 Intro to DDD Integration Patterns
27 Managing BC Relationships using Context Maps
28 Symmetric Relationship Patterns
29 Asymmetric Relationship Patterns
30 One to Many Relationship Patterns
31 Exercise Context Mapping for a Bank
Domain Driven Design – Tactical Patterns
32 Intro to DDD Tactical Patterns
33 Entity Object – Pattern
34 Value Object – Pattern
35 Exercise Identify Entity & VO in ACME Sales Model
36 Hands On Building the ACME Sales Entities & VO in JAVA
37 Aggregate & Factory – Pattern
38 Exercise ACME Sales Use Case
39 Hands On UML for ACME Sales Aggregates
40 Model Behavior Anemic & Rich Models
41 Repository Object – Pattern
42 Hands On ACME model Repository in UML & JAVA
43 Domain Service – Pattern
44 Application Services – Pattern
45 Infrastructure Services – Pattern
46 Hands On ACME Domain Service, UML & JAVA
47 Hands On Application and Infrastructure Services, UML & JAVA
Events Driven Architecture & Domain Events
48 Intro to Events in Microservices
49 Monolithic & Distributed Communication Patterns
50 Microservices Interaction Patterns
51 Event Driven Architecture
52 Hands On Pub Sub with AMQP RabbitMQ
53 Domain Events – Pattern
54 Hands On Static Class Broker Pattern
55 Exercise ACME Sales Domain Events
56 Hands On Realization of ACME Domain Events
57 Integration Events – Pattern
58 Exercise ACME Sales Integration Events
59 Hands On Realization of ACME Integration Events (1 of 2)
60 Hands On Realization of ACME Integration Events (2 of 2)
Event Storming for creating shared knowledge
61 Learning Objectives Discovering the Events in a Domain
62 Introduction to Event Storming
63 Elements of Event Storming
64 Preparing for the ES Workshop
65 Conducting the ES Workshop
66 Exercise ACME Sales ES Workshop
Microservices Data Management Patterns
67 Introduction to Microservices Data Persistence
68 Monolithic Apps – Shared Persistence Storage
69 Service Oriented Architecture (SOA)
70 Separate Database pattern
71 Brownfield Microservices Database patterns options
72 Shared Database Pattern
73 Shared Database Challenges & Solutions
Microservices DB Performance Management
74 Need for more Data Patterns
75 Commands Query Separation (CQS)
76 Hands On PostgreSQL Database for backend
77 Realization of Commands & Queries
78 Hands On Build the CQS Pattern
79 Command Query Responsibility Segregation (CQRS)
80 Data Replication between WRITE-READ sides
81 Exercise ACME CQRS for Proposal
82 Hands On ACME CQRS command implementation
83 Event Sourcing and Event Store considerations
84 Hands On MongoDB for ACME Sales READ side
85 Hands On CQRS-v1 Proposal Subscriber
86 Hands On CQRS-v2 Read side Query
Microservices Managing the Data Integrity
87 Introduction to Reliable Messaging
88 Designing for Failure
89 Exercise Address ACME CQRS Write side failures
90 Exercise Address ACME CQRS Read side failures
91 Hands On Handling Duplicate Messages
Microservices and Kafka
92 Use of Kafka in Microservices
93 Kafka Overview
94 Kafka Concepts
95 Hands On Create a Kafka Cluster
96 Hands On Working with Kafka Producer
97 Hands On Working with Kafka Consumer Groups
98 Kafka vs AMQP (RabbitMQ)
99 Exercise Messaging for Microservices
Managing Distributed Transactions with SAGA
100 Distributed Transactions with SAGA
101 SAGA Pattern for distributed transactions
102 SAGA Choreography Vs. Orchestration
103 SAGA Implementation Considerations
104 Exercise ACME Sales Booking Transaction SAGA
105 Hands On UML & Code walkthrough of Booking SAGA
Microservices and API
106 Microservices-API Realization
107 Introduction to REST API
108 REST API Resources & Design constraints
109 API Management
110 Exercise ACME REST API for Products
111 Hands On ACME REST API in action
112 Introduction to GraphQL
113 GraphQL Schema Definition
114 Exercise ACME GraphQL API for Products
115 Hands On ACME GraphQL API in action
Resolve the captcha to access the links!