Cloud Design Patterns with Microsoft Azure

=============================================

Christopher Fahey

Cache-Aside

Problem

Usually impractical to expect that cached data will always be completely consistent with the data in the data store.

Solution

Load data on demand into a cache from a data store.

Notes

• Develop so cache is as up to date as possible, detect when cache is stale.
• Make the modification to the data store, then invalidate the corresponding item in the cache.
• https://msdn.microsoft.com/en-us/library/dn589799.aspx

Circuit Breaker

Problem

In a distributed environment, unexpected events may cause resources to break and try to rectify themselves continously.

Solution

Quickly accept that the operation has failed and handle this failure accordingly (backoff logic or stop trying).

Notes

• Prevent an application repeatedly trying to execute an operation that is likely to fail.
• Can enable an application to detect whether the fault has been resolved.
• https://msdn.microsoft.com/en-us/library/dn589784.aspx

Compensating Transaction

Problem

Data may be spread across an assortment of data sources held in a variety of geographic locations. Data store must be undone reliably.

Solution

Intelligent process that takes into account any work done by concurrent instances.

Notes

• Application should not attempt to provide strong transactional consistency. (ACID)
• Implement eventual consistency. (BASE)
• https://msdn.microsoft.com/en-us/library/dn589804.aspx

Competing Consumers

Problem

System may be overloaded by an influx of messages coming from the application.

Solution

System can run multiple instances of the consumer service. Coordinated effort so work isn't duplicated.

Notes

• Reduces bottlenecks.
• Dynamically increase or decrease the number of instances of the consumer service as the volume of messages fluctuates.
• https://msdn.microsoft.com/en-us/library/dn568101.aspx

Compute Resource Consolidation

Problem

Deploying lots of instances as part of the same application can increase runtime hosting costs and make management of the system more complex.

Solution

Consolidate multiple tasks or operations into a single computational unit. (Separation of Concerns anti-pattern).

Notes

• Look for tasks that have a similar profile concerning their scalability, lifetime, and processing requirement.
• Grouping items together allows them to scale as a unit.
• https://msdn.microsoft.com/en-us/library/dn589778.aspx

Command and Query Responsibility Segregation (CQRS)

Problem

Traditional CRUD designs work well when there is only limited business logic applied to the data operations.

Solution

Segregate operations that read(queries) and update(commands) data. Use Separate interfaces.

Notes

• Data models used for querying and updates are different.
• CQRS code cannot automatically be generated by using scaffold mechanisms.
• https://msdn.microsoft.com/en-us/library/dn568103.aspx

CQRS Separation

Event Sourcing

Problem

Data will be read, modified, and updated. Current state of the data with the new values may be locked by transactions.

Solution

Handle operations on data that is driven by a sequence of events, each of which is recorded in an append-only store.

Notes

• Append-only store to record the full series of events that describe actions taken.
• Data update conflicts are more likely to occur because the update operations take place on a single item of data.
• https://msdn.microsoft.com/en-us/library/dn589792.aspx

External Configuration Store

Problem

Changes to the configuration require the application to be redeployed, resulting in unacceptable downtime. Securing sensitive configurations.

Solution

Store the configuration information in external storage, and provide an interface that can be used to quickly and efficiently read and update configuration settings.

Notes

• Easier management and control of configuration data.
• Sharing between instances.
• https://msdn.microsoft.com/en-us/library/dn589803.aspx

Federated Identity

Problem

Users may be forced to use specific (and different) credentials for applications. Complicated user management.

Solution

Separating user authentication from the application code, and delegating authentication to a trusted identity provider.

Notes

• Trusted identity providers (IdP) include corporate directories, on-premises federation services and others.
• IdP issues security tokens that assert information about the authenticated user (claims).
• https://msdn.microsoft.com/en-us/library/dn589790.aspx

Gatekeeper

Problem

Code that accepts requests from clients, likely to accesses storage with sensitive information. If one host compromised, other areas may be impacted.

Solution

Decouple hosts or tasks that expose public endpoints from the code that processes requests and accesses storage.

Notes

• Dedicated instance that acts as a broker between clients.
• If the Gatekeeper is compromised, the attacker does not obtain access to other credentials or keys. (Firewall-like.)
• https://msdn.microsoft.com/en-us/library/dn589793.aspx

Health Endpoint Monitoring

Problem

You do not have full control of the hosting environment. Services typically depend on other services provided by platform others.

Solution

Implement health monitoring by sending requests to an endpoint. Do a check and then analysis of the result.

Notes

• Functional checks that external tools can access through exposed endpoints at regular intervals.
• Validating the response code, response time, expired SSL certificates, etc.
• https://msdn.microsoft.com/en-us/library/dn589789.aspx

Index Table

Problem

Application might not be able to use the primary key if it needs to retrieve data based on some other field.

Solution

Emulate secondary indexes by creating your own index(fact) tables. An index table organizes the data by a specified key.

Notes

• NoSQL data stores used by cloud applications do not provide secondary indexes.
• Improve query performance when an application frequently needs to retrieve data by using a key.
• https://msdn.microsoft.com/en-us/library/dn589791.aspx

Leader Election

Problem

Multiple instances of the same task could be running simultaneously with each instance servicing a different user, overwritting others work.

Solution

Instance is elected as leader. This instance should coordinate the actions of the other subordinate task instances.

Notes

• Ensures that task instances do not conflict with each other
• https://msdn.microsoft.com/en-us/library/dn568104.aspx

Materialized View

Problem

When aggregates are needed, extract all of the data for the relevant entities in order to obtain the required information.

Solution

Generate (in advanced) a view that materializes the data in a format most suited to the required results set

Notes

• Data is completely disposable because it can be entirely rebuilt from the source data stores.
• Automatically update on an appropriate schedule, or when the system detects a change to the original data.
• https://msdn.microsoft.com/en-us/library/dn589782.aspx

Pipes and Filters

Problem

Application requires many tasks of various complexities that is developed as a monolithic module. Limited code reuse.

Solution

Decompose the processing required for each stream into a set of discrete components (or filters), each of which performs a single task.

Notes

• Standardize the format of the data that each component receives and emits.
• Filters are combined into a pipeline.
• https://msdn.microsoft.com/en-us/library/dn568100.aspx

Priority Queue

Problem

Message queues are typically used to delegate tasks to background processing. Some tasks are more important than others.

Solution

Messages in the queue are automatically reordered so that messages with a higher priority will be received before those of a lower priority.

Notes

• Most message queue implementations support multiple consumers (Competing Consumers Pattern).
• Can also maintain a separate queue for each priority level.
• https://msdn.microsoft.com/en-us/library/dn589794.aspx

Queue-based Load Leveling

Problem

Difficult to predict the volume of requests to which the service might be subjected at any given point in time.

Solution

Introduce a queue between the task and the service as a buffer.

Notes

• Many solutions in the cloud involve running tasks that invoke services.
• Queue effectively decouples the tasks from the service.
• https://msdn.microsoft.com/en-us/library/dn589783.aspx

Retry

Problem

Temporary faults can occur in your own or others services and are not uncommon.

Solution

Application detects a failure when it attempts to send a request to a remote service, and trys again.

Notes

• Period between retries should be chosen as to spread requests evenly amount instances.
• Requests sent to different services can be subject to different policies and strategies.
• https://msdn.microsoft.com/en-us/library/dn589788.aspx

Runtime Reconfiguration

Problem

Necessary to reconfigure the application to change specific behavior or settings while it is deployed and in use.

Solution

Application code will respond to events that are raised by the hosting infrastructure when it detects a change to the application configuration.

Notes

• Depends on the features available in the application hosting environment.
• Consider how you will roll back configuration changes that cause issues.
• https://msdn.microsoft.com/en-us/library/dn589785.aspx

Scheduler Agent Supervisor

Problem

Perform tasks that comprise a number of steps, some of which may fail.

Solution

Restore the system to a consistent state and ensure integrity of the entire end-to-end operation.

Notes

• Scheduler: Arranges for the individual steps that comprise the overall task.
• Agent: Contains logic that makes calls to a remote service.
• Supervisor: Monitors the status of the steps in the task being performed by the Scheduler.
• https://msdn.microsoft.com/en-us/library/dn589780.aspx

Sharding

Problem

Data store hosted by a single server may be subject to limitations such as storage space, bandwidth, computing resources and location.

Solution

Divide the data store into horizontal partitions or shards. Each shard has the same schema, but holds its own distinct subset of the data.

Notes

• Scaling vertically may postpone the effects of some of these limitations.
• https://msdn.microsoft.com/en-us/library/dn589797.aspx

Static Content Hosting

Problem

App server must handle requests to download static content. This absorbs processing cycles that could often be put to better use.

Solution

Locate some of an application’s resources and static pages in a storage service. The cost for cloud-hosted storage is typically much less than for compute instances.

Notes

• Secure resources that are not intended to be available to anonymous users.
• https://msdn.microsoft.com/en-us/library/dn589776.aspx

Throttling

Problem

Load on a cloud application typically varies over time based on the number of active users or the types of activities they are performing.

Solution

System should monitor how it is using resources so that, when usage exceeds some system-defined threshold, it can throttle requests from one or more users to enable the system to continue functioning.

Notes

• The system may be obliged to meet an agreed level of service, and such failure could be unacceptable.
• https://msdn.microsoft.com/en-us/library/dn589798.aspx

Valet Key

Problem

Application will handle the movement of the data. This approach absorbs valuable resources such as compute, memory, and bandwidth.

Solution

Restrict access to the data store’s public connection and provide the client with a key or token that the data store itself can validate.

Notes

• Once the client has a connection to the data store for direct access, the application cannot act as the gatekeeper.
• https://msdn.microsoft.com/en-us/library/dn568102.aspx