Construct an API gateway utilizing YARP in ASP.NET Core

An API gateway gives a mechanism by way of which the person interface parts of an utility can hook up with back-end providers to change information. This text introduces the idea of an API gateway, discusses the variations between an API gateway and a reverse proxy, and illustrates how one can implement an API gateway utilizing YARP (But One other Reverse Proxy) in ASP.NET Core.

On this article, we’ll make use of the microservices we created in my earlier article. To make use of the code examples offered on this article, it’s best to have Visible Studio 2022 put in in your system. In the event you don’t have already got a duplicate, you possibly can obtain Visible Studio 2022 right here.

What’s an API gateway?

An API gateway gives a single level of entry for purchasers or service shoppers to entry back-end providers. An API gateway accepts calls from shopper functions and forwards them to the suitable providers. As a central level of management between purchasers and providers, an API gateway can be utilized to implement price limiting, safety, load balancing, routing, and monitoring. It additionally helps to implement unfastened coupling, safety, scalability, and excessive availability.

An API gateway is a particular type of reverse proxy. A reverse proxy is a server that sits between purchasers and back-end providers to distribute the shopper requests throughout a number of machines. A reverse proxy is an efficient selection for caching, safety, and cargo balancing. The purchasers can name the downstream providers solely by way of the reverse proxy, which forwards the requests to the suitable downstream service.

Within the following sections we’ll look at the best way to implement an API gateway utilizing YARP in ASP.NET Core.

Create an ASP.NET Core Internet API undertaking in Visible Studio 2022

First off, let’s create an ASP.NET Core Internet API undertaking in Visible Studio 2022. Observe the steps outlined beneath.

1. Launch the Visible Studio 2022 IDE.
2. Click on on “Create new undertaking.”
3. Within the “Create new undertaking” window, choose “ASP.NET Core Internet API” from the record of templates displayed.
4. Click on Subsequent.
5. Within the “Configure your new undertaking” window, specify the title and placement for the brand new undertaking.
6. Optionally verify the “Place resolution and undertaking in the identical listing” verify field, relying in your preferences.
7. Click on Subsequent.
8. Within the “Further Data” window proven subsequent, depart the “Use controllers (uncheck to make use of minimal APIs)” field checked. We gained’t be utilizing minimal APIs on this undertaking.
9. Elsewhere within the “Further Data” window, depart the “Authentication Kind” set to “None” (the default) and ensure the verify packing containers “Allow Open API Assist,” “Configure for HTTPS,” and “Allow Docker” stay unchecked. We gained’t be utilizing any of these options right here.
10. Click on Create.

We’ll use this ASP.NET Core Internet API undertaking to implement an API gateway with YARP within the sections beneath. Particularly, we’ll create a microservices-based utility that includes an API gateway and three downstream providers.

Set up the YARP NuGet bundle

Subsequent add the YARP NuGet bundle to the Internet API undertaking you simply created in Visible Studio. To do that, choose the undertaking within the Answer Explorer window and right-click and choose “Handle NuGet Packages.” Within the NuGet Package deal Supervisor window, seek for the Yarp.ReverseProxy bundle and set up it.

Alternatively, you possibly can set up the YARP bundle through the NuGet Package deal Supervisor console by coming into the road proven beneath.

PM> Set up-Package deal Yarp.ReverseProxy

Configure YARP in ASP.NET Core

Assuming the Yarp.ReverseProxy NuGet bundle has been efficiently put in in your undertaking, it’s best to now configure YARP within the Program.cs file of your ASP.NET Core undertaking. You possibly can configure YARP utilizing the next piece of code.

var builder = WebApplication.CreateBuilder(args);
builder.Providers
   .AddReverseProxy()
   .LoadFromConfig(builder.Configuration.GetSection("Yarp"));
var app = builder.Construct();
app.MapReverseProxy();
app.Run();

The AddReverseProxy methodology is used so as to add the required providers for YARP to work. The LoadFromConfig methodology masses the endpoints and their routing data from the config file. Lastly, the MapReverseProxy methodology provides the reverse proxy routes to the routing desk.

Specify the route data in YARP

YARP takes benefit of routes and clusters to specify route configuration. Whereas routes are used to specify request patterns, clusters are used to specify providers the place the requests needs to be forwarded.

The next is the whole supply code of the configuration we are going to use on this instance. As you possibly can see, there are three routes: customers-route, suppliers-route, and products-route.

"Yarp": {
   "Routes": {
      "customers-route": {
         "ClusterId": "customers-cluster",
         "Match": {
            "Path": "/clients/{**catch-all}"
         },
         "Transforms": [ { "PathPattern": "{**catch-all}" } ]
      },
      "suppliers-route": {
         "ClusterId": "suppliers-cluster",
         "Match": {
            "Path": "/suppliers/{**catch-all}"
         },
         "Transforms": [ { "PathPattern": "{**catch-all}" } ]
      },
      "products-route": {
         "ClusterId": "products-cluster",
         "Match": {
            "Path": "/merchandise/{**catch-all}"
         },
         "Transforms": [ { "PathPattern": "{**catch-all}" } ]
      }
   },
   "Clusters": {
      "customers-cluster": {
         "Locations": {
            "destination1": {
               "Handle": "http://localhost:5198/api/buyer"
            }
         }
      },
      "suppliers-cluster": {
         "Locations": {
            "destination1": {
               "Handle": "http://localhost:5054/api/provider"
            }
         }
      },
      "products-cluster": {
         "Locations": {
            "destination1": {
               "Handle": "http://localhost:6982/api/product"
            }
         }
      }
   }
}

Implement price limiting

Fee limiting is a technique used to restrict the variety of requests your API purchasers are allowed to make to an API. Fee limiting helps in securing your utility and decreasing the load in your APIs. It’s also possible to use YARP to implement price limiting in your API gateway.

The next code snippet illustrates how one can outline a price restrict coverage in Yarp.

builder.Providers.AddRateLimiter(rateLimiterOptions =>
{
   rateLimiterOptions.AddFixedWindowLimiter("fastened", choices =>
   {
      choices.Window = TimeSpan.FromSeconds(5);
      choices.PermitLimit = 2;
   });
});

Implement authentication and authorization

You possibly can implement authentication and authorization in your API gateway utilizing the next piece of code within the Program.cs file.

builder.Providers.AddAuthorization(choices =>
{
   choices.AddPolicy("safe", coverage =>
   coverage.RequireAuthenticatedUser());
});

You must then name the UseAuthentication and UseAuthorization strategies so as to add safety to the request processing pipeline.

app.UseAuthentication();
app.UseAuthorization();
app.MapReverseProxy();

Check the API gateway

To check the API Gateway we’ve created on this instance, run all 4 of the functions, i.e., the API gateway and the shoppers, suppliers, and merchandise microservices. Now launch Postman and execute the next endpoint.

http://localhost:5198/clients/1

Assuming you will have set breakpoints within the CustomerController class pertaining to the shoppers microservice, you’ll see that the endpoint has been hit as proven in Determine 1 beneath. 

IDG

YARP is simple to configure and use. You possibly can be taught extra about YARP and all of its options from the YARP docs.