Ocelot API Gateway

A lightweight and Open Source API Gateway : Ocelot is an Open Source .NET Core based API Gateway especially made for microservices architecture that need unified points of entry into their system. It is lightweight, fast, scalable and provides routing and authentication among many other features.

Deployment : The Ocelot is a .NET Core lightweight API Gateway that you can deploy into the same application deployment environment where you are deploying your microservices/containers, such as a Docker Host, Kubernetes, Service Fabric, etc. and since it is based on .NET Core it is cross-platform allowing you to deploy on Linux or Windows.

Features :

• Routing
• Request Aggregation
• WebSockets
• Authentication
• Authorization
• Rate Limiting
• Caching
• Retry policies / QoS
• Load Balancing
• Logging / Tracing / Correlation
• Headers / Method / Query String / Claims Transformation
• Custom Middleware / Delegating Handlers
• Configuration / Administration REST API
• Platform / Cloud Agnostic

Building API Gateway Using Ocelot In ASP.NET Core
Install NuGet package

Install Ocelot and it’s dependencies using nuget. You will need to create a netcoreapp3.1 project and bring the package into it. Then follow the Startup below and Configuration sections to get up and running.

Install-Package Ocelot

All versions can be found here.

Configuration

The following is a very basic ocelot.json. It won’t do anything but should get Ocelot starting.

{
    "Routes": [],
    "GlobalConfiguration": {
        "BaseUrl": "https://api.mybusiness.com"
    }
}

If you want some example that actually does something use the following:

{
    "Routes": [
        {
        "DownstreamPathTemplate": "/todos/{id}",
        "DownstreamScheme": "https",
        "DownstreamHostAndPorts": [
            {
                "Host": "jsonplaceholder.typicode.com",
                "Port": 443
            }
        ],
        "UpstreamPathTemplate": "/todos/{id}",
        "UpstreamHttpMethod": [ "Get" ]
        }
    ],
    "GlobalConfiguration": {
        "BaseUrl": "https://localhost:5000"
    }
}

The most important thing to note here is BaseUrl. Ocelot needs to know the URL it is running under in order to do Header find & replace and for certain administration configurations. When setting this URL it should be the external URL that clients will see Ocelot running on

The main functionality of an Ocelot API Gateway is to take incoming HTTP requests and forward them on to a downstream service, currently as another HTTP request. Ocelot’s describes the routing of one request to another as a ReRoute.

Program.cs

Then in your Program.cs you will want to have the following. The main things to note are AddOcelot() (adds ocelot services), UseOcelot().Wait() (sets up all the Ocelot middleware).

The Program.cs just needs to create and configure the typical ASP.NET Core BuildWebHost.

using System.IO;
   using Microsoft.AspNetCore.Hosting;
   using Microsoft.Extensions.Configuration;
   using Microsoft.Extensions.Hosting;
   using Ocelot.DependencyInjection;
   using Ocelot.Middleware;

   namespace OcelotBasic
   {
       public class Program
       {
           public static void Main(string[] args)
           {
               new WebHostBuilder()
               .UseKestrel()
               .UseContentRoot(Directory.GetCurrentDirectory())
               .ConfigureAppConfiguration((hostingContext, config) =>
               {
                   config
                       .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                       .AddJsonFile("appsettings.json", true, true)
                       .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
                       .AddJsonFile("ocelot.json")
                       .AddEnvironmentVariables();
               })
               .ConfigureServices(s => {
                   s.AddOcelot();
               })
               .ConfigureLogging((hostingContext, logging) =>
               {
                   //add your logging
               })
               .UseIISIntegration()
               .Configure(app =>
               {
                   app.UseOcelot().Wait();
               })
               .Build()
               .Run();
           }
       }
   }