English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 10 Hours | 4.53 GB
Handle millions of request with designing high scalable and high available systems on microservices architecture.
In this course, we’re going to learn how to Design Microservices Architecture with using Design Patterns, Principles and the Best Practices. We will using the right architecture design patterns and techniques.
By the end of the course, you will Learn how to handle millions of request with designing system for high availability, high scalability, low latency, and resilience to network failures on microservices distributed architectures.
This course is will be the journey of software architecture design with step by step evolving architecture monolithic to event driven microservices.
We will start the basics of software architecture with designing e-commerce monolithic architecture that handles low amount of requests.
After that step by step evolves the architecture with
- Layered Architecture
- SOA
- Microservices
- and lastly Event Driven Microservices Architectures
with designing together that handle millions of requests.
We will discuss microservices architectures with all aspects,
- Microservices Decomposition
- Microservices Communications (Sync / Async Message-Based Communication, API Gws)
- Microservices Data Management (Databases / Query / Commands / Distributed Transactions)
- Microservices Distributed Caching
- Microservices Deployments with Containers and Orchestrators
with applying microservices design patterns and practices.
We are going to design with together and step by step with our drawing tool that we will use this designing architectures.
We will start with designing Monolithic Architecture. And you can see that we have Functional and Non-functional requirements that should cover our design and we have patterns and principles toolbox that we will learn and use these principles when evolving architectures.
You will find that we will add new requirements in order to handle millions of request and learn new patterns and practices that will use these principles when evolving architectures.
- Layered Architecture
- SOA
- Microservices Architectures
- Microservices Architectures API Gws
- Microservices Architectures API Gws – BFF
- Microservices Architecture – Service Aggregator / Registry Patterns
- Microservices Architecture – Message Broker
- Microservices Architecture – Database Sharding Cassandra
- Event-Driven Microservices Architecture
- Microservices Distributed Caching
- Microservices Containers and Orchestrators
We will see full of patterns and principle toolbox is loading with new patterns and apply them into current designs. We will see latest patterns that we use more than 30 patterns and practices with implementing High scalability, High availability and handle millions of request requirements.
Let me write some microservices pattern which we covered in this courses;
- The Database-per-Service Pattern
- API Gateway Pattern
- Backends for Frontends pattern BFF
- Service Aggregator Pattern, Service Registry Pattern
- CQRS and Event Sourcing Patterns
- Materialized View Pattern
- Publish–Subscribe Pattern
- Database Sharding Pattern
- Saga Pattern
- Outbox Pattern
and so on..
So the course flow will be the both theoretical and practical information;
- We will learn a specific pattern, why and where we should use
- After that we will see the Reference architectures that applied these patterns
- After that we will design our architecture with applying this newly learned pattern with together
- And lastly we will decide which Technologies can be choices for that architectures.
And at the last section, we will made Code Review for Existing Microservices Architecture Repository on GitHub for practical implementation of microservices architecture.
So this course will includes
- Hands-on Design Activities
- Iterate Design Architecture from On-Premises to Cloud Server-less architectures
- Evolves architecture monolithic to Event-Driven Microservices Architectures
- Refactoring System Design for handling million of requests
- Apply best practices with microservices design patterns and principles
- Examine microservices patterns with all aspects like Communications, Data Management, Caching and Deployments
- Prepare for Software Architecture Interviews
Prepare for System Design Architecture Interview exams.
I have been joined several famous company’s architecture position interviews, also involved software architect positions assessment process more than 50+ interviews collect the architecture requirements for software industry positions.
So with this course, you will gain real-world experience about all architecture positions from monolithic to event-driven microservices architectures.
This course prepared for the beginner but at least you should familiar with basics of software architectures. This course will have good theoretical information but also will be 90% of hands-on design activities. All course architecture steps will designed step by step and together.
What you’ll learn
- Design Microservices Architecture with using Design Patterns, Principles and the Best Practices
- Learn how to handle millions of request with designing system for high availability, high scalability, low latency, and resilience to network failures
- Journey of software architecture design
- Step by step evolving architecture monolithic to event driven microservices
- Designing e-commerce monolithic – Layered – SOA – Microservices – Event-Driven Architecture
- Microservices Decomposition Strategies
- Microservices Communications (Sync / Async Message-Based Communication, API Gws)
- Microservices Data Management (Databases / Query / Commands / Distributed Transactions)
- Microservices Distributed Caching
- Microservices Deployments with Containers and Orchestrators
- Microservices Design Patterns and Best Practices
- The Database-per-Service Pattern, Api Gateway Pattern, Backends for Frontends pattern BFF
- Service Aggregator Pattern, Service Registry Pattern
- CQRS and Event Sourcing Patterns, Eventual Consistency Principle, CAP Theorem
- Materialized View Pattern, Publish–Subscribe Pattern, Database Sharding Pattern
- Saga Pattern, Outbox Pattern
- Code Review for Existing Microservices Architecture Repository on GitHub
- Hands-on Design Activities, Iterate Design Architecture from On-Premises to Cloud Serverless architectures
- Evolves architecture monolithic to event-driven microservices architectures
- Refactoring System Design for handling million of requests
- Prepare for Software Architecture Interviews
- Prepare for System Design Architecture Interviews
Table of Contents
Introduction
1 Introduction
2 Prerequisites and Tools
3 Setting Up Design Environment
4 Design Architecture Journey = Monolithic – Layered – SOA – Microservices
5 Understand E-Commerce Domain – Use Cases – Functional Requirement
6 Understand E-Commerce Domain – Use Cases – Non-Functional Requirement
Monolithic Architecture
7 Introduction
8 When to use Monolithic Architecture
9 Benefits of Monolithic Architecture
10 Challenges of Monolithic Architecture
11 Monolithic Architecture Pros-Cons
12 Reference architectures of Monolithic Architecture
13 Design principles of Monolithic Architecture — KISS, YAGNI, DRY
14 Design the Architecture – E-Commerce App – KISS DRY YAGNI
15 Design the Architecture – E-Commerce App – Database and Components
16 Monolithic Architecture Inter-Process Communication
17 Inter-Process communication – Transaction Management in Monolithic Architectures
Scalability – Vertical Scaling – Horizontal Scaling
18 Scalability – Vertical Scaling – Horizontal Scaling Introduction
19 Vertical Scaling – Scale up
20 Horizontal Scaling – Scale out
21 Design the Architecture – E-Commerce App – Scaling the Application
22 What is Load Balancer and Why We are using Load Balancer with Consistent Hashing
23 Technology Choices – Adapting Technology Stack
24 Deployments for Monolithic Architecture
Layered (N-Layer) Architecture
25 Introduction
26 Design principles – Separation of Concerns (SoC)
27 Design principles – SOLID
28 Design the Architecture – E-Commerce App – Layered Architecture
29 Technology Choices – Adapting Technology Stack
Service-Oriented Architecture (SOA)
30 Introduction
31 Architectural Design patterns – Enterprise Service Bus (ESB)
32 Design the Architecture – E-Commerce App – SOA
33 Communication in SOA
34 Comparing SOA and Microservices
Microservices Architecture
35 Introduction – What are Microservices
36 What are Microservices – 2
37 Microservices Characteristics
38 Benefits of Microservices Architecture
39 Challenges of Microservices Architecture
40 When to Use Microservices Architecture – Best Practices
41 Monolithic vs Microservices Architecture Comparison
42 Design Pattern – The Database-per-Service Pattern
43 Reference Architectures of Microservices Architecture
44 Design Microservice Architecture – E-Commerce App – KISS DRY YAGNI
45 Design Microservice Architecture – E-Commerce App – Database-per-Services
46 Technology Choices – Adapting Technology Stack
Decomposition Microservices Architecture – Understand E-Commerce Domain
47 Introduction
48 Microservices Decomposition Pattern – Decompose by Business Capability
49 Microservices Decomposition Pattern – Decompose by Subdomain
50 Bounded Context Pattern (Domain-Driven Design – DDD)
51 Identify Bounded Context Boundaries for Each Microservices
52 Using Domain Analysis to Model Microservices
53 Analysis E-Commerce Domain – Use Cases
54 Analysis E-Commerce Domain – Nouns and Verbs
55 Identifying and Decomposing Microservices for E-Commerce Domain
Microservices Communications – Basics
56 Introduction
57 Microservices Communication Types – Sync or Async Communication
58 Microservices Communication Types Request-Driven or Event-Driven Architecture
59 Microservices Synchronous Communication Patterns and Best Practices
60 Designing HTTP based RESTful APIs for Microservices
61 RESTful API design for Microservices
62 RESTful API design for Microservices – Part 2
63 What is gRPC
64 How gRPC works
65 Advantages of gRPC
66 gRPC vs REST
67 gRPC Usage of Microservices Communication
68 Example of gRPC in Microservices Communication
Microservices Communication Design Patterns – API Gateways
69 Introduction
70 Gateway Routing Pattern
71 Gateway Aggregation Pattern
72 API Gateway Pattern
73 Main Features of API Gateway Pattern
74 DESIGN – API Gateway – Microservices Communications Design Patterns
75 Backends for Frontends pattern BFF – Microservices Communications Design pattern
76 DESIGN – Backends for Frontends pattern BFF – Microservices Communications
77 Service-to-Service Communications between Backend Internal Microservices
78 Service Aggregator Pattern – Microservices Communications Design patterns
79 Service Registry Pattern – Microservices Communications Design patterns
80 DESIGN – Service Aggregator Pattern – Service Registry Pattern in Microservices
81 Technology Choices – Adapting Technology Stack
Microservices Asynchronous Message-Based Communication
82 Introduction
83 Asynchronous Message-Based Communication in Microservices Architecture
84 Design Principles – Dependency Inversion Principles (DIP)
85 Design Pattern – Publish–Subscribe Design Pattern
86 DESIGN – Pub Sub Message Broker – Microservices Asynchronous Communications
87 Technology Choices – Adapting Technology Stack
Kafka and RabbitMQ Architecture
88 Introduction – What is Apache Kafka
89 Apache Kafka Benefits and Use Cases
90 Kafka Components – Topic, Partitions, Offset and Replication Factor
91 Apache Kafka Cluster Architecture
92 Apache Kafka Core APIs – Producer, Consumer, Streams and Connect API
93 What is RabbitMQ, Main Components of RabbitMQ
94 RabbitMQ Exchange Types
95 RabbitMQ Architecture
Scale the Microservices Architecture Design
96 Introduction – Scale the Microservices Architecture Design
97 The Scale Cube
98 Stateless and Stateful Application Horizontal Scaling
Microservices Data Management
99 Introduction – Polyglot Persistence Microservices
100 Microservices Database Management Patterns and Principles
101 The Database-per-Service Pattern
102 The Shared Database Anti-Pattern and Polyglot Persistence
103 Relational and NoSQL Databases – Document, Key-value, Graph-based, Column-based
104 How to Choose a Database for Microservices
105 CAP Theorem
106 Horizontal, Vertical, and Functional Data Partitioning
107 Database Sharding Pattern
108 Cassandra No-Sql Database – Peer-to-Peer Distributed Wide Column Database
109 Design the Architecture – Database Sharding Cassandra
Microservices Data Management – Queries
110 Introduction – Microservices Data Management – Cross-Service Queries
111 Materialized View Pattern
112 CQRS Design Pattern
113 CQRS Design Pattern – 2
114 Event Sourcing Pattern
115 Eventual Consistency Principle
116 Instagram System Architecture – Instagram Story View and User Information
117 Instagram Database Architecture
118 Design the Architecture – CQRS, Event Sourcing, Eventual Consistency
Microservices Distributed Transactions
119 Introduction – Microservices Distributed Transactions
120 Saga Pattern for Distributed Transactions
121 Saga Pattern – Choreography and Orchestration
122 The Outbox Pattern
Event-Driven Microservices Architecture
123 Introduction – Event-Driven Microservices Architecture
124 Design the Architecture – Event-Driven Microservices Architecture
Microservices Distributed Caching
125 Introduction – Microservices Distributed Caching
126 Design the Architecture – Microservices Distributed Caching
Microservices Deployments with Containers and Orchestrators
127 Microservices Deployments with Containers and Orchestrators
128 What is Docker and Container
129 Docker Containers, Images, and Registries
130 What is Kubernetes
131 Kubernetes Architecture
132 Kubernetes Components
133 Design the Architecture – Microservices Deployments Containers and Orchestrators
Implementation of Microservices Architecture
134 Implementation of Microservices Architecture
135 Code Review for Existing Microservices Architecture Repository on Github
Thanks
136 Thanks
Resolve the captcha to access the links!