Création d'un proxy pour une autre API Web avec le noyau Asp.net

Je suis l'élaboration d'un ASP.Net de Base de l'application web où j'ai besoin de créer une sorte de "proxy d'authentification" à l'autre (externe) du service web.

Ce que je veux dire par proxy d'authentification est que je vais recevoir des demandes par le biais d'un chemin d'accès spécifique de mon application web et vérifier les en-têtes de ces demandes pour un jeton d'authentification que je vais avoir émis plus tôt, et puis rediriger toutes les demandes avec la même demande de la chaîne /le contenu d'une page web API qui mon application va s'authentifier via HTTP Basic auth.

Voici l'ensemble du processus en pseudo-code

Client demande un jeton en faisant un POST à une URL unique que je lui ai envoyé plus tôt
Mon application lui envoie un jeton unique en réponse à ce POST
Client fait une requête GET vers une URL spécifique de mon application, dire /extapi et ajoute la auth-jeton dans l'en-tête HTTP
Mon application reçoit la requête, il vérifie que l'auth-jeton est présent et valide
Mon appli fait la même demande à l'externe de l'API web et authentifie la demande à l'aide de l'authentification de BASE
Mon application reçoit le résultat de la requête et l'envoie au client

Voici ce que j'ai pour le moment. Il semble fonctionner très bien, mais je me demande si c'est vraiment la façon dont cela doit être fait, si il n'y a pas plus élégant ou une meilleure solution? Pourrait que la solution de créer des problèmes à long terme pour l'accroissement de la demande?

[HttpGet]
public async Task GetStatement()
{
    //TODO check for token presence and reject if issue

    var queryString = Request.QueryString;
    var response = await _httpClient.GetAsync(queryString.Value);
    var content = await response.Content.ReadAsStringAsync();

    Response.StatusCode = (int)response.StatusCode;
    Response.ContentType = response.Content.Headers.ContentType.ToString();
    Response.ContentLength = response.Content.Headers.ContentLength;

    await Response.WriteAsync(content);
}

[HttpPost]
public async Task PostStatement()
{
    using (var streamContent = new StreamContent(Request.Body))
    {
        //TODO check for token presence and reject if issue

        var response = await _httpClient.PostAsync(string.Empty, streamContent);
        var content = await response.Content.ReadAsStringAsync();

        Response.StatusCode = (int)response.StatusCode;

        Response.ContentType = response.Content.Headers.ContentType?.ToString();
        Response.ContentLength = response.Content.Headers.ContentLength;

        await Response.WriteAsync(content);
    }
}

_httpClient être un HttpClient classe instanciée quelque part d'autre et d'être un singleton, et avec un BaseAddressde http://someexternalapp.com/api/

Aussi, est-il une approche plus simple pour le jeton de création /jeton de vérifier que de le faire manuellement?

source d'informationauteur Gimly

11

J'ai fini par mettre en place un proxy middleware inspiré par un projet dans Asp.Net's GitHub.

Essentiellement, il met en œuvre un middleware qui lit la demande reçue, crée une copie de lui et le renvoie à un service configuré, lit la réponse du service et l'envoie à l'appelant.

Ici est une base de mise en œuvre de Proxy de la bibliothèque pour ASP.NET de Base:

Ce n'est pas de mettre en œuvre l'autorisation, mais pourrait être utile pour quelqu'un qui cherche un simple reverse proxy avec ASP.NET de Base. Nous les utilisons uniquement pour les stades de développement.

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

Vous devez vous connecter pour publier un commentaire.