Implementing the Bulkhead Pattern with Polly in .NET

In the ever-evolving landscape of .NET applications, ensuring resiliency is paramount to maintaining system stability and reliability. One crucial design pattern that addresses this need is the bulkhead pattern. By isolating different parts of an application, the bulkhead pattern prevents a failure in one component from cascading and affecting others. This isolation is achieved by allocating separate resources for critical operations, ensuring that a malfunction in one service or subsystem does not exhaust the resources needed by other parts of the application. As a result, the bulkhead pattern helps contain failures, preserve resource availability, and sustain overall application performance, making it an indispensable strategy for enhancing resilience in complex, distributed environments.

What is the Bulkhead pattern?

The bulkhead pattern is a software design strategy used to enhance the resilience and stability of applications by isolating different components or subsystems. Inspired by the compartments in a ship that prevent it from sinking if one section is breached, the bulkhead pattern allocates dedicated resources to separate parts of the application. This isolation ensures that a failure in one component, such as a service or subsystem, does not deplete resources and impact the functionality of other components. Therefore by containing failures within specific boundaries, the bulkhead pattern helps maintain overall application performance and availability, especially in complex, distributed systems.

Imagine your application sends requests to a third-party API. If too many concurrent requests are allowed, the API might become overwhelmed, leading to slow response times or even outages. The Bulkhead Pattern can help by limiting the number of concurrent calls sent to the API.

Implementing the Bulkhead Pattern with Polly

Polly is a well-known .NET library for resilience and transient fault handling. It provides a suite of policies for managing various aspects of resilience, including the Bulkhead Policy. This policy allows you to control the number of concurrent executions of a specific piece of code, thereby enhancing system stability.

Let’s start with the implementation of the bulkhead pattern with Polly in the .NET application:

We will begin with the installation of the NuGet package Polly.

dotnet add package Polly

In your .NET application, you can define the Bulkhead Policy by creating an instance of the AsyncBulkheadPolicy. This allows you to set the maximum number of concurrent executions and the maximum queue length.

using Polly;
using Polly.Bulkhead;
using System;
var bulkheadPolicy = Policy.BulkheadAsync(6, int.MaxValue);

In this demo, we implemented it in a way that we allow up to 6 concurrent executions and an unlimited queue. You should adjust these values based on your application’s requirements and resource constraints.

Next, specify the code you want to safeguard with the Bulkhead Policy. In this example, we’ll create a method that sends an HTTP request to an external API:

using System.Net.Http;
using System.Threading.Tasks;
public async Task<string> CallExternalApiAsync()
{
    return await bulkheadPolicy.ExecuteAsync(async () =>
    {
        var apiUrl = "https://api.example.com/data";
        using var httpClient = new HttpClient();
        var response = await httpClient.GetAsync(apiUrl);
        if (response.IsSuccessStatusCode)
        {
            var data = await response.Content.ReadAsStringAsync();
            return data;
        }
        else
        {
            return "API request failed";
        }
    });
}

Within the CallExternalApiAsync method, we employ the ExecuteAsync method furnished by the Bulkhead Policy to run the code within the designated bulkhead. Furthermore, should the maximum limit of concurrent executions be attained, Polly will manage request queuing and throttling accordingly.

Benefits of the Bulkhead pattern

• Isolation of Failures: The bulkhead pattern segregates different components of an application, so if one component fails, the failure is contained and does not propagate to other parts. This, in turn, helps maintain the overall system’s functionality even when some parts are experiencing issues.
• Resource Containment: By allocating dedicated resources to specific operations, the bulkhead pattern ensures that critical tasks have the necessary resources to function properly. This prevents a single faulty component from consuming all available resources and impacting the entire application.
• Improved Stability: The pattern enhances system stability by managing how different parts of the application use resources. Even under heavy load or during a failure, the bulkhead pattern helps maintain a consistent performance level across the application.
• Enhanced Availability: By isolating faults and ensuring that critical services have access to required resources. The bulkhead pattern ensures that essential functionalities remain available to users, thus enhancing the overall availability of the application.
• Controlled Concurrency: The bulkhead pattern controls the number of concurrent operations for specific components, preventing overload. This ensures that the system can handle high traffic without degrading performance or becoming unresponsive.
• Better Fault Tolerance: By compartmentalising the application, the bulkhead pattern increases its ability to withstand and recover from failures. It provides a structured way to handle errors and reduces the risk of cascading failures. It leads to a more fault-tolerant system.

Conclusion

To conclude, implementing the Bulkhead Pattern alongside Polly in .NET applications can greatly boost your application’s resilience and fault tolerance. Therefore, by segregating various components or services, you can avert the spread of failures and guarantee that your application remains responsive across diverse scenarios.