Azure Cloud Design Patterns

Azure Cloud Design Patterns

Let’s talk about Cloud Design Patterns.

We introduced the topic of design patterns in this previous post, then we discussed how design patterns apply specifically to the AWS cloud. Now we’ll talk about patterns as they apply to the Microsoft Azure Cloud.

Microsoft Azure –  being more focused on application development – provides for much more official and detailed Design Patterns than AWS. In fact, they dedicate an entire section on the subject on MSDN, from where you can download a 236-page book in PDF or ebook editions, or order a print version from Amazon. Sample code and an infographic depicting all the patterns are also available. The book contains 24 design patterns, 10 guidance topics, and 10 sample applications.

Problem Areas

The 24 design patterns are divided into 8 Problem Areas, each with its own symbol.

Availability
Data Management
Design and Implementation
Messaging
Management and Monitoring
Performance and Scalability
Resiliency
Security


The guide provides solutions to common problems encountered while developing cloud-based applications, describes the benefits derived from the application of patterns when implementing Azure-hosted cloud applications, and discusses the problems that affect the patterns, and how these relate to Azure. The book also shows us how to implement the patterns using the features and services of Microsoft Azure, and highlights their benefits.

Primer & Guidance Topics

The book also presents guidance topics. These, in fact, represent the basic orientation for developing applications in the cloud:

• Asynchronous Messaging Primer
• Autoscaling Guidance
• Caching Guidance
• Compute Partitioning Guidance
• Data Consistency Primer
• Data Partitioning Guidance
• Data Replication and Synchronization Guidance
• Instrumentation and Telemetry Guidance
• Multiple Datacenter Deployment Guidance
• Service Metering Guidance

Cloud Design Patterns

We come now to the core thematic list: Microsoft’s 24 patterns:

Static Content Hosting Pattern (example)	Circuit Breaker Pattern
Competing Consumers Pattern (example)	Index Table Pattern
Compute Resource Consolidation Pattern (example)	Event Sourcing Pattern
Command and Query Responsibility Segregation (CQRS) Pattern	Federated Identity Pattern
External Configuration Store Pattern (example)	Gatekeeper Pattern
Health Endpoint Monitoring Pattern (example)	Retry Pattern
Leader Election Pattern (example)	Materialized View Pattern
Compensating Transaction Pattern	Scheduler Agent Supervisor Pattern
Runtime Reconfiguration Pattern (example)	Sharding Pattern
Pipes and Filters Pattern (example)	Cache-aside Patter
Priority Queue Pattern (example)	Throttling Pattern
Queue-based Load Leveling Pattern	Valet Key Pattern (example)

For each pattern, the book provides a short description, some context and a problem along with its solution, issues and considerations, A use case, sample code with C #, and finally the patterns and related guidance.

Code Samples

All examples work with the Visual Studio Windows Azure emulator and can be deployed through the Windows Azure Cloud Service.

Let’s take the Static Content Hosting Pattern as an example. The pattern is part of these problem areas: Data Management, Design, and Implementation, Performance & Scalability. The book’s author writes:

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

While adding more detail concerning the context and problem:

Web applications typically include some elements of static content. This static content may include HTML pages and other resources such as images and documents that are available to the client, either as part of an HTML page (such as inline images, style sheets, and client-side JavaScript files) or as separate downloads (such as PDF documents).

Although web servers are well tuned to optimize requests through efficient dynamic page code execution and output caching, they must still handle requests to download static content. This absorbs processing cycles that could often be put to better use.

And the Solution gives us the guidelines to implement it:

In most cloud hosting environments, it is possible to minimize the requirement for compute instances (for example, to use a smaller instance or fewer instances), by locating some of an application’s resources and static pages in a storage service. The cost of cloud-hosted storage is typically much less than for compute instances.

When hosting some parts of an application in a storage service, the main considerations are related to the deployment of the application and to securing resources that are not intended to be available to anonymous users.

Therefore we see that the pattern improves the performance and scalability by moving the delivery of static content to Azure Blob Storage. The sample code simulates the solution of pattern also giving us useful snippet of Azure code.

Conclusion

As you can see, Cloud Design Patterns for Azure is rich in useful content. In particular, I highly recommend a quick read of Autoscaling Guidance.

Next, we’ll explore two websites that also discuss Cloud Design Patterns in more general terms.