YARP (Yet Another Reverse Proxy) è una potente libreria .NET che permette di creare server reverse proxy ad alte prestazioni, pronti per la produzione e altamente personalizzabili.
Per gli sviluppatori impazienti di buttarsi nel codice, il progetto completo è disponibile su GitHub: APIGateway.NET
Perché usare YARP?
YARP (Yet Another Reverse Proxy) emerge come un’alternativa chiara e potente a Ocelot per l’implementazione di API Gateway in .NET. Offre una soluzione robusta e flessibile, particolarmente adatta per progetti moderni basati su architetture a microservizi.
- Semplicità e Chiarezza: A differenza di Ocelot, YARP offre un’API più intuitiva e una documentazione più completa. La sua struttura e il suo utilizzo sono progettati per essere più facilmente comprensibili, riducendo la curva di apprendimento per gli sviluppatori.
- Prestazioni Superiori: YARP è ottimizzato per offrire prestazioni elevate, superando Ocelot in scenari di carico intensivo. Supporta nativamente HTTP/2 e gRPC, rendendolo ideale per applicazioni moderne che richiedono alte prestazioni e bassa latenza.
- Maggiore Flessibilità: YARP permette una personalizzazione più granulare rispetto a Ocelot. Gli sviluppatori possono facilmente estendere e modificare il comportamento del proxy direttamente attraverso il codice .NET, offrendo un controllo più preciso sulla logica di routing e trasformazione delle richieste.
Implementazione Step-by-Step
Ora che abbiamo compreso cos’è YARP e perché usarlo, passiamo all’implementazione seguendo un approccio passo dopo passo.
1. Inizializzazione Soluzione
2. Configurazione Progetto APIGateway
Dopo aver creato i due progetti necessari per implementare il gateway, procediamo con la configurazione del progetto che fungerà da punto d’ingresso.
2.1 Configurazione YARP
Per installare la libreria YARP.ReverseProxy è necessario aprire il NuGet Package Manager oppure utilizzare il seguente comando:
dotnet add package Yarp.ReverseProxy
2.2 Registrazione Servizio
Adesso che abbiamo installato la libreria, possiamo procedere con la sua registrazione. Per fare questo, facciamo riferimento al codice evidenziato.
using System.Threading.RateLimiting;
using Microsoft.AspNetCore.RateLimiting;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddControllers();
builder.Services.AddHealthChecks();
// YARP - Register Service
builder.Services.AddReverseProxy().LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
builder.Services.AddSwaggerGen();
// YARP - Configure RateLimiter Service to prevent DoS attacks
builder.Services.AddRateLimiter(options =>
{
options.AddFixedWindowLimiter("customPolicy", opt =>
{
opt.PermitLimit = 1;
opt.Window = TimeSpan.FromSeconds(4);
opt.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
opt.QueueLimit = 1;
});
});
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.MapControllers();
app.MapHealthChecks("healthy");
// YARP - Configure RateLimiter Application Part to prevent DoS attacks
app.UseRateLimiter();
// YARP - Add Application Part
app.MapReverseProxy();
await app.RunAsync();
2.3 Configurazione Rotte
Affinché il gateway operi correttamente, è indispensabile configurare le rotte delle diverse applicazioni che saranno ospitate. Modifichiamo il file appsettings.json aggiungendo la seguente configurazione:
"ReverseProxy": {
"Routes": {
"get-customers": {
"ClusterId": "customers",
"RateLimiterPolicy": "customPolicy",
"Match": {
"Path": "/customers/all",
"Methods": [
"GET"
]
}
},
"create-customer": {
"ClusterId": "customers",
"Match": {
"Path": "/customers/create",
"Methods": [
"POST"
]
},
"Transforms": [
{
"RequestHeader": "X-Added-Website",
"Set": "https://CosminIrimescu.COM"
}
]
}
},
"Clusters": {
"customers": {
"Destinations": {
"customers/destination1": {
"Address": "http://localhost:5010/"
}
}
}
}
}
3. Configurazione Progetto APIGateway.Customers
Dopo aver configurato il gateway, passiamo ora all’implementazione del microservizio che esporrà le nostre API attraverso l’APIGateway. Questo progetto conterrà i controller e la logica di business che verranno accessibili tramite il nostro reverse proxy.
3.1 Implementazione CustomersController
Implementiamo ora un controller che esporrà due endpoint API essenziali: un GET per recuperare la lista dei customers e un POST per aggiungere nuovi customers, utilizzando una lista statica in memoria come semplice ‘database’ dimostrativo.
using Microsoft.AspNetCore.Mvc;
namespace APIGateway.Customers.Controllers;
[ApiController]
[Route("[controller]/[action]")]
public class CustomersController : ControllerBase
{
private static readonly List<string> _customers = ["Cst1", "Cst2", "Cst3"];
[HttpGet]
public Task<IActionResult> All()
{
return Task.FromResult<IActionResult>(Ok(_customers));
}
[HttpPost]
public Task<IActionResult> Create([FromQuery] string customer)
{
const string HeaderKeyName = "X-Added-Website";
Request.Headers.TryGetValue(HeaderKeyName, out var headerValue);
_customers.Add(customer);
return Task.FromResult<IActionResult>(Ok(new
{
Customers = _customers,
CustomHeader = headerValue
}));
}
}
3.2 Registrazione Controllers
Con l’introduzione di .NET 8, il template ASP.NET Core Web API non registra più automaticamente i controller. Pertanto, dobbiamo modificare il file Program.cs per aggiungere manualmente la registrazione e la mappatura dei controller, come mostrato nel codice seguente.
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddControllers();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.MapControllers();
await app.RunAsync();
4. Test Gateway
5000, mentre APIGateway.Customers è impostato per girare sulla porta 5010. Con entrambe le applicazioni in esecuzione, possiamo aprire un terminale e testare il gateway utilizzando i seguenti comandi curl:4.1 Creazione di un nuovo customer
curl --location --request POST 'http://localhost:5000/customers/create?customer=nuovo%20cst'
4.2 Elenco dei customers
curl --location 'http://localhost:5000/customers/all'
Conclusione
In questo articolo abbiamo esaminato come utilizzare YARP per implementare un gateway API in ASP.NET Core. Abbiamo configurato il progetto, creato i controller necessari e testato le API tramite il gateway, esplorando le potenzialità di YARP nella gestione delle richieste. Ora sei pronto a integrare un potente gateway nella tua architettura.
Ora Tocca a Te
- Condividi nei commenti le tue esperienze e le tue opinioni sull’uso di YARP per il routing delle API.
- Aiuta altri sviluppatori a scoprire YARP condividendo questo articolo.
- Iscriviti alla newsletter per ricevere altri contenuti interessanti su ASP.NET Core e migliorare le tue competenze!