<!DOCTYPE html>

ASP.NET Core API Gateway with Ocelot Part 1: Routing

 body { font-family: sans-serif; } h1, h2, h3 { color: #333; } code { font-family: monospace; background-color: #eee; padding: 2px 5px; } pre { background-color: #eee; padding: 10px; overflow-x: auto; }

ASP.NET Core API Gateway with Ocelot Part 1: Routing

Introduction

In modern microservices architectures, managing communication between numerous services can become complex. API gateways serve as a centralized entry point for external clients, simplifying access and providing features like security, rate limiting, and routing. Ocelot is a powerful and open-source API gateway built for ASP.NET Core that offers a flexible and customizable way to manage your API landscape.

This article dives into the fundamental aspect of Ocelot: routing. We'll explore how Ocelot effectively directs requests to the appropriate downstream microservices based on various criteria, streamlining your API management and enhancing the overall performance and scalability of your microservice architecture.

What is an API Gateway?

An API gateway acts as a central point of control for all requests to your microservices. It sits in front of your backend services and acts as a single point of entry for clients. It provides several benefits:

Centralized Entry Point:
Clients interact with the gateway instead of directly accessing each service, simplifying communication and reducing the number of connections.
Security:
The gateway can implement authentication, authorization, and other security measures for all incoming requests.
Routing:
The gateway can intelligently route requests to the appropriate backend service based on various factors like path, headers, or query parameters.
Rate Limiting:
Control the number of requests that can be processed per unit of time, preventing overloading of your services.
Load Balancing:
Distribute requests across multiple instances of your services for improved performance and fault tolerance.
Protocol Translation:
Convert between different protocols (e.g., REST and gRPC) to facilitate communication between clients and services.

Installing Ocelot

To get started with Ocelot, first, you need to install it in your ASP.NET Core project. Open your project's terminal or command prompt and run the following command:



   dotnet add package Ocelot

Configuring Ocelot

The core of Ocelot's functionality is defined in its configuration. You can configure Ocelot using JSON files or by creating configuration classes within your project. In this example, we'll use a JSON configuration file.

Sample Configuration File (ocelot.json)



    {

        "GlobalConfiguration": {

            "ServiceDiscoveryProvider": {

                "Type": "None"

            }

        },

        "ReRoutes": [

            {

                "DownstreamPathTemplate": "/products/{productId}",

                "DownstreamScheme": "http",

                "DownstreamHostAndPorts": [

                    {

                        "Host": "localhost",

                        "Port": 5001

                    }

                ],

                "UpstreamPathTemplate": "/api/products/{productId}",

                "UpstreamHttpMethod": [ "Get" ]

            },

            {

                "DownstreamPathTemplate": "/orders",

                "DownstreamScheme": "http",

                "DownstreamHostAndPorts": [

                    {

                        "Host": "localhost",

                        "Port": 5002

                    }

                ],

                "UpstreamPathTemplate": "/api/orders",

                "UpstreamHttpMethod": [ "Post" ]

            }

        ]

    }

This configuration defines two re-routes:

Products Service:
Routes requests to the /api/products/{productId} path to the /products/{productId} path on the products service (running on port 5001). This route only accepts GET requests.
Orders Service:
Routes requests to the /api/orders path to the /orders path on the orders service (running on port 5002). This route only accepts POST requests.

Using Configuration in the ASP.NET Core Application

After creating the configuration file, you need to integrate it into your ASP.NET Core application. Modify your
Program.cs
file as follows:



    using Ocelot.DependencyInjection;

    using Ocelot.Middleware;
var builder = WebApplication.CreateBuilder(args);

// Add Ocelot services to the container
builder.Services.AddOcelot();

var app = builder.Build();

// Configure Ocelot middleware
app.MapGet("/", () =&gt; "Ocelot is running");

app.UseOcelot().Wait();

app.Run();
</pre>



   This code adds the necessary Ocelot services and configures the middleware. Ocelot's middleware will process requests based on the configuration you've provided. In this case, it will redirect requests based on the defined routes.

  


  


   Advanced Routing Features

  


  

   Ocelot offers a rich set of routing features that go beyond simple path-based routing. Let's explore some of them:

  


  


Host-Based Routing




You can route requests based on the incoming request's host. This allows you to configure different routes for different domains or subdomains. For example, you might want to route requests from

api.example.com

to one set of services and requests from

admin.example.com

to another.


{
    "ReRoutes": [
        {
            // ...
            "UpstreamHost": "api.example.com"
        },
        {
            // ...
            "UpstreamHost": "admin.example.com"
        }
    ]
}

Header-Based Routing

You can also route requests based on specific HTTP headers. This allows you to provide customized routing based on the context of the request.

{
    "ReRoutes": [
        {
            // ...
            "UpstreamHeaders": {
                "X-Tenant-Id": "customerA"
            }
        },
        {
            // ...
            "UpstreamHeaders": {
                "X-Tenant-Id": "customerB"
            }
        }
    ]
}

Query Parameter-Based Routing

Routing decisions can also be made based on query parameters in the URL.

{
    "ReRoutes": [
        {
            // ...
            "UpstreamQueryKeys": [
                "region",
                "currency"
            ]
        }
    ]
}

Using Regex in Routing

For more complex routing scenarios, Ocelot supports regular expressions. You can use regex patterns to match specific patterns in the URL path.

{
    "ReRoutes": [
        {
            // ...
            "UpstreamPathTemplate": "/api/products/([0-9]+)"
        }
    ]
}

This example uses a regex pattern to match any path starting with /api/products/ followed by one or more digits.

Using Route Groups

Ocelot allows you to group your routes together for better organization and manageability. You can define a group of routes with common configurations, such as the same downstream service or upstream host, and then reuse this group in multiple re-routes.

{
    "ReRoutes": [
        {
            "DownstreamPathTemplate": "/products/{productId}",
            "DownstreamScheme": "http",
            "DownstreamHostAndPorts": [
                {
                    "Host": "localhost",
                    "Port": 5001
                }
            ],
            "UpstreamPathTemplate": "/api/products/{productId}",
            "UpstreamHttpMethod": [ "Get" ]
        },
        {
            "DownstreamPathTemplate": "/orders",
            "DownstreamScheme": "http",
            "DownstreamHostAndPorts": [
                {
                    "Host": "localhost",
                    "Port": 5002
                }
            ],
            "UpstreamPathTemplate": "/api/orders",
            "UpstreamHttpMethod": [ "Post" ]
        }
    ],
    "RouteGroups": [
        {
            "Routes": [
                {
                    "DownstreamPathTemplate": "/users",
                    "DownstreamScheme": "http",
                    "DownstreamHostAndPorts": [
                        {
                            "Host": "localhost",
                            "Port": 5003
                        }
                    ],
                    "UpstreamPathTemplate": "/api/users",
                    "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ]
                }
            ]
        }
    ]
}

This configuration defines a route group named "UserServiceGroup" that includes a single route to the users service. This group can be referenced in other routes, which can simplify your configuration and reuse common settings.

Conclusion

Ocelot provides a powerful and flexible framework for managing and routing requests in a microservice environment. In this part, we've explored the fundamentals of routing, including basic path-based routing and advanced techniques like host-based, header-based, and query parameter-based routing. By leveraging Ocelot's routing capabilities, you can streamline API communication, improve security, and enhance the scalability and performance of your microservice architecture.

In subsequent parts of this series, we'll dive into other key features of Ocelot, including authentication, authorization, rate limiting, and more. Stay tuned to learn how Ocelot can help you build robust and efficient API gateways for your microservices.