Cloud Design Patterns

I wanted to study a huge list of patterns since 6 months ago, but I had not enough time, so now I decided to move forward by sharing this list of cloud design patterns with whoever wants to learn from them.

Here the entire list:
Azure Design patterns
01 - Ambassador (Design and implementation)
Create helper services that send network requests on behalf of a consumer service or application.
02 - Anti-Corruption Layer (Design and implementation)
Implement a façade or adapter layer between a modern application and a legacy system.
03 - Asynchronous Request-Reply **(Messaging)
Decouple backend processing from a frontend host, where backend processing needs to be asynchronous, but the frontend still needs a clear response.
**04 - Backends for Frontends (Design and implementation)
Create separate backend services to be consumed by specific frontend applications or interfaces.
05 - Bulkhead
Isolate elements of an application into pools so that if one fails, the others will continue to function.
06 - Cache-Aside **(Data Management)
Load data on demand into a cache from a data store
**07 - Choreography (Messaging)
Let each service decide when and how a business operation is processed, instead of depending on a central orchestrator.
08 - Circuit Breaker
Handle faults that might take a variable amount of time to fix when connecting to a remote service or resource.
09 - Claim Check (Messaging)
Split a large message into a claim check and a payload to avoid overwhelming a message bus.
10 - Compensating Transaction
Undo the work performed by a series of steps, which together define an eventually consistent operation.
11 - Competing Consumers (Messaging)
Enable multiple concurrent consumers to process messages received on the same messaging channel.
12 - Compute Resource Consolidation (Design and implementation)
Consolidate multiple tasks or operations into a single computational unit
13 - CQRS **(Data Management) & (Design and implementation)
Segregate operations that read data from operations that update data by using separate interfaces.
**14 - Deployment Stamps
Deploy multiple independent copies of application components, including data stores.
15 - Edge Workload Configuration (Design and implementation)
The great variety of systems and devices on the shop floor can make workload configuration a difficult problem.
16 - Event Sourcing (Data Management)
Use an append-only store to record the full series of events that describe actions taken on data in a domain.
17 - External Configuration Store (Design and implementation)
Move configuration information out of the application deployment package to a centralized location.
18 - Federated Identity
Delegate authentication to an external identity provider.
19 - Gatekeeper
Protect applications and services by using a dedicated host instance that acts as a broker between clients and the application or service, validates and sanitizes requests, and passes requests and data between them.
20 - Gateway Aggregation (Design and implementation)
Use a gateway to aggregate multiple individual requests into a single request.

21 - Gateway Offloading
Offload shared or specialized service functionality to a gateway proxy.
22 - Gateway Routing (Design and implementation)
Route requests to multiple services using a single endpoint.
** 23 - Geodes**
Deploy backend services into a set of geographical nodes, each of which can service any client request in any region.
** 24 - Health Endpoint Monitoring**
Implement functional checks in an application that external tools can access through exposed endpoints at regular intervals.
25 - Index Table (Data Management)
Create indexes over the fields in data stores that are frequently referenced by queries.
26 - Leader Election (Design and implementation)
Coordinate the actions performed by a collection of collaborating task instances in a distributed application by electing one instance as the leader that assumes responsibility for managing the other instances.
27 - Materialized View (Data Management)
Generate prepopulated views over the data in one or more data stores when the data isn't ideally formatted for required query operations.
28 - Pipes and Filters (Design and implementation) & (Messaging)
Break down a task that performs complex processing into a series of separate elements that can be reused.
29 - Priority Queue (Messaging)
Prioritize requests sent to services so that requests with a higher priority are received and processed more quickly than those with a lower priority.
30 - Publisher/Subscriber (Messaging)
Enable an application to announce events to multiple interested consumers asynchronously, without coupling the senders to the receivers.
31 - Queue-Based Load Leveling (Messaging)
Use a queue that acts as a buffer between a task and a service that it invokes in order to smooth intermittent heavy loads.
32 - Rate Limit Pattern
Limiting pattern to help you avoid or minimize throttling errors related to these throttling limits and to help you more accurately predict throughput.
** 33 - Retry**
Enable an application to handle anticipated, temporary failures when it tries to connect to a service or network resource by transparently retrying an operation that's previously failed.

34 - Saga **(Messaging)
Manage data consistency across microservices in distributed transaction scenarios. A saga is a sequence of transactions that updates each service and publishes a message or event to trigger the next transaction step.

**35 - Scheduler Agent Supervisor (Messaging)
Coordinate a set of actions across a distributed set of services and other remote resources.
36 - Sequential Convoy (Messaging)
Process a set of related messages in a defined order, without blocking processing of other groups of messages.

37 - Sharding (Data Management)
Divide a data store into a set of horizontal partitions or shards.

** 38 - Sidecar** (Design and implementation)
Deploy components of an application into a separate process or container to provide isolation and encapsulation.

39 - Static Content Hosting (Data Management) & (Design and implementation)
Deploy static content to a cloud-based storage service that can deliver them directly to the client.
40 - Strangler Fig (Design and implementation)
Incrementally migrate a legacy system by gradually replacing specific pieces of functionality with new applications and services.
41 - Throttling
Control the consumption of resources used by an instance of an application, an individual tenant, or an entire service.
42 - Valet Key (Data Management)
Use a token or key that provides clients with restricted direct access to a specific resource or service.