Route a request to CDN backend

[milen-denev]

After reading the docs i think maybe this is the correct approach:

app.MapReverseProxy(proxyPipeline =>
{
    proxyPipeline.Use((context, next) =>
    {
        var proxyFeature = context.GetReverseProxyFeature();
        var destinations = proxyFeature.AvailableDestinations;

        var destinationState = new DestinationState("cdnDefault", new DestinationModel(new DestinationConfig()
        {
            Address = "https://cdn.mydomain.net/some-location"
        }));
 
        proxyFeature.Route.Config.WithTransform(x => x.Add("PathSet", "/some-id"));

        proxyFeature.AvailableDestinations = new List<DestinationState>() { destinationState }.AsReadOnly();

        return next();
    });
    proxyPipeline.UseSessionAffinity();
    proxyPipeline.UseLoadBalancing();
    proxyPipeline.UsePassiveHealthChecks();
});

but after checking the logs instead of routing to https://cdn.mydomain.net/some-location/some-id it routes to https://cdn.mydomain.net/some-location + PathString .

I tried also Address = "https://cdn.mydomain.net/some-location/some-id" but again not having the correct result since it adds the PathString no matter what.

[Tratcher]

The route transforms can't be modified in middleware per request. Add that destination and transform in config when defining your route.

https://microsoft.github.io/reverse-proxy/articles/config-files.html

{
  "ReverseProxy": {
    "Routes": {
      "route1" : {
        "ClusterId": "cluster1",
        "Match": {
          "Path": "{**catch-all}",
        },
        "Transforms": [
          { "PathSet": "/some-id" }
        ]
      }
    },
    "Clusters": {
      "cluster1": {
        "Destinations": {
          "cluster1/destination1": {
            "Address": "https://cdn.mydomain.net/some-location"
          }
        }
      }
    }
  }
}

If you need more flexibility then try https://microsoft.github.io/reverse-proxy/articles/direct-forwarding.html

[milen-denev]

Thank you very much for the suggestion Chris.

But the thing is that the /some-id is the hash of the path and the domain. Long story short I made something like a web server which has caching. But instead of using local SSD I wanted to try just redirecting traffic to a CDN.
I was wondering if it's currently supported based on the incoming request URL to redirect to some other URL with config during runtime. (Also note that there are 10s of thousands of pages dynamically expiring and invalidated by a background service. So changing a JSON file or using the LoadFromMemory() is not a viable option),

The way I wish I make it work:

Incoming request: https://mydomain.com/product/my-product
↓
Get CRC-64 hash of the 'mydomain.com/product/my-product': 23E185D6D2DAA582
↓
Check if 23E185D6D2DAA582 is cached
↓ [If True]
Forward the request to 'cdn.other-domain.net/cache-container/23E185D6D2DAA582
↓ [If False]
Continue down the pipeline (Logging, Caching, so on so forth)

I tried some shenanigans with the non other than the Azure CDN (and it's Rules Engine) without success. I came to the conclusion it's not possible.

[MihaZupan]

Using direct forwarding that Chris mentioned is likely the easiest option to achieve what you're trying to do: https://microsoft.github.io/reverse-proxy/articles/direct-forwarding.html

For example, you can have a middleware before YARP that looks something like this (untested):

var httpClient = new HttpMessageInvoker(new SocketsHttpHandler()
{
    // ...
});

app.Use(async (context, next) =>
{
    var id = GetHash(context.Request.Path);

    if (IsCached(id))
    {
        context.Request.Path = $"cache-container/{id}";
        var forwarder = context.RequestServices.GetRequiredService<IHttpForwarder>();
        await forwarder.SendAsync(context, "https://cdn.other-domain.net/", httpClient);
    }
    else
    {
        // Fall back to regular forwarding
        await next(context);
    }
});

// Fallback configuration
app.MapReverseProxy();

[MihaZupan]

Note however that this will still mean that all the data will be flowing from the CDN, through the proxy, and then back to the client.
If you're using the CDN to lower egress costs, reduce latencies, or reduce the load on the proxy, you may want to redirect the request to the CDN instead of proxying to it.

[milen-denev]

Thanks a lot Miha for your answer. For anyone interested this is my code:

public class CdnCacheMiddleware : IMiddleware
{
    private IHttpForwarder forwarder;
    private static readonly HttpMessageInvoker httpClient = new HttpMessageInvoker(new SocketsHttpHandler()
    {
    });

    public CdnCacheMiddleware(IHttpForwarder httpForwarder)
    {
        this.forwarder = httpForwarder;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        string path = context.Request.Path + context.Request.QueryString;
        var hashedString = GetHash(context.Request.Host.Host + path);

        //Concurrent Dictionary Holding in-memory records 
        if (CacheRecords.TryGetValue(hashedString, out _))
        {
            context.Request.Path = $"/cache-container/{hashedString}";
            //Decided to use Azure Storage Premium Blob for backend instead of CDN
            await forwarder.SendAsync(context, "https://storage-app.blob.core.windows.net", httpClient);
        }
        else
        {
            await next(context);
        }
    }
}

I saw big uplift in performance but not in latency reduction. Although going from 3ms up to 7ms in load testing benchmarks is not that big of a deal since serving website in 3ms or 7ms is impossible to be noted by a user.

Previous code:

public class DriveCacheMiddleware : IMiddleware
{
    public DriveCacheMiddleware()
    {

    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        string path = context.Request.Path + context.Request.QueryString;
        var hashedString = GetHash(context.Request.Host.Host + path);

        //Concurrent Dictionary Holding in-memory records 
        if (CacheRecords.TryGetValue(hashedString, out _))
        {
            using SafeFileHandle handle = File.OpenHandle(FilePathAndPath, FileMode.Open, FileAccess.Read, FileShare.Read, FileOptions.SequentialScan);
            int length = (int)RandomAccess.GetLength(handle);
            Span<byte> buffer = stackalloc byte[length];
            RandomAccess.Read(handle, buffer, 0);
            Memory<byte> _fileMemory = new Memory<byte>(new byte[length]);
            buffer.CopyTo(bufferMemory.Span);

           await context.Response.BodyWriter.WriteAsync(_fileMemory);
        }
        else
        {
            await next(context);
        }
    }
}

[Tratcher]

While this works, I will warn that directly setting Request.Path to the proxy path can have side-effects in the app such as confusing logs. The cleaner option is to set it on the outbound request in a transform.

reverse-proxy/samples/ReverseProxy.Direct.Sample/Program.cs

Lines 43 to 55 in 8de4032

	var error = await forwarder.SendAsync(httpContext, "https://example.com", httpClient, requestOptions,
	static (context, proxyRequest) =>
	{
	// Customize the query string:
	var queryContext = new QueryTransformContext(context.Request);
	queryContext.Collection.Remove("param1");
	queryContext.Collection["area"] = "xx2";
	// Assign the custom uri. Be careful about extra slashes when concatenating here. RequestUtilities.MakeDestinationAddress is a safe default.
	proxyRequest.RequestUri = RequestUtilities.MakeDestinationAddress("https://example.com", context.Request.Path, queryContext.QueryString);
	// Suppress the original request header, use the one from the destination Uri.
	proxyRequest.Headers.Host = null;

    var error = await forwarder.SendAsync(httpContext, "https://storage-app.blob.core.windows.net", httpClient, requestOptions,
        static (context, proxyRequest) =>
        {
            string path = context.Request.Path + context.Request.QueryString;
            var hashedString = GetHash(context.Request.Host.Host + path);
            proxyRequest.RequestUri = RequestUtilities.MakeDestinationAddress("https://storage-app.blob.core.windows.net", $"/cache-container/{hashedString}");

            // Suppress the original request header, use the one from the destination Uri.
            proxyRequest.Headers.Host = null;

            return default;
        });