YARP: El «Muro de Contención» que tu Arquitectura Necesita

Imagina que eres el portero de la discoteca más exclusiva de la ciudad. Tienes una fila enorme de gente (tus usuarios) queriendo entrar, y adentro hay varias salas VIP (tus microservicios). Sin un proxy, los clientes intentarían entrar por la ventana, la cocina o incluso por el conducto de ventilación. Caos total.

Un Reverse Proxy es ese portero elegante que dice: «Tú vas para la API de pagos, tú para el catálogo, y tú… bueno, tú no tienes token, así que a tu casa». YARP es ese portero, pero con esteroides de .NET y que además sabe hacer malabares con el tráfico.

¿Por qué debería importarte?

Si expones tus microservicios directamente al internet salvaje, estás pidiendo problemas a gritos. YARP te ayuda a:

• Centralizar la seguridad: Autentica en un solo lugar.
• Balanceo de carga: No quemes un servidor mientras el otro duerme la siesta.
• Abstracción: Puedes cambiar tus servidores internos de IP o nombre sin que el cliente se entere de nada.
• Felicidad del desarrollador: Se configura en C# o JSON. ¡Nada de archivos .conf extraños!

Manos a la Obra

Primero, necesitamos el arma secreta. En tu terminal favorita (o en el Package Manager si eres de la vieja escuela):

dotnet add package Yarp.ReverseProxy

El «Antes» (Program.cs aburrido y vacío)

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.Run();

El «Después» (Program.cs con superpoderes)

var builder = WebApplication.CreateBuilder(args);

// 1. Añadimos el servicio del portero (YARP)
builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

var app = builder.Build();

// 2. Le decimos a la app que use el mapa de rutas
app.MapReverseProxy();

app.Run(); // ¡Listo! El portero ya está en la puerta.

Aquí es donde ocurre la magia. Vamos a redirigir todo el tráfico que llegue a /api/tienda/ hacia nuestro servidor de backend.

{
  "ReverseProxy": {
    "Routes": {
      "ruta_compras": {
        "ClusterId": "cluster_servidores_vip",
        "Match": {
          "Path": "/api/tienda/{**catch-all}" 
        }
      }
    },
    "Clusters": {
      "cluster_servidores_vip": {
        "Destinations": {
          "servidor_1": {
            "Address": "https://localhost:7001/" // El servidor real donde vive el código
          }
        }
      }
    }
  }
}

Comentario: {**catch-all} es como decir «y todo lo que venga después». No seas tacaño con los asteriscos.

El Veredicto

Pros:

• Es .NET puro: Si sabes C#, sabes YARP. Puedes extenderlo con middlewares personalizados sin aprender otro lenguaje.
• Performance: Es increíblemente rápido. Microsoft lo usa para sus propios servicios (y esos tipos tienen tráfico de sobra).

Contras:

• Overhead: Si solo tienes una web sencilla, poner un proxy es como comprar un tráiler para ir a por el pan.
• Configuración: Aunque es fácil, si te equivocas en un ClusterId en el JSON, te vas a pasar 20 minutos debugueando por qué recibes un 404.

Conclusión

Ya tienes a tu portero configurado. YARP es la navaja suiza para migrar aplicaciones legacy (el famoso patrón Strangler Fig), hacer A/B testing o simplemente dormir tranquilo sabiendo que tus microservicios están protegidos.

Reto: Intenta configurar YARP para que redirija el tráfico a Google solo cuando el Header de la petición sea X-I-Am-Lazy: true. ¡Si lo logras, habrás alcanzado el nivel de Arquitecto de Sombras