Ocelot .NET (Como funciona para desenvolvedores)

Roteamento

A principal funcionalidade do Ocelot é sua capacidade de roteamento. Ele relaciona as solicitações recebidas às rotas de serviço apropriadas com base na configuração especificada pelos desenvolvedores e pode ser integrado a mecanismos de descoberta de serviços. Isso inclui suporte para roteamento curinga, o que é particularmente útil ao lidar com versões de API variáveis ​​ou inúmeros endpoints de serviço.

Middleware / Manipuladores de delegação

O Ocelot permite que os desenvolvedores injetem middleware ou manipuladores personalizados que podem processar solicitações e respostas antes que elas cheguem ao cliente ou ao serviço. Isso é útil para adicionar cabeçalhos, registrar solicitações ou até mesmo modificar a estrutura da resposta conforme necessário.

Balanceamento de carga

O Ocelot oferece suporte a diversas estratégias de balanceamento de carga prontas para uso, como Round Robin, Menor Conexão e um provedor personalizado caso nenhuma das estratégias predefinidas atenda aos requisitos. Essa funcionalidade garante que a carga seja distribuída uniformemente entre os serviços disponíveis, aumentando a resiliência e a eficiência geral da aplicação.

Autenticação e Autorização

Garantir a segurança dos endpoints da API é fundamental, e o Ocelot oferece suporte para integração com provedores de autenticação existentes, como o Identity Server. Ele oferece suporte a esquemas de autenticação populares, incluindo JWT e OAuth2, e permite um controle preciso sobre o acesso do usuário aos serviços.

Limitação de taxa e QoS

A limitação de taxa é essencial para prevenir abusos e garantir o uso justo dos serviços, limitando o número de solicitações que um usuário pode fazer em um determinado período. Opções de Qualidade de Serviço (QoS), como a configuração de tempos limite e novas tentativas, garantem que os serviços permaneçam disponíveis e responsivos sob diversas condições e cargas de rede.

Etapa 1: Configurar o aplicativo Web .NET Core

Primeiro, crie um novo projeto de API Web .NET Core . Você pode fazer isso usando a CLI do .NET ou o Visual Studio.

Utilizando a CLI do .NET :

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Passo 2: Adicionar os pacotes necessários

Você precisa instalar o Ocelot e o IronPDF. Você pode adicionar esses pacotes via NuGet.

dotnet add package Ocelot
dotnet add package IronPdf

dotnet add package Ocelot
dotnet add package IronPdf

Etapa 3: Configurar o Ocelot

Adicione um arquivo ocelot.json à raiz do seu projeto com o seguinte conteúdo para configurar o roteamento do Ocelot. Esta configuração pressupõe que você deseja que o Ocelot direcione as solicitações de geração de PDF para um caminho específico que será tratado pelo IronPDF dentro do mesmo aplicativo.

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

Etapa 4: Configurar o arquivo Startup.cs

Atualize o arquivo Startup.cs para incluir o middleware do Ocelot. Certifique-se também de configurar seu aplicativo para usar arquivos estáticos, pois o IronPDF pode precisar carregar recursos do sistema de arquivos 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

Etapa 5: Implementar a geração de PDFs com o IronPDF

Crie um novo controlador chamado PdfController.cs na sua pasta Controllers. Este controlador irá lidar com as solicitações de geração 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 the PDF as a file result
            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 the PDF as a file result
            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> htmlContent As String) As IActionResult
            Dim renderer = New ChromePdfRenderer()
            Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
            Dim output = pdf.BinaryData

            ' Return the PDF as a file result
            Return File(output, "application/pdf", "generated.pdf")
        End Function

    End Class

End Namespace

Etapa 6: Execute o aplicativo

Certifique-se de que seu aplicativo esteja configurado corretamente para escutar nas portas especificadas em ocelot.json . Você pode configurar isso em Properties/launchSettings.json .

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

Agora, execute seu aplicativo e você deverá conseguir enviar conteúdo HTML para http://localhost:5000/generatepdf e receber um PDF como resposta.

Este exemplo demonstra uma implementação básica do Ocelot com o IronPDF dentro da mesma aplicação. Para cenários de produção, considere proteger seus endpoints, lidar com situações de erro e otimizar o processo de geração de PDFs com base em seus requisitos específicos.