Ocelot .NET (Cómo funciona para desarrolladores)

Pasarela API Ocelot es una biblioteca .NET que implementa el patrón de pasarela de API comúnmente utilizado en pasarelas de API, para gestionar solicitudes a través de múltiples microservicios. Actúa como una pasarela de API ligera, enrutando las peticiones de los clientes a los servicios descendentes. Este artículo ofrece una visión en profundidad de cómo la pasarela API Ocelot se sitúa entre los clientes y los servicios descendentes, cubriendo su instalación, configuración, características clave y ejemplos prácticos para demostrar sus capacidades. También exploraremos IronPDF y Ocelot API combinados.

¿Qué es Ocelot .NET?

Ocelot es una solución de pasarela API de código abierto para aplicaciones .NET, diseñada para facilitar el enrutamiento de solicitudes a través de múltiples microservicios. Actúa como proxy inverso, gestionando las solicitudes HTTP de los clientes y dirigiéndolas a los servicios adecuados en un entorno ASP.NET Core. Desarrollado sobre ASP.NET Core, Ocelot se integra a la perfección con el ecosistema .NET, ofreciendo un sólido conjunto de funciones cruciales para las aplicaciones modernas.

Características principales de Ocelot

Enrutamiento

El núcleo de la funcionalidad de Ocelot es su capacidad de enrutamiento. Hace coincidir las solicitudes entrantes con las rutas de servicio adecuadas en función de la configuración especificada por los desarrolladores, y puede integrarse con mecanismos de descubrimiento de servicios. Esto incluye soporte para enrutamiento comodín, que es particularmente útil cuando se trata de diferentes versiones de API o numerosos puntos finales de servicio.

Middleware / Delegación de gestores

Ocelot permite a los desarrolladores inyectar middleware o manejadores personalizados que pueden procesar peticiones y respuestas antes de que lleguen al cliente o al servicio. Esto resulta útil para añadir cabeceras, registrar solicitudes o incluso modificar la estructura de la respuesta según sea necesario.

Equilibrio de la carga

Ocelot admite diversas estrategias de equilibrio de carga, como Round Robin, Conexión mínima y un proveedor personalizado si ninguna de las estrategias predefinidas se ajusta a las necesidades. Esta función garantiza que la carga se distribuya uniformemente entre los servicios disponibles, lo que mejora la resistencia y la eficacia generales de la aplicación.

Autenticación y autorización

Asegurar los puntos finales de la API es fundamental, y Ocelot ofrece soporte para integrarse con los proveedores de autenticación existentes, como Identity Server. Admite los esquemas de autenticación más conocidos, como JWT y OAuth2, y permite un control detallado del acceso de los usuarios a los servicios.

Limitación de velocidad y QoS

La limitación de tarifas es esencial para evitar abusos y garantizar un uso justo de los servicios, limitando el número de solicitudes que un usuario puede hacer en un periodo determinado. Calidad del servicio (QoS) opciones como el establecimiento de tiempos de espera y reintentos garantizan que los servicios sigan estando disponibles y respondiendo bajo diversas condiciones y cargas de red.

Configuración de Ocelot en un proyecto .NET

Para integrar Ocelot en su proyecto, debe instalar el paquete Ocelot a través de NuGet y configurarlo en la clase Program:

Install-Package IronPdf

Configure los servicios, incluido el middleware de creación de solicitudes, en su clase Startup.cs o Program para configurar el contenedor de servicios:

public void ConfigureServices(IServiceCollection services)
{
    services.AddOcelot();
}
public async void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Optionally handle ASP.NET Core environment settings
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    // Start Ocelot
    await app.UseOcelot();
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddOcelot();
}
public async void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Optionally handle ASP.NET Core environment settings
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    // Start Ocelot
    await app.UseOcelot();
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddOcelot()
End Sub
Public Async Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	' Optionally handle ASP.NET Core environment settings
	If env.IsDevelopment() Then
		app.UseDeveloperExceptionPage()
	End If
	' Start Ocelot
	Await app.UseOcelot()
End Sub

Configuración de rutas en Ocelot

Ocelot utiliza un archivo de configuración, normalmente ocelot.json, para definir las reglas de enrutamiento. A continuación se muestra un ejemplo más complejo que demuestra múltiples configuraciones de rutas:

{
    "ReRoutes": [
        {
            "DownstreamPathTemplate": "/api/users/{id}",
            "DownstreamScheme": "https",
            "DownstreamHostAndPorts": [
                {
                    "Host": "userapi.com",
                    "Port": 443
                }
            ],
            "UpstreamPathTemplate": "/users/{id}",
            "UpstreamHttpMethod": ["Get"]
        },
        {
            "DownstreamPathTemplate": "/api/products/{id}",
            "DownstreamScheme": "https",
            "DownstreamHostAndPorts": [
                {
                    "Host": "productapi.com",
                    "Port": 443
                }
            ],
            "UpstreamPathTemplate": "/products/{id}",
            "UpstreamHttpMethod": ["Get"]
        }
    ],
    "GlobalConfiguration": {
        "BaseUrl": "http://yourgateway.com"
    }
}

Esta configuración especifica cómo se enrutan las peticiones a la pasarela API a diferentes servicios descendentes en función de la ruta y el método HTTP, utilizando el archivo JSON para la configuración.

Uso de IronPDF con Ocelot .NET

Combinación de Ocelot con IronPDF en una aplicación .NET proporciona una potente solución que permite dirigir las solicitudes de generación de PDF a un servicio específico o gestionarlas internamente. Aquí, te guiaré a través de la configuración de una aplicación básica .NET Core que utiliza Ocelot como API Gateway y IronPDF para generar PDF a partir de HTML.

Paso 1: Configurar la aplicación web .NET Core

En primer lugar, cree un nuevo proyecto de API web .NET Core. Puede hacerlo utilizando la CLI de .NET o Visual Studio.

Utilizando la plataforma .NET:

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Paso 2: Añadir los paquetes necesarios

Es necesario instalar Ocelot e IronPDF. Puede añadir estos paquetes a través de NuGet.

dotnet add package Ocelot
dotnet add package IronPdf

Paso 3: Configurar Ocelot

Añade un archivo ocelot.json a la raíz de tu proyecto con el siguiente contenido para configurar el enrutamiento de Ocelot. Esta configuración asume que usted desea que Ocelot dirija las solicitudes de generación de PDF a una ruta específica que será manejada por IronPDF dentro de la misma aplicación.

{
    "ReRoutes": [
        {
            "DownstreamPathTemplate": "/api/pdf",
            "DownstreamScheme": "https",
            "DownstreamHostAndPorts": [
                {
                    "Host": "localhost",
                    "Port": 5001
                }
            ],
            "UpstreamPathTemplate": "/generatepdf",
            "UpstreamHttpMethod": ["Post"]
        }
    ],
    "GlobalConfiguration": {
        "BaseUrl": "http://localhost:5000"
    }
}

Paso 4: Configurar Startup.cs

Actualizar Startup.cs para incluir el middleware de Ocelot. Asegúrese también de configurar su aplicación para utilizar archivos estáticos, ya que IronPDF puede necesitar cargar activos del sistema de archivos local.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddOcelot();
    }
    public async void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseRouting();
        app.UseAuthorization();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
        await app.UseOcelot();
    }
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddOcelot();
    }
    public async void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseRouting();
        app.UseAuthorization();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
        await app.UseOcelot();
    }
}

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddControllers()
		services.AddOcelot()
	End Sub
	Public Async Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		End If
		app.UseRouting()
		app.UseAuthorization()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapControllers()
		End Sub)
		Await app.UseOcelot()
	End Sub
End Class

Paso 5: Implementar la generación de PDF con IronPDF

Cree un nuevo controlador PdfController.cs en la carpeta Controllers. Este controlador gestionará las solicitudes de generación de PDF.

using Microsoft.AspNetCore.Mvc;
using IronPdf;
namespace OcelotWithIronPDF.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class PdfController : ControllerBase
    {
        [HttpPost]
        public IActionResult CreatePdfFromHtml([FromBody] string htmlContent)
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            var output = pdf.BinaryData;
            return File(output, "application/pdf", "generated.pdf");
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using IronPdf;
namespace OcelotWithIronPDF.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class PdfController : ControllerBase
    {
        [HttpPost]
        public IActionResult CreatePdfFromHtml([FromBody] string htmlContent)
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            var output = pdf.BinaryData;
            return File(output, "application/pdf", "generated.pdf");
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Namespace OcelotWithIronPDF.Controllers
	<ApiController>
	<Route("api/[controller]")>
	Public Class PdfController
		Inherits ControllerBase

		<HttpPost>
		Public Function CreatePdfFromHtml(<FromBody> ByVal htmlContent As String) As IActionResult
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
			Dim output = pdf.BinaryData
			Return File(output, "application/pdf", "generated.pdf")
		End Function
	End Class
End Namespace

Paso 6: Ejecutar la aplicación

Asegúrese de que su aplicación está correctamente configurada para escuchar en los puertos especificados en ocelot.json. Puede configurar esto en Properties/launchSettings.json.

{
  "profiles": {
    "OcelotWithIronPDF": {
      "commandName": "Project",
      "launchBrowser": false,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Ahora, ejecute su aplicación, y usted debe ser capaz de enviar contenido HTML a http://localhost:5000/generatepdf y recibirá un PDF como respuesta.

Este ejemplo muestra una implementación básica de Ocelot con IronPDF dentro de la misma aplicación. Para escenarios de producción, considere la posibilidad de proteger sus puntos finales, gestionar escenarios de error y optimizar el proceso de generación de PDF en función de sus requisitos específicos.

Conclusión

En conclusión, Ocelot es una excelente opción para gestionar y enrutar peticiones en una arquitectura de microservicios. Sus sólidas funciones, como el enrutamiento, el equilibrio de carga, la compatibilidad con middleware y la autenticación, lo convierten en una potente herramienta para cualquier desarrollador .NET. Siguiendo los pasos detallados que se proporcionan, podrá integrar Ocelot de forma eficaz en sus proyectos .NET para agilizar sus necesidades de API Gateway.

Además, si necesita funciones de generación de PDF, la integración de IronPDF con Ocelot es sencilla y mejora la funcionalidad de su aplicación. IronPDF ofrece un prueba gratuitay las licencias cuestan a partir de $749, lo que supone una solución rentable para sus necesidades de PDF.

Al aprovechar conjuntamente Ocelot e IronPDF, puede crear una infraestructura de microservicios completa y eficiente que satisfaga tanto los requisitos de enrutamiento como los de generación de documentos.