My experience with Ocelot as an entry point to an app was mostly good. I like that it is cloud-agnostic – it’s good to go on Azure, AWS, or whatever.

The biggest issue I had was with route configuration. You are stuck writing a static config file (separate from appsettings.json) or creating an overkill provider.

In my dev environment, I used Ocelot’s config file and my routes all pointed to localhost. But when deploying to the cloud, did I really want to create another config file (ocelot.production.json) just for a different hostname or port? My solution was to dynamically build the routes at runtime using injected ENV variables.

Step 1: Create a config template

You will still need to define some configuration beforehand.

To keep things simple, I used my ocelot.json as a basis, but you can read from any data source. I appended the "Target": "app1" field as an identifier.

{
  "Routes": [
    {
      "Target": "app1",
      "UpstreamHttpMethod": [
        "GET"
      ],
      "UpstreamPathTemplate": "/api/page1",
      "DownstreamPathTemplate": "/page1",
      "DownstreamScheme": "https",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5001
        }
      ]
    }
  ]
}

Step 2: Read the config and format it for Ocelot

Reading ocelot.json:

var file = File.ReadAllText(Path.Combine(builder.Environment.ContentRootPath, "ocelot.json"));
var json = JsonNode.Parse(file)!;

This produces a JSON object in the format of Ocelot’s configuration. I then replaced the data in the Routes array with the new hostnames by matching the Target in ocelot.json with my desired replacement values.

The following data represents gatewayConfig.

[
  {
    "Target": "app1",
    "Scheme": "https",
    "Host": "brettnamba.com",
    "Port": 5002
  }
]

gatewayConfig is then used to match the replacement target and replaces the scheme, host, and port.

// For each route in ocelot.json
var routes = (json["Routes"] as JsonArray)!;
for (var i = 0; i < routes.Count; i++)
{
    var route = (routes[i] as JsonObject)!;
    var target = route["Target"] ?? throw new ArgumentException($"No target found for route at {i}");

    // Find the replacement values
    var targetApp = gatewayConfig.GetByName(target.GetValue<string>());

    // Update the route entry with the replacement values
    route["DownstreamScheme"] = targetApp.Scheme;
    route["DownstreamHostAndPorts"] = new JsonArray()
    {
        new JsonObject()
        {
            { "Host", targetApp.Host },
            { "Port", targetApp.Port },
        }
    };
}

Step 3: Load the JSON object to Ocelot config

The JSON object now has the replaced values and can be passed to Ocelot. You do this by using the classes in Ocelot.Configuration.File which represent Ocelot’s route configuration.

var ocelotConfig = new Ocelot.Configuration.File.FileConfiguration();
// Set the routes
ocelotConfig.Routes = JsonSerializer.Deserialize<List<FileRoute>>(routes.ToJsonString());
// Apply the config (builder is of type WebApplicationBuilder)
builder.Configuration.AddOcelot(ocelotConfig, Path.Combine(builder.Environment.ContentRootPath, "ocelot_override.json"));

Conclusion

Using this pattern, I built a gatewayConfig with multiple targets for multiple microservices, all with different ports and hostnames. These are injected into the app at runtime as ENV variables and simply replace the existing dev values for hostname and port.

Gotchas

• When you add the Ocelot config to your app builder (builder.Configuration.AddOcelot(ocelotConfig, Path.Combine(builder.Environment.ContentRootPath, "ocelot_override.json")), it will write the config to a file. I specified a new file ocelot_override.json and added it to .gitignore.
• The override needs to be writeable when building a Docker image from Microsoft’s ASP.NET image (mcr.microsoft.com/dotnet/aspnet:8.0)

USER root
RUN echo '' > ocelot_override.json && \
    chown app:app ocelot_override.json && \
    chmod 644 ocelot_override.json
USER app