YARP Load Balancing in .NET: Setup Guide

Want to optimize traffic distribution in your .NET applications? YARP (Yet Another Reverse Proxy) makes it simple. This guide walks you through setting up YARP for load balancing, ensuring reliability, scalability, and performance for your backend services.

Key Steps:

1. Install YARP: Add the Yarp.ReverseProxy NuGet package to your ASP.NET Core project.
2. Configure Routes and Clusters: Define routing rules and backend destinations in appsettings.json.
3. Choose Load Balancing Strategies: Options include RoundRobin, LeastRequests, and PowerOfTwoChoices.
4. Test Your Setup: Use tools like curl, Apache Benchmark, or k6 to verify traffic distribution and performance.

YARP also supports health checks, custom load balancing strategies, and seamless integration with containerized environments like Docker and Kubernetes. Follow this guide to get started!

Setting Up YARP Load Balancing

Now that you're familiar with YARP basics, let's get into the setup process. We'll cover creating a project, configuring YARP, and setting up load balancing.

Creating an ASP.NET Core Project

First, create a new ASP.NET Core web API project. You can use Visual Studio or the .NET CLI for this. Here's how:

1. Open Visual Studio and select "Create a new project".
2. Choose the "ASP.NET Core Web API" template.
3. Add the YARP.ReverseProxy NuGet package using the following command:

   dotnet add package Yarp.ReverseProxy
   

Next, enable YARP in your project by configuring it in Program.cs. Add the reverse proxy services like this:

builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

Once the project is ready, you'll need to configure routing and load balancing in appsettings.json.

Configuring YARP with appsettings.json

In the appsettings.json file, define the routes and clusters needed for YARP to function. Here's an example:

{
  "ReverseProxy": {
    "Routes": {
      "route1": {
        "ClusterId": "backendCluster",
        "Match": {
          "Path": "{**catch-all}"
        }
      }
    },
    "Clusters": {
      "backendCluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://backend1.example.com"
          },
          "destination2": {
            "Address": "https://backend2.example.com"
          }
        },
        "LoadBalancingPolicy": "RoundRobin"
      }
    }
  }
}

This setup defines a route (route1) that directs traffic to a cluster (backendCluster) with two destinations. The LoadBalancingPolicy is set to "RoundRobin" by default. You can adjust this based on your needs.

Load Balancing Strategies

YARP supports several load balancing strategies. Here's a quick overview:

To apply a specific strategy, update the LoadBalancingPolicy in your cluster configuration. For example, to use "LeastRequests":

"Clusters": {
  "backendCluster": {
    "LoadBalancingPolicy": "LeastRequests"
  }
}

YARP also includes passive health monitoring to skip servers that aren't functioning properly ^[2]. For more advanced needs, you can create custom load balancing strategies by extending YARP's base classes.

Implementing and Testing YARP Load Balancing

Setting Up Backend Services

To configure YARP load balancing, you'll need multiple instances of your backend service. You can duplicate the project or use configuration overrides to run the same API on different ports. Here's an example of setting up an instance:

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseUrls("http://localhost:5001");

Next, update the appsettings.json file to define the backend services for YARP:

{
  "ReverseProxy": {
    "Clusters": {
      "apiCluster": {
        "Destinations": {
          "api1": { "Address": "http://localhost:5001" },
          "api2": { "Address": "http://localhost:5002" },
          "api3": { "Address": "http://localhost:5003" }
        },
        "LoadBalancingPolicy": "PowerOfTwoChoices",
        "HealthCheck": {
          "Active": { "Enabled": true }
        }
      }
    }
  }
}

Testing the Load Balancer

Once your backend services are set up, it's time to test the load balancer. Add request tracking and a health check endpoint to your application:

app.Use(async (context, next) =>
{
    var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
    logger.LogInformation($"Request received at {DateTime.UtcNow}: {context.Request.Path}");

    // Health check endpoint
    if (context.Request.Path == "/health")
    {
        await context.Response.WriteAsJsonAsync(new { 
            Status = "Healthy",
            Timestamp = DateTime.UtcNow
        });
        return;
    }
    await next();
});

app.MapGet("/instance-info", (HttpContext context) => Results.Ok(new {
    InstanceId = Environment.MachineName,
    Port = context.Connection.LocalPort,
    Timestamp = DateTime.UtcNow
}));

Now, test the setup using these methods:

• Manual testing with curl:

curl http://localhost:5000/instance-info

• Load testing with Apache Benchmark:

ab -n 1000 -c 10 http://localhost:5000/instance-info

• Performance testing with k6:

import http from 'k6/http';
export default function () {
    http.get('http://localhost:5000/instance-info');
}

Keep an eye on the following metrics to assess how well the load balancer is working:

• Distribution of requests across backends
• Response times
• Error rates
• Health status of instances

For production systems, consider using tools like Application Insights or Prometheus to get detailed insights into traffic and server health ^[2][3].

sbb-itb-29cd4f6

Advanced Topics and Best Practices

Improving Scalability and Performance

Selecting the right load balancing strategy - like RoundRobin, LeastRequests, or PowerOfTwoChoices - is key to boosting scalability and performance. For a deeper dive, check out the earlier section on Load Balancing Strategies.

To keep tabs on performance, you can add custom middleware to track crucial metrics. Here's an example in C#:

app.Use(async (context, next) =>
{
    var timer = Stopwatch.StartNew();
    try
    {
        await next();
    }
    finally
    {
        timer.Stop();
        var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
        logger.LogInformation($"Request processed in {timer.ElapsedMilliseconds}ms");
    }
});

After fine-tuning your load balancing approach, deploying YARP in a containerized setup ensures it can handle production-level demands with ease.

Deploying YARP with Docker or Kubernetes

Using container platforms like Docker and Kubernetes allows you to maximize YARP's load balancing capabilities while ensuring smooth orchestration. Here's a simple Dockerfile for deploying YARP in a production environment:

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["YarpProxy.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "YarpProxy.dll"]

To ensure reliability, you can integrate YARP's health checks with Kubernetes liveness probes. Here's an example configuration:

livenessProbe:
  httpGet:
    path: /health
    port: 80

For production, it's smart to enable rate limiting and utilize YARP's health checks to safeguard backend services and handle traffic surges effectively. These features also reroute requests away from unhealthy instances automatically ^[2]. If you're dealing with complex setups, you can extend YARP's default behavior to create custom load balancing strategies tailored to your business needs while retaining its core architectural benefits ^[2].

Conclusion and Key Takeaways

Review of Setup Process

Setting up YARP for load balancing in .NET applications involves three main steps: creating an ASP.NET Core project, adding YARP services with builder.Services.AddReverseProxy(), and configuring routes and clusters in appsettings.json ^[1]. Here's a quick breakdown:

Once these steps are complete, you're ready to see why YARP is a great option for .NET developers.

Why Choose YARP?

YARP delivers high performance, scalability, and adaptability for .NET applications. Its seamless integration with ASP.NET Core includes features like built-in health checks and rate limiting. Plus, it supports multiple load balancing policies, such as RoundRobin, LeastRequests, and PowerOfTwoChoices, allowing you to fine-tune traffic distribution based on your needs ^[1][2].

"YARP is a robust and flexible reverse proxy solution tailored for .NET developers. Whether you need simple routing, complex load balancing, or advanced transformations, YARP provides the tools you need to build a performant and scalable reverse proxy." ^[2]

Stay Updated with the .NET Newsletter

YARP is constantly evolving, and keeping up with its new features and best practices is essential for optimizing your systems. The .NET Newsletter offers daily updates on YARP and related technologies, helping you stay ahead in load balancing and distributed systems.

What you’ll find:

• Updates on the latest YARP features
• Real-world implementation case studies
• Insights into trends in reverse proxy and load balancing

Stay informed to make the most of YARP in your projects.