Design Microservices Architecture With Patterns & Principles

Evolve from Monolithic to Event-driven Microservices Architecture with designing High Scalable and High Available system

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

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.

Who this course is for:
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