YARP vs. Ocelot: Choosing the Right API Gateway in C#

When building microservices-based applications in .NET, managing API routing, security, and load balancing can become complex. API gateways help simplify this by acting as intermediaries between clients and your microservices, handling requests and managing traffic. In the .NET ecosystem, two popular API gateway options are YARP (Yet Another Reverse Proxy) and Ocelot. Both are powerful, open-source solutions with unique features and use cases. In this article, I'll compare YARP and Ocelot, exploring their features, configuration, pros, cons, and code examples to help you choose the right API gateway for your application.

What is YARP?

YARP (Yet Another Reverse Proxy) is a high-performance, customizable reverse proxy library developed by Microsoft. It’s specifically designed to integrate seamlessly with .NET Core applications, offering developers flexibility to control how requests are processed. YARP is ideal for scenarios where you need fine-grained control over routing, load balancing, and middleware, as it lets you write custom logic easily.

Key Features of YARP

• High Performance: Built on top of .NET and optimized for high throughput.

• Customizability: Allows for custom routing and request handling logic.

• Integration with ASP.NET Core: Works natively with ASP.NET Core’s dependency injection and middleware pipeline.

• Real-Time Routing Configuration: Modify routing dynamically, making it adaptable to changing microservices environments.

What is Ocelot?

Ocelot is an open-source API gateway built specifically for .NET applications. It provides a more opinionated approach, with built-in support for API routing, load balancing, caching, rate limiting, authentication, and authorization. Ocelot is widely used for simple to moderately complex microservices architectures where ease of configuration and a quick setup are priorities.

Key Features of Ocelot

• Ease of Configuration: Configuration is primarily JSON-based, making it easy to set up.

• Built-in Features: Supports advanced features like rate limiting, QoS, and caching.

• Middleware-Based: Extensible via custom middleware.

• Supports .NET 5+: Works with .NET Core and .NET 5+ applications.

When to Use YARP or Ocelot

Getting Started with YARP

To set up YARP, you’ll need to install the YARP package and configure routing in your ASP.NET Core application.

1. Install the YARP Package

dotnet add package Microsoft.ReverseProxy

2. Configure YARP in appsettings.json

Add a ReverseProxy section to define the routes and clusters. For example, if you have two microservices (ServiceA and ServiceB), you can configure them as follows:

{
  "ReverseProxy": {
    "Routes": {
      "route1": {
        "ClusterId": "clusterA",
        "Match": {
          "Path": "/serviceA/{**catch-all}"
        }
      },
      "route2": {
        "ClusterId": "clusterB",
        "Match": {
          "Path": "/serviceB/{**catch-all}"
        }
      }
    },
    "Clusters": {
      "clusterA": {
        "Destinations": {
          "destination1": {
            "Address": "http://localhost:5001/"
          }
        }
      },
      "clusterB": {
        "Destinations": {
          "destination1": {
            "Address": "http://localhost:5002/"
          }
        }
      }
    }
  }
}

3. Configure YARP in Startup.cs

Add YARP to the middleware pipeline in Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddReverseProxy()
            .LoadFromConfig(Configuration.GetSection("ReverseProxy"));
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapReverseProxy();
    });
}

4. Run the Application
Start the application, and you can access ServiceA at /serviceA and ServiceB at /serviceB.

Pros of YARP

• High performance and low latency.

• Highly customizable and flexible routing options.

• Seamlessly integrates with ASP.NET Core’s dependency injection.

Cons of YARP

• Less feature-rich than Ocelot out-of-the-box (requires custom development for some features).

• More complex configuration for beginners.

Getting Started with Ocelot

Ocelot provides a simpler configuration model that’s easy to set up with JSON files.

1. Install the Ocelot Package

dotnet add package Ocelot

2. Configure Ocelot in ocelot.json

Ocelot configuration is stored in a separate JSON file, ocelot.json. Here’s an example configuration for two routes:

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/serviceA/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5001
        }
      ],
      "UpstreamPathTemplate": "/serviceA/{everything}",
      "UpstreamHttpMethod": [ "Get", "Post" ]
    },
    {
      "DownstreamPathTemplate": "/api/serviceB/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5002
        }
      ],
      "UpstreamPathTemplate": "/serviceB/{everything}",
      "UpstreamHttpMethod": [ "Get", "Post" ]
    }
  ]
}

3. Configure Ocelot in Startup.cs
Add Ocelot to the middleware pipeline in Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddOcelot();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
    app.UseOcelot().Wait();
}

1. Run the Application

Start the application, and you can access ServiceA at /serviceA and ServiceB at /serviceB.

Pros of Ocelot

• Easy to configure and set up.

• Comes with built-in features like rate limiting, caching, and load balancing.

• Minimal code required; configuration is primarily JSON-based.

Pros of Ocelot
Easy to configure and set up.
Comes with built-in features like rate limiting, caching, and load balancing.
Minimal code required; configuration is primarily JSON-based.

Real-Life Scenarios
**Scenario 1:** High-Performance E-commerce Platform (Use YARP)
Imagine you’re building an e-commerce platform that needs to handle thousands of requests per second. You require advanced load balancing, custom routing logic, and low latency to ensure users get a fast and smooth experience. YARP would be an ideal choice because of its high performance and flexibility. You can customize routing to handle traffic spikes, ensure low latency, and scale up as needed.

**Scenario 2:** Quick Microservices Setup for an Internal Tool (Use Ocelot)
Now imagine your team needs to set up a quick internal tool that aggregates data from several microservices for reporting. Since it’s an internal tool with lower traffic, Ocelot can be an excellent choice. With its simple configuration and built-in features like caching, you can get the tool up and running quickly without much custom code.

**Scenario 3:** Custom Authentication Requirement (Use YARP)
Suppose you have a custom authentication system that needs to inspect and modify requests before they reach your microservices. With YARP, you can write custom middleware to authenticate and validate requests according to your specific requirements, adding a level of control that might be harder to implement in Ocelot.

Conclusion

Both YARP and Ocelot are powerful API gateways, each suited to different needs:

Use YARP if you need high performance, advanced customizability, and integration directly with ASP.NET Core's pipeline. YARP is suitable for large-scale, high-throughput applications where custom routing and load balancing logic are required.

Use Ocelot if you prefer a simpler configuration process and need quick setup with built-in features like caching, rate limiting, and load balancing. Ocelot is ideal for small to moderate microservices projects where ease of setup and built-in functionality are priorities.

LinkedIn Account : LinkedIn
Twitter Account: Twitter
Credit: Graphics sourced from treblle