Создание прокси для другого веб-API с ядром Asp.net

Если кому-то интересно, я взял код Microsoft.AspNetCore.Proxy и немного улучшил его с помощью промежуточного программного обеспечения.

Проверьте это здесь: https://github.com/twitchax/AspNetCore.Proxy. NuGet здесь: https://www.nuget.org/packages/AspNetCore.Proxy/. Microsoft заархивировала другой, упомянутый в этом посте, и я планирую ответить на любые вопросы по этому проекту.

По сути, это значительно упрощает обратное проксирование другого веб-сервера, позволяя использовать атрибуты в методах, которые выбирают маршрут с аргументами и вычисляют проксируемый адрес.

[ProxyRoute("api/searchgoogle/{query}")]
public static Task<string> SearchGoogleProxy(string query)
{
    // Get the proxied address.
    return Task.FromResult($"https://www.google.com/search?q={query}");
}

В итоге я реализовал промежуточное ПО прокси, вдохновленное проектом в GitHub от Asp.Net.

Он в основном реализует промежуточное программное обеспечение, которое считывает полученный запрос, создает из него копию и отправляет ее обратно в настроенную службу, считывает ответ от службы и отправляет его обратно вызывающей стороне.

В этом посте рассказывается о написании простой логики HTTP-прокси на C # или ASP.NET Core. И позволяя вашему проекту проксировать запрос на любой другой URL. Речь идет не о развертывании прокси-сервера для вашего проекта ASP.NET Core.

Добавьте следующий код в любое место вашего проекта.

        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;
        }

Этот метод скрытого пользователя отправляет HttpContext.Request повторно используемому HttpRequestMessage. Таким образом, вы можете отправить это сообщение на целевой сервер.

После ответа вашего целевого сервера вам нужно скопировать ответ HttpResponseMessage в HttpContext.Response, чтобы браузер пользователя просто его получил.

        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);
            }
        }

И вот подготовка завершена. Вернемся к нашему контроллеру:

    private readonly HttpClient _client;

    public YourController()
    {
        _client = new HttpClient(new HttpClientHandler()
        {
            AllowAutoRedirect = false
        });
    }

        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 Ok();
        }

И попробуйте получить к нему доступ. Он будет проксирован на google.com

Хорошую реализацию промежуточного программного обеспечения обратного прокси-сервера также можно найти здесь: https://auth0.com/blog/building-a-reverse-proxy-in-dot-net-core/

Обратите внимание, что я заменил эту строку здесь

requestMessage.Content?.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());

с участием

requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.ToString());

Исходные заголовки (например, заголовок авторизации с токеном-носителем) не будут добавлены без моей модификации в моем случае.

Мне посчастливилось использовать пакет NuGet AspNetCore.Proxy от Twitchax, но я не смог заставить его работать с помощью ProxyRoute метод, показанный в ответе twitchax. (С моей стороны это легко могло быть ошибкой.)

Вместо этого я определил отображение в методе Statup.cs Configure (), аналогичном приведенному ниже коду.

app.UseProxy("api/someexternalapp-proxy/{arg1}", async (args) =>
{
    string url = "https://someexternalapp.com/" + args["arg1"];
    return await Task.FromResult<string>(url);
});

Поддержка ответа Джеймса Лоурука https://stackoverflow.com/a/54149906/6596451 для получения атрибута прокси twitchax чтобы работать, я также получал ошибку 404, пока я не указал полный маршрут в атрибуте ProxyRoute. У меня был свой статический маршрут в отдельном контроллере, и относительный путь от маршрута контроллера не работал.

Это сработало:

public class ProxyController : Controller
{
    [ProxyRoute("api/Proxy/{name}")]
    public static Task<string> Get(string name)
    {
        return Task.FromResult($"http://www.google.com/");
    }
}

Это не так:

[Route("api/[controller]")]
public class ProxyController : Controller
{
    [ProxyRoute("{name}")]
    public static Task<string> Get(string name)
    {
        return Task.FromResult($"http://www.google.com/");
    }
}

Надеюсь, это кому-то поможет!

Вот базовая реализация библиотеки прокси для ASP.NET Core:

Это не реализует авторизацию, но может быть полезно тем, кто ищет простой обратный прокси-сервер с ASP.NET Core. Мы используем это только на этапах разработки.

using System;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Primitives;

namespace Sample.Proxy
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddLogging(options =>
            {
                options.AddDebug();
                options.AddConsole(console =>
                {
                    console.IncludeScopes = true;
                });
            });

            services.AddProxy(options =>
            {
                options.MessageHandler = new HttpClientHandler
                {
                    AllowAutoRedirect = false,
                    UseCookies = true 
                };

                options.PrepareRequest = (originalRequest, message) =>
                {
                    var host = GetHeaderValue(originalRequest, "X-Forwarded-Host") ?? originalRequest.Host.Host;
                    var port = GetHeaderValue(originalRequest, "X-Forwarded-Port") ?? originalRequest.Host.Port.Value.ToString(CultureInfo.InvariantCulture);
                    var prefix = GetHeaderValue(originalRequest, "X-Forwarded-Prefix") ?? originalRequest.PathBase;

                    message.Headers.Add("X-Forwarded-Host", host);
                    if (!string.IsNullOrWhiteSpace(port)) message.Headers.Add("X-Forwarded-Port", port);
                    if (!string.IsNullOrWhiteSpace(prefix)) message.Headers.Add("X-Forwarded-Prefix", prefix);

                    return Task.FromResult(0);
                };
            });
        }

        private static string GetHeaderValue(HttpRequest request, string headerName)
        {
            return request.Headers.TryGetValue(headerName, out StringValues list) ? list.FirstOrDefault() : null;
        }

        public void Configure(IApplicationBuilder app)
        {
            app.UseWebSockets()
                .Map("/api", api => api.RunProxy(new Uri("http://localhost:8833")))
                .Map("/image", api => api.RunProxy(new Uri("http://localhost:8844")))
                .Map("/admin", api => api.RunProxy(new Uri("http://localhost:8822")))
                .RunProxy(new Uri("http://localhost:8811"));
        }

        public static void Main(string[] args)
        {
            var host = new WebHostBuilder()
                .UseKestrel()
                .UseIISIntegration()
                .UseStartup<Startup>()
                .Build();

            host.Run();
        }
    }
}

Ответ Twitchax кажется лучшим решением на данный момент. Изучая это, я обнаружил, что Microsoft разрабатывает более надежное решение, которое точно соответствует той проблеме, которую OP пытался решить.

Репо: https://github.com/microsoft/reverse-proxy

Статья для предварительного просмотра 1 (на самом деле они только что выпустили предыдущий 2): https://devblogs.microsoft.com/dotnet/introduction-yarp-preview-1/

Из статьи ...

YARP - это проект по созданию обратного прокси-сервера. Все началось, когда мы заметили ряд вопросов от внутренних команд в Microsoft, которые либо создавали обратный прокси для своей службы, либо спрашивали об API и технологиях для его создания, поэтому мы решили собрать их всех вместе для работы над общим решением. , который стал YARP.

YARP - это набор инструментов обратного прокси для создания быстрых прокси-серверов в .NET с использованием инфраструктуры из ASP.NET и .NET. Ключевым отличием YARP является то, что его легко настраивать и настраивать в соответствии с конкретными потребностями каждого сценария развертывания. YARP подключается к конвейеру ASP.NET для обработки входящих запросов, а затем имеет собственный вспомогательный конвейер для выполнения шагов по проксированию запросов к внутренним серверам. Клиенты могут добавлять дополнительные модули или заменять стандартные модули по мере необходимости.
...
YARP работает с .NET Core 3.1 или .NET 5 preview 4 (или новее). Загрузите предварительную версию 4 (или более позднюю) пакета SDK для .NET 5 со страницы https://dotnet.microsoft.com/download/dotnet/5.0

В частности, одно из их примеров приложений реализует аутентификацию (как и для исходного намерения OP) https://github.com/microsoft/reverse-proxy/blob/master/samples/ReverseProxy.Auth.Sample/Startup.cs