Cloud Design Patterns for Azure: Availability and Resilience

When building and designing applications for the cloud you need to overcome a lot of challenges. In this course, you'll learn the design patterns that will make your cloud applications resilient to failure, and keep them up and running.
Course info
Rating
(55)
Level
Intermediate
Updated
May 2, 2017
Duration
1h 57m
Table of contents
Description
Course info
Rating
(55)
Level
Intermediate
Updated
May 2, 2017
Duration
1h 57m
Description

When building and designing applications for the cloud you need to overcome a lot of challenges, such as performance, availability, data management, and resilience. In this course, Cloud Design Patterns for Azure: Availability and Resilience, you'll learn the design patterns that will make your cloud applications resilient to failure, and keep them up and running. First, you'll learn how to buffer workloads with the queue-based load leveling pattern. Next, you'll explore how to use the retry pattern for failed requests. Finally, you'll cover how to keep your application alive with the throttling pattern. When you've finished this course, you'll have a fundamental knowledge of the design patterns that will help you to design and build highly available and resilient cloud-based applications.

About the author
About the author

Barry is a software architect and developer with a passion for the cloud. He has worked for lots of companies throughout the last decade and is keen to share his knowledge with the community. He co-founded a usergroup focused on technology and soft-skills and currently teaches people about the benefits of the cloud.

More from the author
What's New in Visual Studio 2019
Beginner
58m
Apr 1, 2019
More courses by Barry Luijbregts
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone, my name is Barry Luijbregts, and welcome to my course, Cloud Design Patterns for Azure: Availability and Resilience, which is part of the series of courses about cloud design patterns for Azure. I am an independent software developer and architect with a passion for the cloud. Cloud design patterns provide best-practice solutions to common software design problems. You are probably using a lot of them already. Now it's time to learn everything about them. Some of the major topics that we will cover include, buffering workloads with the queue-based load leveling pattern, retrying field requests with the retry pattern, and keeping your application alive with the throttling pattern. By the end of this course, you'll know the solutions to the most common problems in cloud-based applications. Before beginning the course, you should be familiar with designing and developing cloud-based applications, at least at a beginner level. I hope you'll join me on this journey to learn about cloud design patterns, with the Cloud Design Patterns for Azure: Availability and Resilience course, at Pluralsight.

About the Availability and Resilience Cloud Design Patterns
Hi, I'm Barry. Welcome to the course, Cloud Design Patterns for Azure: Availability and Resilience. This course is part of a series of courses about design patterns for the cloud. In this course, you'll learn design patterns that are particularly relevant for applications that live in the cloud. These patterns are generic in nature and can be used with any cloud vendor. However, the examples of the patterns in this course are all examples in Microsoft Azure. Let's start with the first module about the availability and resilience patterns. This is a short introduction module in which I'll explain what design patterns are, and why they matter. And I'll explain how the cloud design patterns library is organized, and where you can find the examples for this course.

Circuit Breaker Pattern
Let's talk about the circuit breaker pattern. This pattern can improve the stability and resilience of your application by handling errors that take a variable amount of time to rectify. The circuit breaker pattern is often used together with the retry pattern, which you'll find in a later module in this course. First, I'll talk you through the problems that you can have when dealing with non-transient failures, so errors that aren't glitches. Next, I'll show you how to solve these problems with the circuit breaker pattern. Also, we'll discuss the things that you should consider when thinking about it, and we'll talk about when to use the pattern. Finally, I'll show you the circuit breaker pattern in action using a simple console application.

Compensating Transaction Pattern
Welcome to the module about the Compensating Transaction Pattern. This pattern is all about reverting errors in distributed processes. This pattern is very relevant when you work with distributed systems and eventual consistency. In the module, I'll first explain what the problems are with distributed processes. Next, I'll explain how you can solve these problems with the compensating transaction pattern. We'll also look at considerations for the pattern, and when to use the pattern, and when not to. And finally, I'll show you an example of the pattern using Azure Logic Apps.

Health Endpoint Monitoring Pattern
Let's talk about the Health Endpoint Monitoring Pattern. This will enable you to perform advanced monitoring of the health of your application and subsystems. I will first talk you through the problems that you can have with health monitoring, and how the health endpoint monitoring pattern solves these problems. Next, I'll discuss the things that you need to consider when thinking about the pattern, and I'll talk about when you should use the pattern. Finally, I'll show you an example of the health endpoint monitoring pattern using services in Microsoft Azure.

Queue-based Load Leveling Pattern
This module is all about the Queue-based Load Leveling Pattern. This pattern will help you to manage the load on services that your application calls so that your application will stay available and performant. In the module, I will first discuss the problems that we are going to solve with the pattern, namely the problem with calling services directly. After that, I'll talk about how to solve these problems with the queue-based load leveling pattern, and which things you should consider when thinking about the pattern. I'll also cover when you should use the pattern and when you shouldn't. And finally, I'll demo the pattern using an Azure Storage queue in a console application. I'll also demo the pattern in an Azure WebJob, so that you can see another approach for implementing the pattern.

Retry Pattern
Let's talk about the Retry Pattern. This pattern will help you to make your application more stable by retrying calls that failed because of transient failures. First, we will talk about the problem with transient failures, and then we will look at how to solve them. We will also discuss things to consider when thinking about the retry pattern and when to use it and when not to. Finally, I'll show you the retry pattern in action, in a simple console application that uses the Azure Storage Client Library.

Throttling Pattern
This module is about the Throttling Pattern. This pattern can help your application to stay available, even when there are certain increases in traffic. In the module, I'll first talk about what problems you could have with unpredictable traffic, and how to solve those problems with the throttling pattern. We'll also go over some considerations for the pattern, and when you should use the pattern. And finally, I'll show you the pattern in action using Azure API Management.