Architectural Patterns to Learn

Resiliency & Fault Isolation

• Retry
  Automatically re-invoke transient-failure operations (e.g., HTTP calls, database commands) with exponential back-off. Azure SDKs (Storage, SQL, Service Bus, Cosmos DB) all offer built-in retry policies.

• Circuit Breaker
  Prevent a cascade of failures by “tripping” after a threshold of consecutive errors, built into Azure Application Gateway’s health probes or via Polly in your .NET code.

• Bulkhead
  Partition resources (e.g., App Service slots, Kubernetes pods) into isolated pools so one workload can’t exhaust all capacity. Azure Load Balancer and AKS node pools let you segment traffic.

---

2. Scalability & Load Leveling

• Queue-Based Load Leveling
  Decouple producers from consumers with Azure Queue Storage, Service Bus Queues, or Event Hubs. Spikes are smoothed by processing messages at your own pace.

• Competing Consumers
  Scale out processing by having multiple workers pull from the same queue/topic—e.g., Azure Functions with a Service Bus trigger.

• Cache-Aside
  Load-on-demand caching with Azure Cache for Redis to reduce database hits and improve read latency.

---

3. Data Management & Consistency

• CQRS (Command-Query Responsibility Segregation)
  Separate read and write models—e.g., writes are sent to Cosmos DB or SQL, while reads are served from a Materialized View via Azure Synapse.

• Event Sourcing
  Persist every state change as an append-only event stream, stored in Event Hubs or Cosmos DB’s change feed. Enables full audit trail and temporal queries.

• Saga (Compensating Transaction)
  Coordinate distributed transactions across microservices—Azure Logic Apps or Durable Functions can orchestrate or choreograph these compensating steps.

---

4. Integration & Messaging

• Publisher/Subscriber
  Broadcast events to multiple subscribers with Azure Event Grid or Service Bus Topics—loosely coupled producers and consumers.

• Claim Check
  Store large payloads in Blob Storage and pass only a lightweight reference through Service Bus or Event Grid to avoid message-size limits.

• Asynchronous Request-Reply
  Combine a request queue with a reply queue (or a callback URL) so that front-end processes stay responsive while back-end processing proceeds. Azure Functions and Service Bus are a common combination.

5. API Composition & Microservices

• Backends for Frontends (BFF)
  Define tailored APIs for each client (web, mobile, IoT) using Azure API Management to orchestrate multiple microservice calls.

• Gateway Aggregation / Routing / Offloading
  Use APIM or Azure Front Door as a single entry point—offloading SSL, routing, and caching—before traffic reaches microservices.

• Sidecar / Ambassador
  Deploy helper components (e.g., logging, service-mesh proxy) alongside your service container in AKS or Service Fabric.

6. Cloud Design Patterns

• External Configuration Store
  Keep configuration separate from code by storing app settings, feature flags, secrets, and other configuration elements in Azure App Configuration or Azure Key Vault. This allows you to change behavior without redeployment.

• External Dependency Configuration
  Model external services (databases, queues, third-party APIs) as configurable endpoints, so you can swap or mock them at runtime (e.g., via Azure App Configuration).

• Health Endpoint Monitoring
  Expose a /health (or similar) HTTP endpoint that reports liveness and readiness. Azure App Service and AKS probes can use this to detect and replace unhealthy instances.

• Policy Enforcement
  Centralize cross-cutting rules—like authorization, throttling, and input validation—at the API gateway layer (Azure API Management or Azure Front Door) rather than in each microservice.

• Telemetry
  Instrument your services to emit logs, metrics, and traces (via Azure Application Insights) so you can monitor performance, detect anomalies, and diagnose issues in production.

• Anti-Corruption Layer
  Introduce a façade or translation layer between your domain model and any legacy or external systems to prevent undesirable dependencies or model corruption.

• Strangler Fig
  Migrate or refactor a monolith by incrementally replacing functionality behind a façade: new requests go to microservices while old behavior remains until fully retired.

• Sidecar
  Package helper components—such as logging agents, service-mesh proxies, or configuration updates—as a separate container or process alongside your main service (e.g., in AKS or Service Fabric).

• Ambassador
  Deploy a proxy as a side-by-side helper that mediates communication between your service and the outside world (for caching, protocol translation, or routing).

• Scheduler Agent Supervisor
  Run background tasks—such as batch jobs, cron-style maintenance, or long-running workflows—using Azure Functions Timer triggers or Azure Batch, and supervise them for failures and retries.

---

How to apply these:

1. Identify your pain points (legacy coupling, config sprawl, monitoring blind spots).

2. Select the minimal pattern(s) that address each gap.

3. Leverage Azure services (App Configuration, Key Vault, App Insights, API Management, Functions, etc.) to implement them with minimal custom code.

Together with the previously listed service-level patterns (Resiliency, Scalability, Data, Integration, API Composition), these Cloud Design Patterns round out a robust, maintainable, and well-architected solution on Azure.

For details, go to https://learn.microsoft.com.