Does YARP have a feature for caching http responses having public caching directive?

[jessecavada71]

Does YARP have a feature for caching http responses having public caching directive? This feature is intended to reduce load on backend servers by caching http responses having public caching directive then using the cache for future http requests. The cache should only be considered for http(s) requests having a “GET” method. The cache match should include both the resource URL together with the query string. The cache should recognize the http response public caching directive including expiration. The cache should store the http response in a compressed format to avoid having to compress for each cache response. A cached response should add a response header indicating that the response was produced by a cache.

[Tratcher]

You should be able to use ASP.NET Core's existing response caching middleware for this.
https://docs.microsoft.com/en-us/aspnet/core/performance/caching/middleware?view=aspnetcore-5.0

[DrEsteban]

This doesn't appear to be working for me. I have a .NET Core 6.0 app that looks like this:

app.UseResponseCaching();
app.MapControllers();
app.MapReverseProxy(r =>
{
    // Enable response caching
    r.Use((context, next) =>
    {
        context.Response.OnStarting(() =>
        {
            context.Response.GetTypedHeaders().CacheControl = new CacheControlHeaderValue()
            {
                Public = true,
                MaxAge = TimeSpan.FromSeconds(builder.Configuration.GetValue<int>("ResponseCacheDurationSeconds"))
            };
            return Task.CompletedTask;
        });
        return next();
    });
});

app.Run();

Cache-Control headers returned by my Controllers are working as expected, but response caching is NOT working when requests are proxied via YARP. Even though I've verified the Cache-Control headers are identical.

[DrEsteban]

Oops, please disregard... I didn't realize the ResponseCachingMiddleware (rightly) does not cache responses when the Authorization header is specified.

[Patelchirag386]

This may be the solution you are looking for.

app.MapReverseProxy(r =>
{
r.Use(async (context, next) =>
{
var memoryCache = context.RequestServices.GetRequiredService();
var cacheKey = context.Request.Path.ToString();

       if (context.Request.Path.StartsWithSegments("/api/data/getData"))
       {
           
           if (memoryCache.TryGetValue(cacheKey, out string cachedResponse))
           {
               // Serve the cached response
               context.Response.StatusCode = StatusCodes.Status200OK;
               context.Response.ContentType = "application/json";
               await context.Response.WriteAsync(cachedResponse);
               await context.Response.CompleteAsync();
               return; 
           }
           else
           {
               // Set caching headers on the response
               context.Response.OnStarting(() =>
               {
                   context.Response.GetTypedHeaders().CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue
                   {
                       Public = true,
                       MaxAge = TimeSpan.FromSeconds(60)
                   };
                   context.Response.Headers[Microsoft.Net.Http.Headers.HeaderNames.Vary] = new string[] { "Accept-Encoding" };
                   return Task.CompletedTask;
               });

               // Capture the response body for caching
               var originalBodyStream = context.Response.Body;
               using var memoryStream = new MemoryStream();
               context.Response.Body = memoryStream;

               await next();

               // Cache the response
               if (context.Response.StatusCode == StatusCodes.Status200OK)
               {
                   memoryStream.Seek(0, SeekOrigin.Begin);
                   cachedResponse = new StreamReader(memoryStream).ReadToEnd();
                   memoryCache.Set(cacheKey, cachedResponse, TimeSpan.FromMinutes(1));

                   // Write the cached response to the original body stream
                   memoryStream.Seek(0, SeekOrigin.Begin);
                   await memoryStream.CopyToAsync(originalBodyStream);
               }
               context.Response.Body = originalBodyStream;
           }
       }
       else
       {
           await next();
       }
   });

});