Design Microservices Architecture with Patterns Principles

Evolve from Monolithic to Event-driven Microservices Architecture with designing High Scalable and High Available system
Design Microservices Architecture with Patterns Principles
File Size :
5.16 GB
Total length :
17h 22m

Category

Instructor

Mehmet Ozkaya

Language

Last update

4/2023

Ratings

4.5/5

Design Microservices Architecture with Patterns Principles

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 from Monolithic to Serverless Microservices
Step by step evolving architecture from Monolithic to Event-driven Microservices Architecture
Design E-commerce App with Monolithic – Layered – Clean – Modular Monolithic – Microservices – Event-Driven Architecture and Serverless Microservices
Microservices Decomposition Strategies
Microservices Communications (Sync / Async Message-Based Communication, API Gateways))
Microservices Data Management (Databases / Query / Commands / Distributed Transactions)
Microservices Distributed Transaction Management
Microservices Distributed Caching
Microservices Deployments with Containers and Orchestrators
Microservices Resilience, Observability, Monitoring
Microservices Design Patterns and Best Practices
The Database-per-Service Pattern, Polyglot Persistence and The Shared Database Anti-Pattern
API Gateway Pattern, Backends for Frontends Pattern-BFF, Gateway Routing/Aggregation/Offloading Pattern
Service Aggregator Pattern, Service Registry/Discovery Pattern
Materialized View Pattern, Database Sharding Pattern, CAP Theorem
Fan-out Publish/Subscribe Messaging Pattern, Topic-Queue Chaining & Load Balancing Pattern
CQRS and Event Sourcing Patterns, Eventual Consistency Principle, CAP Theorem
SAGA Pattern — Choreography-based/Orchestration-based SAGA, Compensating Transaction Pattern
Transactional Outbox Pattern, Dual Write Problem
CDC — Change Data Capture with Outbox Pattern
Code Review for Existing Microservices Architecture Repository on GitHub
Event Hubs and Real-time Event Streaming in Event-Driven Microservices Architecture
Cache-Aside Pattern for Microservices Distributed Caching
Sidecar Pattern, Service Mesh Pattern
DevOps and CI/CD Pipelines for Microservices Deployments
Deployment Strategies for Microservices: Blue-green, Rolling and Canary deployments
Infrastructure as Code (IaC) and usage in Microservices Deployments
Microservices Resilience, Observability and Monitoring Patterns
Retry and Circuit Breaker Patterns
Bulkhead / Timeout / Cache / Fallback Patterns
Elastic Stack for Microservices Observability with Distributed Logging
Microservices Health Checks: Liveness, Readiness and Performance Checks
Serverless Microservices Architecture implementation on AWS
Hands-on Design Activities, Iterate Design Architecture from On-Premises to Cloud Serverless architectures
Refactoring System Design for handling million of requests
Prepare for Software Architecture Interviews
Prepare for System Design Architecture Interviews

Design Microservices Architecture with Patterns Principles

Requirements

Software Architecture Basics

Description

In this course, we’re going to learn how to Design Microservices Architecture with using Design Patterns, Principles and the Best Practices with Iterate Design Architecture from Monolithic to Microservices. 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 from 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 ArchitectureClean ArchitectureModular Monolithic ArchitectureMicroservicesEvent-Driven Microservices Architecturesand lastly Serverless Microservices Architectures with designing together that handle millions of requests. This is a step-by-step process for software system design and evolve from monolithic to microservices following the patterns & principles.We will discuss microservices architectures with all aspects, Microservices DecompositionMicroservices Communications (Sync / Async Message-Based Communication, API Gateways)Microservices Data Management (Databases / Query / Commands)Microservices Transaction ManagementMicroservices Distributed CachingMicroservices Deployments with Containers and OrchestratorsMicroservices Resiliencewith applying microservices design patterns and practices.We are going to design with together and step by step with refactor architectures with all aspects of microservices pillars.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.Way of Learning — The Course FlowWe will always starts with the problem and try to solve this problem with learning and designing new architectures, patterns and best practices.Problem -> Learn -> Design -> Adapt -> EvaluateWe will complete this circle for every section of the course. 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.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.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 course;The Database-per-Service PatternAPI Gateway Pattern, Gateway Routing/Aggregation/Offloading PatternBackends for Frontends pattern BFFService Aggregator Pattern, Service Registry/Discovery PatternFan-out Publish/Subscribe Messaging PatternTopic-Queue Chaining & Load Balancing PatternThe Shared Database Anti-Pattern and Polyglot PersistenceDatabase Sharding Pattern, CAP TheoremMaterialized View PatternCQRS and Event Sourcing PatternsSAGA Pattern — Choreography-based/Orchestration-based SAGACompensating Transaction PatternTransactional Outbox PatternDual Write ProblemCDC — Change Data Capture with Outbox PatternEvent Hubs and Real-time Event Streaming in Event-Driven Microservices ArchitectureCache-Aside Pattern for Microservices Distributed CachingSidecar PatternService Mesh PatternDevOps and CI/CD Pipelines for Microservices DeploymentsDeployment Strategies for Microservices: Blue-green, Rolling and Canary deploymentsInfrastructure as Code (IaC) and usage in Microservices DeploymentsMicroservices Resilience, Observability and Monitoring PatternsRetry and Circuit Breaker PatternsBulkhead / Timeout / Cache / Fallback PatternsElastic Stack for Microservices Observability with Distributed LoggingMicroservices Health Checks: Liveness, Readiness and Performance ChecksServerless Microservices Architecture implementation on AWSSo the course flow will be the both theoretical and practical information;We will always start with a business problemWe will learn a specific pattern, why and where we should useAfter that we will see the Reference architectures that applied these patternsAfter that we will design our architecture with applying this newly learned pattern with togetherAnd 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 ActivitiesIterate Design Architecture from On-Premises to Cloud Server-less architecturesEvolves architecture monolithic to Event-Driven Microservices ArchitecturesRefactoring System Design for handling million of requestsApply best practices with microservices design patterns and principlesExamine microservices patterns with all aspects like Communications, Data Management, Caching and DeploymentsPrepare for Software Architecture InterviewsPrepare 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.I hope you’ll join me on this journey and develop this project with me.

Overview

Section 1: Course Introduction

Lecture 1 Introduction

Lecture 2 Architecture Design Journey – Evolution of Architectures

Lecture 3 Way of Learning – The Course Flow

Lecture 4 Choosing the Right Architecture for your Application

Lecture 5 How to Follow the Course & Course Slides

Section 2: Understand E-Commerce Domain

Lecture 6 First Problem: Sell Products Online

Lecture 7 Understand E-Commerce Domain – Use Cases – Functional Requirement

Lecture 8 Understand E-Commerce Domain – Non-Functional Requirements

Section 3: Monolithic Architecture

Lecture 9 Introduction – Monolithic Architecture

Lecture 10 When to use Monolithic Architecture

Lecture 11 Benefits of Monolithic Architecture

Lecture 12 Challenges of Monolithic Architecture

Lecture 13 Design principles of Monolithic Architecture — KISS, YAGNI, DRY

Lecture 14 Design the Architecture – E-Commerce App – KISS & YAGNI

Lecture 15 Design & Iterate : Monolithic Architecture – E-Commerce Application

Lecture 16 Evaluate : Monolithic Architecture – E-Commerce Application

Lecture 17 Problem: Code Become Too Complex over time – Monolithic Architecture -E-Commerce

Section 4: Layered (N-Layer) Architecture

Lecture 18 Layered (N-Layer) Architecture

Lecture 19 Design principles – Separation of Concerns (SoC)

Lecture 20 Design principles – SOLID

Lecture 21 Design the Architecture – E-Commerce App – Layered Architecture

Lecture 22 Adapt Technology Stack – E-Commerce App – Layered Architecture

Lecture 23 DEMO: Layered Monolithic Architecture Code Review – E-Commerce App

Lecture 24 Evaluate: Layered Monolithic Architecture

Lecture 25 Problem: Highly Coupling Dependent Layers

Section 5: Clean Architecture

Lecture 26 Introduction the Clean Architecture

Lecture 27 What is Clean Architecture

Lecture 28 The Dependency Rule

Lecture 29 Layers of Clean Architecture

Lecture 30 Benefits of Clean Architecture

Lecture 31 Design the Architecture – Clean Architecture – E-Commerce App

Lecture 32 Adapt: Clean Architecture – E-Commerce App

Lecture 33 DEMO: Clean Architecture Code Review – E-Commerce App

Lecture 34 Evaluate: Clean Architecture

Lecture 35 Problem: Increased Traffic, Handle More Request

Section 6: Scalability – Vertical Scaling – Horizontal Scaling

Lecture 36 Introduction Scalability – Why need to Scale ?

Lecture 37 Scalability – Vertical Scaling – Horizontal Scaling

Lecture 38 Vertical Scaling – Scale up

Lecture 39 Horizontal Scaling – Scale out

Lecture 40 What is Load Balancer ? Use Load Balancer Split the Load with Consistent Hashing

Lecture 41 Design the Architecture – Scalability – E-Commerce App

Lecture 42 Adapt the Architecture – Scalability – Load Balancer – E-Commerce App

Lecture 43 Evaluate: Clean Architecture with Scalability – Load Balancer – E-Commerce App

Lecture 44 Problem: Agility of New Features, Split Agile Teams

Section 7: Modular Monolithic Architecture

Lecture 45 Introduction – Modular Monolithic Architecture

Lecture 46 What is Modular Monolithic Architecture ?

Lecture 47 Benefits of Modular Monolithic Architecture

Lecture 48 Challenges of Modular Monolithic Architecture

Lecture 49 When to use Modular Monolithic Architecture

Lecture 50 Monolith First Approaches from Martin Fowler and Sam Newman

Lecture 51 Monolithic Architecture Vertical Considerations, Communications of Monolithic

Lecture 52 Transaction Management of Monolithic Architecture

Lecture 53 Deployments of Monolithic Architecture

Lecture 54 Design the Architecture – Modular Monolithic Architecture – E-Commerce App

Lecture 55 Evaluate: Complexity of Presentation UI Operations- Modular Monolithic Architect

Lecture 56 Problem: Improved customer experience with Separated UI and Omnichannel

Lecture 57 Headless Architecture and Separated Presentation with SPA

Lecture 58 Design the Architecture – Modular Monolithic Architecture with SPA -Separated UI

Lecture 59 Adapt the Architecture – Modular Monolithic Architecture with SPA – Separated UI

Lecture 60 DEMO: Modular Monolithic Architecture Code Review – E-Commerce App

Lecture 61 Evaluate: Modular Monolithic Architecture with SPA

Lecture 62 Problem: Agility of New Features, Split Agile Teams

Section 8: Microservices Architecture

Lecture 63 Introduction – Microservices Architecture

Lecture 64 What are Microservices ?

Lecture 65 What is Microservices Architecture ?

Lecture 66 Microservices Characteristics

Lecture 67 Benefits of Microservices Architecture

Lecture 68 Challenges of Microservices Architecture

Lecture 69 When to Use Microservices Architecture – Best Practices

Lecture 70 When Not to Use Microservices – Anti-Patterns of Microservices

Lecture 71 Monolithic vs Microservices Architecture Comparison

Lecture 72 The Database-per-Service Pattern – Polyglot Persistence

Lecture 73 Design the Architecture – Microservices Architecture – First Iteration

Lecture 74 Adapt the Architecture – Microservices Architecture – First Iteration

Lecture 75 Evaluate: Microservices Architecture – First Iteration

Lecture 76 Problem: Break Down Application into Microservices

Section 9: Decomposition of Microservices Architecture

Lecture 77 Introduction – Decomposition of Microservices Architecture

Lecture 78 Why we need to Decompose ? – The Scale Cube

Lecture 79 Microservices Decomposition Pattern – Decompose by Business Capability

Lecture 80 Microservices Decomposition Pattern – Decompose by Subdomain

Lecture 81 Bounded Context Pattern (Domain-Driven Design – DDD)

Lecture 82 Identify Bounded Context Boundaries for Each Microservices

Lecture 83 Using Domain Analysis to Model Microservices and Checklist After Decomposition

Lecture 84 Analysis E-Commerce Domain – Use Cases

Lecture 85 Analysis E-Commerce Domain – Nouns and Verbs

Lecture 86 Identifying and Decomposing Microservices for E-Commerce Domain

Lecture 87 Design & Adapt: Microservices Architecture with Decomposition Patterns

Lecture 88 Evaluate & Problem : Microservices Architecture and Client-Service Communication

Section 10: Microservices Communications – The Basics

Lecture 89 Introduction – Microservices Communications – The Basics

Lecture 90 What is Changed for Communications Between Monolithic to Microservices

Lecture 91 Microservices Communication Types – Synchronous or Asynchronous Communication

Lecture 92 Microservices Communication Styles: Request-Driven or Event-Driven Architecture

Lecture 93 Microservices Synchronous Communications and Best Practices

Lecture 94 Designing HTTP based RESTful APIs for Microservices

Lecture 95 RESTful API design for Microservices

Lecture 96 RESTful API design for Single Microservices

Lecture 97 RESTful API design for E-Commerce Microservices

Lecture 98 API versioning in Microservices RESTful APIs

Lecture 99 Design: Microservices Architecture with RESTful API design

Lecture 100 Evaluate: Microservices Architecture with RESTful API design

Lecture 101 Problem: Multiple Request (N+1) for Retrieving Relational Data

Lecture 102 GraphQL: A query language for APIs

Lecture 103 GraphQL Core Concepts: Schemas, Queries, Mutations and Resolvers

Lecture 104 Advantages and disadvantages of GraphQL

Lecture 105 REST vs GraphQL APIs

Lecture 106 Fetching data with REST and GraphQL

Lecture 107 Design & Evaluate: Microservices Architecture with GraphQL API design

Lecture 108 Problem: Inter-service communication makes heavy load on network traffic

Lecture 109 gRPC: High Performance Remote Procedure Calls

Lecture 110 How gRPC works ?

Lecture 111 Main Advantages of gRPC

Lecture 112 When to use gRPC ? Use Cases of gRPC

Lecture 113 gRPC Usage in Microservices Communication

Lecture 114 Design & Evaluate: Microservices Architecture with gRPC API design

Lecture 115 Problem: Chat with Support Agent to answer Customer queries

Lecture 116 WebSocket API: Real-time two-way communications

Lecture 117 When to use WebSocket API and Uses Cases of WebSocket API

Lecture 118 Design & Evaluate: Microservices Architecture with WebSocket API Design

Lecture 119 Problem: Direct Client-to-Service Communication

Section 11: Microservices Communication Patterns – API Gateways

Lecture 120 Introduction: Microservices Communication Patterns – API Gateways

Lecture 121 Problems of Direct-to-Microservices Communication

Lecture 122 Why should we use API Gateway ?

Lecture 123 The Solution – API Gateway Patterns

Lecture 124 Gateway Routing pattern

Lecture 125 Gateway Aggregation Pattern

Lecture 126 Gateway Offloading Pattern

Lecture 127 API Gateway Pattern

Lecture 128 Main Features of API Gateway Pattern

Lecture 129 A Request Flow of API Gateway Pattern

Lecture 130 Design & Evaluate: Microservices Architecture with API Gateway Design

Lecture 131 Problem: Client Apps has Different UI Requirements

Lecture 132 Backends for Frontends Pattern-BFF

Lecture 133 Design & Evaluate: Microservices Architecture with Backends for Frontend Pattern

Lecture 134 Service-to-Service Communications between Backend Internal Microservices

Lecture 135 Service-to-Service Communications Chain Queries

Lecture 136 Problem: Service-to-Service Communications Chain Queries

Lecture 137 Service Aggregator Pattern – Microservices Communications Design patterns

Lecture 138 Service Registry/Discovery Pattern – Microservices Communications Design pattern

Lecture 139 Design & Evaluate: Microservices Architecture with Service Aggregator, Registry

Lecture 140 Adapt the Architecture – Microservices Architecture – Second Iteration

Lecture 141 Problem: Long Running Operations Can’t Handle with Sync Communication

Section 12: Microservices Asynchronous Message-Based Communication

Lecture 142 Introduction – Microservices Asynchronous Message-Based Communication

Lecture 143 Microservices Asynchronous Communication

Lecture 144 Benefits of Asynchronous Communication

Lecture 145 Challenges of Asynchronous Communication

Lecture 146 Asynchronous Message-Based Communication Types in Microservices Architecture

Lecture 147 Single-receiver Message-based Communication (one-to-one model-queue)

Lecture 148 Multiple-receiver Message-based Communication (one-to-many model-topic)

Lecture 149 Design Principles – Dependency Inversion Principles (DIP)

Lecture 150 Fan-Out Publish/Subscribe Messaging Pattern

Lecture 151 Topic-Queue Chaining & Load Balancing Pattern

Lecture 152 Design: Microservices Architecture with Fan-Out Publish/Subscribe Messaging

Lecture 153 Adapt: Microservices Architecture with Fan-Out Publish/Subscribe Messaging

Lecture 154 Evaluate: Microservices Architecture with Fan-Out Publish/Subscribe Messaging

Lecture 155 Problem: Databases Create Bottlenecks When Scaling

Section 13: [OPTIONAL] Kafka and RabbitMQ Architectures

Lecture 156 What is Apache Kafka ?

Lecture 157 Apache Kafka Benefits

Lecture 158 Apache Kafka Use Cases

Lecture 159 Kafka Components – Topic, Partitions, Offset and Replication Factor

Lecture 160 Apache Kafka Cluster Architecture

Lecture 161 Apache Kafka Core APIs – Producer, Consumer, Streams and Connect API

Lecture 162 What is RabbitMQ ?

Lecture 163 RabbitMQ Components: Producer, Queue, Consumer, Message, Exchange, Binding

Lecture 164 RabbitMQ Exchange Types: Direct, Fanout, Topic, and Headers

Lecture 165 RabbitMQ Architecture

Section 14: Scale the Microservices Architecture Design

Lecture 166 Introduction – Scale the Microservices Architecture Design

Lecture 167 The Scale Cube

Lecture 168 Stateless and Stateful Application Horizontal Scaling

Section 15: Microservices Data Management – Choosing Right Database

Lecture 169 Introduction – Microservices Data Management

Lecture 170 Polyglot Persistence Principle in Microservices

Lecture 171 Microservices Database Management Patterns and Principles

Lecture 172 Design Patterns – The Database-per-Service Pattern

Lecture 173 The Shared Database Anti-Pattern and Polyglot Persistence

Lecture 174 Relational and NoSQL Databases – Document, Key-value, Graph-based, Column-based

Lecture 175 NoSQL Databases Types – Document, Key-value, Graph-based, Column-based Databases

Lecture 176 When to Use Relational Databases ?

Lecture 177 When to Use No-SQL Databases ?

Lecture 178 Best Practices When Choosing Data Store – Use Right Tool for Right Job

Lecture 179 How to Choose a Database for Microservices

Lecture 180 CAP Theorem

Lecture 181 Problem: Single Database Server Performs Low Performance

Lecture 182 What is Data Partitioning ? and Why we are using Data Partitioning ?

Lecture 183 Data Partitioning: Horizontal, Vertical and Functional Data Partitioning

Lecture 184 Database Sharding Pattern

Lecture 185 Tinder System Design Example of Database Sharding Pattern

Lecture 186 Cassandra No-Sql Database – Peer-to-Peer Distributed Wide Column Database

Lecture 187 Design: Microservices Architecture with Database Sharding Pattern

Lecture 188 Adapt: Microservices Architecture with Database Sharding Pattern – Cassandra

Lecture 189 Evaluate: Microservices Architecture with Database Sharding Pattern – Cassandra

Lecture 190 Problem: Cross-Service Queries and Write Commands on Distributed Scaled Database

Section 16: Microservices Data Management – Commands and Queries

Lecture 191 Introduction – Microservices Data Management – Commands and Queries

Lecture 192 Microservices Data Management – Cross-Service Queries

Lecture 193 Problem: Cross-Service Queries with Sync Response, Decouple Way and Low Latency

Lecture 194 Materialized View Pattern

Lecture 195 CQRS — Command Query Responsibility Segregation Pattern

Lecture 196 CQRS — Benefits and Drawbacks

Lecture 197 Best Practices for CQRS and Instagram Database Architecture with CQRS

Lecture 198 How to Sync Read and Write Databases in CQRS ?

Lecture 199 Event Sourcing Pattern

Lecture 200 CQRS with Event Sourcing Pattern

Lecture 201 Eventual Consistency Principle

Lecture 202 Design: Instagram System Architecture

Lecture 203 Design: Instagram Database Architecture

Lecture 204 Design: Microservices Architecture with CQRS, Event Sourcing,Eventual Consistent

Lecture 205 Adapt: Microservices Architecture with CQRS, Event Sourcing, Eventual Consistent

Lecture 206 Evaluate: Microservices Architecture with CQRS, Event Sourcing, Eventual Consist

Lecture 207 Problem: Manage Consistency Across Microservices in Distributed Transactions

Section 17: Microservices Distributed Transactions

Lecture 208 Introduction – Microservices Distributed Transactions

Lecture 209 Transaction Fundamentals and ACID Principles

Lecture 210 Transaction Management of Monolithic Architecture

Lecture 211 Microservices Distributed Transactions

Lecture 212 Microservices Bounded Context for Transactional Boundaries

Lecture 213 Microservices Transactional Boundaries

Lecture 214 SAGA Pattern for Distributed Transactions

Lecture 215 SAGA Pattern – Choreography-based SAGA Implementation

Lecture 216 SAGA Pattern – Orchestration-based SAGA Implementation

Lecture 217 Compensating Transaction Pattern

Lecture 218 Problem: Dual Write Problem

Lecture 219 Transactional Outbox Pattern

Lecture 220 Transactional Outbox Pattern in Microservices

Lecture 221 Problem: Listen and Polling Outbox Table

Lecture 222 What is CDC – Change Data Capture ?

Lecture 223 CDC – Change Data Capture with Outbox Pattern

Lecture 224 Implementation of CDC and Outbox Pattern with Cloud Databases – CockroachDB

Lecture 225 Implementation of CDC and Outbox Pattern with Cloud Databases: Azure CosmosDB

Lecture 226 Design: Microservices Architecture with SAGA, Outbox Pattern and CDC

Lecture 227 Adapt: Microservice Architecture with SAGA, Transactional Outbox and CDC Pattern

Lecture 228 Evaluate: Microservices Architecture with SAGA, Transactional Outbox and CDC

Lecture 229 Problem: Handle Millions of Events Across Microservices

Section 18: Event-Driven Microservices Architectures

Lecture 230 Introduction – Event-Driven Microservices Architectures

Lecture 231 Event-Driven Microservices Architecture

Lecture 232 Real-time Processing and High Volume Events in Event-Driven Microservices

Lecture 233 Event Hubs and Event Streaming in Event-Driven Microservices Architecture

Lecture 234 Real-world Examples of Event-Driven Microservices Architecture

Lecture 235 Design: Event-Driven Microservices Architecture

Lecture 236 Adapt: Event-Driven Microservices Architecture

Lecture 237 Evaluate: Event-Driven Microservices Architecture

Lecture 238 Problem: Database operations are expensive, low performance

Section 19: Microservices Distributed Caching

Lecture 239 Introduction – Microservices Distributed Caching

Lecture 240 What is Caching ?

Lecture 241 Types of Caching

Lecture 242 Distributed Caching in Microservices

Lecture 243 Cache Hit and Cache Miss

Lecture 244 Caching Strategies in Distributed Caching for Microservices

Lecture 245 Cache-Aside Pattern for Microservices

Lecture 246 Design: Microservices Distributed Caching with Cache-Aside Pattern

Lecture 247 Adapt: Microservices Distributed Caching with Cache-Aside Pattern

Lecture 248 Evaluate: Microservices Distributed Caching with Cache-Aside Pattern

Lecture 249 Problem: Deploy Microservices at Anytime with Zero-downtime and flexible scale

Section 20: Microservices Deployments with Containers and Orchestrators

Lecture 250 Introduction – Microservices Deployments with Containers and Orchestrators

Lecture 251 What are Containers ?

Lecture 252 What is Docker ?

Lecture 253 Docker Containers, Images, and Registries

Lecture 254 Why we use them for microservices deployments ?

Lecture 255 What are Container Orchestrators ?

Lecture 256 What is Kubernetes and why we use them for microservices deployments ?

Lecture 257 Kubernetes Architecture

Lecture 258 Kubernetes Components

Lecture 259 Helm Charts with Kubernetes for Microservices Deployments

Lecture 260 Sidecar Pattern and How Does the Sidecar Pattern Work for Microservices Deploy

Lecture 261 Service Mesh Pattern and How Does the Service Mesh Pattern Work for Microservice

Lecture 262 Devops and CI/CD Pipelines for Microservices Deployments

Lecture 263 CI/CD Pipeline Steps for Microservices Deployments

Lecture 264 CI/CD Tools for Microservices Deployments

Lecture 265 Deployment Strategies for Microservices: Blue-green, rolling and canary deploy

Lecture 266 Infrastructure as Code (IaC) and usage in Microservices Deployments

Lecture 267 Design: Microservices Deployments with Containers and Orchestrators

Lecture 268 Adapt: Microservices using Containers and Orchestrators

Lecture 269 Evaluate: Microservices with using Containers and Orchestrators

Lecture 270 Problem: Fault tolerance Microservices able to remains operational for any fail

Section 21: Microservices Resilience, Observability and Monitoring

Lecture 271 Introduction – Microservices Resilience, Observability and Monitoring

Lecture 272 What is Microservices Resiliency

Lecture 273 Microservices Resiliency Patterns

Lecture 274 Retry Pattern

Lecture 275 Circuit Breaker Pattern

Lecture 276 Circuit Breaker States

Lecture 277 Retry + Circuit Breaker Pattern

Lecture 278 Bulkhead Pattern

Lecture 279 Timeout Pattern

Lecture 280 Fallback Pattern

Lecture 281 Microservices Observability with Distributed Logging and Distributed Tracing

Lecture 282 Elastic Stack for Microservices Observability with Distributed Logging

Lecture 283 Microservices Distributed Tracing with OpenTelemetry using Zipkin

Lecture 284 Microservices Health Checks: Liveness, Readiness and Performance Checks

Lecture 285 Microservices Health Monitoring with Kubernetes, Prometheus and Grafana

Lecture 286 Design: Microservices Resilience, Observability and Monitoring

Lecture 287 Adapt: Microservices Resilience, Observability and Monitoring

Section 22: DEMO: E-commerce Implementation of Microservices Architecture

Lecture 288 Implementation of Microservices Architecture

Lecture 289 DEMO: Microservices Architecture Code Review – E-Commerce App

Lecture 290 Catalog Microservices Code Review – E-Commerce App

Lecture 291 Basket Microservices Code Review – E-Commerce App

Lecture 292 Discount Microservices Code Review – E-Commerce App

Lecture 293 Ordering Microservices Code Review – E-Commerce App

Lecture 294 API Gateways Microservices Code Review – E-Commerce App

Lecture 295 Client Applications Code Review – E-Commerce App

Lecture 296 Microservices Resilience, Observability, Monitoring Code Review – E-Commerce App

Section 23: Serverless Microservices Architecture

Lecture 297 Introduction – Serverless Microservices

Lecture 298 AWS Serverless Microservices with Patterns & Best Practices

Lecture 299 AWS Lambda as a Microservice

Lecture 300 Mapping Microservice Architecture with AWS Serverless Services for Microservice

Lecture 301 Event-driven Serverless Microservices Design with AWS Lambda

Section 24: Thanks

Lecture 302 Thanks

Lecture 303 Bonus Lecture

Who wants to be Software Architecture,Who wants to deeply understand Microservices Architecture in Real-world cases,Who wants to pass System Design Architecture Interview

Course Information:

Udemy | English | 17h 22m | 5.16 GB
Created by: Mehmet Ozkaya

You Can See More Courses in the IT & Software >> Greetings from CourseDown.com

New Courses

Scroll to Top