This post covers how to deal with transient issues within Azure Functions. The process is simple thanks to available helper libraries. All my code samples are in C#.
Azure Functions and Transient Fault Handling
Dealing with transient fault handling isn’t new. When cloud-based applications use other cloud services, things might go wrong. This is because of temporary conditions such as intermittent service, network issues etc. In most cases operation may succeed when retrying shortly later.
Transient Fault Handling libraries
Writing retry logic isn’t that simple. Coding cancellation and dynamic wait duration support is a lot of work. Fortunately, libraries that can help dealing with Transient errors do exist.
I am a big Polly fan. It’s easy to use, has many features and supports async operations. Because of this I won’t cover any other options. Keep in mind that you can use any library of your liking. However, make sure it’s available as a NuGet Package.
Building A C# sample function
Let’s get started with creating simple function. This function gathers information from an external web service.
Step 1 – Creating a new Function App
A Function App is a container which hosts Azure Functions. Creating a new Function App using the Portal (or API) is simple. Once created, locate and open the Function App within the Portal.
Step 2 – Creating a new Function
Within the interface select New Function. A new selection screen should display containing pre-defined templates. I’m using a timer based function to simplify the test case. Select your desired template, however make sure it’s using C#.
Within the code section I’ve included the code as displayed below. Here I’m calling a web service using restsharp. The call is surrounded with an exception / retry policy.
Mode about the code
A couple of remarks I would like to make regarding this code sample. First off all, make sure to visit Polly’s GitHub page. Here you can find lots of documented samples. In my sample I’m creating a simple retry policy. Iv’e set the amount of retries to 3 with a dynamic wait duration.
I’ve wrapped the policy within a
Try Catch block. This in case recovery isn’t possible. Within the policy execution block, I’m throwing a custom exception. This to force a retry based on fixable status codes.
Note: You don’t have to throw custom exceptions by using HandleResult. You can find additional details in section 1B.
Step 3 – Importing Nuget packages
As mentioned within step 2, the code uses two Nuget packages. To import packages into your Function, you will need to create a project.json file. You can do this using a tool called Visual Studio Online. To open VS Online, click Function app settings located in the right corner.
Locate Advanced settings at the bottom of the screen. Click on Go to App Service Settings.
Within the management blade find the section called Development Tools. And open VS Online by clicking on App Service Editor, Go.
A new screen will open with the layout of your functions. By default, every function has a run.csx which contains your function code. In addition also contains a function.js which contains config specific information.
Within the root level of your function, create a file called project.json. The example below shows how to reference existing Nuget packages.
Note: Only the .NET Framework 4.6 is supported. Therefore, make sure that your project.json file specifies net46 as shown here.
After this, you can import the namespace as usual, with the using clause.
Step 5 – Testing the function
Testing Transient Faults are hard to test because of their unpredictable nature. You can create a web service mock to see how your code behaves. What’s important is to keep an eye on your Policy and Execution log entries.
Once you have a setup which can mimic server errors, it’s simple to initiate a test run. On the developer tab locate the button called Run.
I’ve included some additional resources below. I hope this was helpful and more on Azure Functions soon!