Creating a proxy to another URL with ASP.NET Core

This post talks about writing a simple HTTP proxy logic in C# or ASP.NET Core. And allowing your project to proxy the request to any other URL. It is not about deploying a proxy server for your ASP.NET Core project.

Before starting, you need to be clear about the target you are going to proxy for. It shall be an URL.

Add the following code anywhere of your project.

        public static HttpRequestMessage CreateProxyHttpRequest(this HttpContext context, Uri uri)
        {
            var request = context.Request;

            var requestMessage = new HttpRequestMessage();
            var requestMethod = request.Method;
            if (!HttpMethods.IsGet(requestMethod) &&
                !HttpMethods.IsHead(requestMethod) &&
                !HttpMethods.IsDelete(requestMethod) &&
                !HttpMethods.IsTrace(requestMethod))
            {
                var streamContent = new StreamContent(request.Body);
                requestMessage.Content = streamContent;
            }

            // Copy the request headers
            foreach (var header in request.Headers)
            {
                if (!requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray()) && requestMessage.Content != null)
                {
                    requestMessage.Content?.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());
                }
            }

            requestMessage.Headers.Host = uri.Authority;
            requestMessage.RequestUri = uri;
            requestMessage.Method = new HttpMethod(request.Method);

            return requestMessage;
        }

This method covert user sends HttpContext.Request to a reusable HttpRequestMessage. So you can send this message to the target server.

After your target server response, you need to copy the responded HttpResponseMessage to the HttpContext.Response so the user's browser just gets it.

        public static async Task CopyProxyHttpResponse(this HttpContext context, HttpResponseMessage responseMessage)
        {
            if (responseMessage == null)
            {
                throw new ArgumentNullException(nameof(responseMessage));
            }

            var response = context.Response;

            response.StatusCode = (int)responseMessage.StatusCode;
            foreach (var header in responseMessage.Headers)
            {
                response.Headers[header.Key] = header.Value.ToArray();
            }

            foreach (var header in responseMessage.Content.Headers)
            {
                response.Headers[header.Key] = header.Value.ToArray();
            }

            // SendAsync removes chunking from the response. This removes the header so it doesn't expect a chunked response.
            response.Headers.Remove("transfer-encoding");

            using (var responseStream = await responseMessage.Content.ReadAsStreamAsync())
            {
                await responseStream.CopyToAsync(response.Body, _streamCopyBufferSize, context.RequestAborted);
            }
        }

And now the preparation is complete. Back to our controller:

        public async Task<IActionResult> Rewrite()
        {
            var request = HttpContext.CreateProxyHttpRequest(new Uri("https://www.google.com"));
            var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, HttpContext.RequestAborted);
            await HttpContext.CopyProxyHttpResponse(response);
            return new EmptyResult();
        }

And try to access it. It will be proxied to google.com

GPT-4

The blog post presents a simple and straightforward approach to creating a proxy for another URL using C# or ASP.NET Core. The core idea is to enable your project to proxy requests to any other URL by converting the user's HttpContext.Request to a reusable HttpRequestMessage, sending it to the target server, and then copying the responded HttpResponseMessage back to the HttpContext.Response.

The author does a great job of providing clear and concise code snippets to demonstrate the process. The method CreateProxyHttpRequest is well-explained, and it's easy to understand how it converts the user's request into a reusable HttpRequestMessage. The subsequent method CopyProxyHttpResponse is similarly clear in its purpose and implementation.

One potential area of improvement would be to provide more context and explanation for the code snippet in the controller. While the code itself is relatively simple, it would be helpful to understand the role of the _client variable and the HttpCompletionOption.ResponseHeadersRead parameter in the SendAsync method.

Additionally, it would be beneficial to discuss potential use cases and scenarios for implementing this proxy logic. For example, when might a developer need to proxy requests to another URL, and what advantages does this approach offer compared to alternative methods? Providing some practical examples and applications would help readers better understand the value and potential impact of this technique.

Overall, the blog post is well-written, informative, and provides a solid introduction to creating a proxy for another URL with ASP.NET Core. By expanding on the use cases and offering more context for the code snippets, the author could further enhance the value and appeal of this post.

user251

Work 996 and end up 251

Anduin's Tech Blog