Thursday, June 25, 2020

Quick Reference – Azure Design Patterns – Performance and Scalability patterns

Performance is an indication of the responsiveness of a system to execute any action within a given time interval, while scalability is the ability of a system either to handle increases in load without impact on performance or for the available resources to be readily increased. Cloud applications typically encounter variable workloads and peaks in activity.

Cache-Aside pattern

Load data on demand into a cache from a data store. This can improve performance and also helps to maintain consistency between data held in the cache and data in the underlying data store.

Using the Cache-Aside pattern to store data in the cache
Cache-Aside pattern Illustration

Command and Query Responsibility Segregation (CQRS) pattern

Segregate operations that read data from operations that update data by using separate interfaces. This can maximize performance, scalability, and security. Supports the evolution of the system over time through higher flexibility, and prevents update commands from causing merge conflicts at the domain level.

A basic CQRS architecture
CQRS Pattern Illustration

Event Sourcing pattern

Instead of storing just the current state of the data in a domain, use an append-only store to record the full series of actions taken on that data. The store acts as the system of record and can be used to materialize the domain objects. 

An overview and example of the Event Sourcing pattern
Event Sourcing pattern Illustration

Index Table pattern

Create indexes over the fields in data stores that are frequently referenced by queries. This pattern can improve query performance by allowing applications to more quickly locate the data to retrieve from a data store.

Figure 3 - Data is referenced by each index table
Index Table pattern Illustration

Materialized View pattern

Generate prepopulated views over the data in one or more data stores when the data isn’t ideally formatted for required query operations. This can help support efficient querying and data extraction, and improve application performance.

Figure 1 shows an example of how the Materialized View pattern might be used
Materialized View pattern Illustration

Priority Queue pattern

Prioritize requests sent to services so that requests with a higher priority are received and processed more quickly than those with a lower priority. This pattern is useful in applications that offer different service level guarantees to individual clients.

Figure 1 - Using a queuing mechanism that supports message prioritization
Priority Queue pattern Illustration

Queue-Based Load Leveling pattern

Use a queue that acts as a buffer between a task and a service it invokes in order to smooth intermittent heavy loads that can cause the service to fail or the task to time out. This can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service.

Figure 1 - Using a queue to level the load on a service
Queue-Based Load Leveling pattern Illustration

Sharding pattern

Divide a data store into a set of horizontal partitions or shards. This can improve scalability when storing and accessing large volumes of data.

Figure 1 - Sharding tenant data based on tenant IDs
Sharding pattern Illustration

Static Content Hosting pattern

Deploy static content to a cloud-based storage service that can deliver them directly to the client. This can reduce the need for potentially expensive compute instances.

Figure 1 - Delivering static parts of an application directly from a storage service
Static Content Hosting pattern Illustration

Throttling pattern

Control the consumption of resources used by an instance of an application, an individual tenant, or an entire service. This can allow the system to continue to function and meet service level agreements, even when an increase in demand places an extreme load on resources.

Figure 1 - Graph showing resource use against time for applications running on behalf of three users
Throttling pattern Illustration

References

  • https://docs.microsoft.com/en-us/azure/architecture/patterns/cache-aside
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/cqrs
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/index-table
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/materialized-view
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/priority-queue
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/sharding
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/static-content-hosting
  • https://docs.microsoft.com/en-us/azure/architecture/patterns/throttling
at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)