Enhancing Real-World Microservices with Resiliency in .NET Aspire

.NET Aspire introduces a powerful set of features designed for .NET-focused applications, including observability, microservices management, resilience, service discovery, and scalability. If you have an existing .NET application and want to integrate these capabilities, .NET Aspire makes it seamless to do so.

If you are new to .NET Aspire, I would suggest you check out the previous chapters of this .NET Aspire Quickbook.

1. Getting Started with .NET Aspire
2. Setting Up Your Development Environment
3. Core Concepts of .NET Aspire

Let's get back to the topic. To demonstrate this, we will start with a basic Blazor application that consumes a microservice to fetch random weather forecast data via a REST API.

Below is the structure of our sample project.

Weather Forecast Project.

• API: ASP.NET Core Web API
• UI/Frontend: Blazor Server
• Solution Name: BlazorWeatherApp.sln

When the front-end requests for the data to the microservice API, the response is returned as JSON and displayed in a table format for users. Both the frontend and API need to be running simultaneously for the application to function properly.

Running the Solution in Visual Studio

1. Open the solution in Visual Studio.
2. Right-click on the solution file and set "Multiple Startup Projects" to ensure both API and frontend applications run together.
   
3. Run the solution. You will see two command-line windows open—one for each project.
   
4. Open the browser and navigate to,
   1. Swagger UI (for API testing and documentation)
   2. Frontend UI (Blazor Server App)
      
5. Navigate to the "Weather" page from the menu bar to see the data retrieved from the API.
   

Challenges in Microservices-Based Applications

Managing multiple microservices, UI clients, and database layers in large enterprise applications can become complex. Running, debugging, logging, and tracing issues across dependent services can be time-consuming and difficult.

Integrating .NET Aspire into Our Project

Now, let’s enhance our project by integrating .NET Aspire. We’ll begin by focusing on resiliency using the .NET Aspire Service Defaults template.

Understanding Resiliency

Resiliency in software systems ensures that applications handle failures gracefully, recover automatically, and remain operational without significantly impacting user experience.

Key Aspects of Resiliency

• Fault Tolerance: The system continues running despite failures.
• Self-Healing: The application recovers automatically.
• Graceful Degradation: Partial functionality remains available during failures.
• Retry Mechanisms: Automatic retries for failed operations.
• Circuit Breakers: Prevent excessive requests to failing services.
• Failover & Redundancy: Uses alternative backup paths during failures.

Techniques to Achieve Resiliency

• Retry Policies: Automatically retry failed requests (e.g., network timeouts).
• Circuit Breakers: Temporarily stop calling services experiencing frequent failures.
• Timeouts & Rate Limiting: Prevent overloaded services from affecting the system.
• Load Balancing: Distributes traffic across multiple instances.
• Logging & Monitoring: Quickly detects failures for proactive resolution.

How .NET Aspire Enhances Resiliency?

.NET Aspire integrates with Polly, a resilience and transient fault-handling library, offering.

• Automatic Retries (for transient errors like timeouts)
• Circuit Breakers (to prevent excessive failed requests)
• Bulkhead Isolation (limiting the impact of failures)
• Timeout Policies (ensuring services don’t hang indefinitely)

Adding .NET Aspire to the Project

Right now, we have two projects in this solution, as shown in the image below.

Step 1. Create a .NET Aspire Service Defaults Project.

1. In Visual Studio, right-click on the solution and select Add -> New Project.
2. Search for ".NET Aspire Service Defaults", select it, and click Next.
   
3. Name the project (e.g., BlazorWeatherApp.ServiceDefaults) and click Next.
   

Now, you should have three projects in your solution.

• BlazorWeatherApp.API (Microservice API)
• BlazorWeatherApp.UI (Blazor Server frontend)
• BlazorWeatherApp.ServiceDefaults (Newly added .NET Aspire service defaults project)
  

Step 2. Add References to Other Projects.

1. Right-click on each project (API and Blazor Server UI) and select “Add Reference”.
2. Add a reference of “BlazorWeatherApp.ServiceDefaults” to each project.
   
3. You can see in the image below, I have added project references of this .Net aspire service defaults to both of my projects (API and Blazor Server).
   

Step 3. Register .NET Aspire Services.

Modify the “Program.cs” file of both API and UI projects to register the service defaults.

builder.AddServiceDefaults();

Step 4. Enable Default Endpoints.

Before calling `app.Run()`, add the following line to map default endpoints.

app.MapDefaultEndpoints();

Step 5. Build and Run the Solution.

1. Rebuild the solution to verify there are no errors.
2. Run the application. You should see additional output in the command-line window indicating execution attempts by Polly’s retry mechanism.
   
3. This means that .NET Aspire has added Polly Library to achieve resiliency.

Verifying Resiliency and Health Endpoints

.NET Aspire provides default health endpoints to check application status. Open a browser and request.

https://localhost:[port]/health

If you receive a valid response like above in the image above, it confirms that your default endpoints are working correctly.

Conclusion

By integrating .NET Aspire into our Blazor-based microservices application, we have enhanced its resilience with automated retries, circuit breakers, and health monitoring. This ensures the system remains reliable, even in the face of failures.

In the next chapter, we will explore additional Polly Library features and configurations along with .NET Aspire to improve Resiliency.