Ocelot API Gateway é uma biblioteca .NET que implementa o padrão de gateway de API comumente usado em gateways de API para lidar com solicitações em vários microsserviços. Ele funciona como um gateway de API leve, encaminhando solicitações de clientes para serviços subsequentes. Este artigo oferece uma visão aprofundada de como o gateway de API Ocelot se posiciona entre os clientes e os serviços downstream, abordando sua instalação, configuração, principais recursos e exemplos práticos para demonstrar suas capacidades. Também exploraremos a Visão Geral do IronPDF e a API do Ocelot em conjunto.
Ocelot é uma solução de gateway de API de código aberto para aplicações .NET , projetada para facilitar o roteamento de requisições entre múltiplos microsserviços. Ele atua como um proxy reverso, gerenciando solicitações HTTP de clientes e encaminhando-as para os serviços apropriados em um ambiente ASP.NET Core . Desenvolvido em ASP.NET Core, o Ocelot integra-se perfeitamente ao ecossistema .NET , oferecendo um conjunto robusto de recursos essenciais para aplicações modernas.
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.
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.
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.
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.
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.
Para integrar o Ocelot ao seu projeto, você precisa instalar o pacote Ocelot via NuGet e configurá-lo na classe Program:
Configure os serviços, incluindo o middleware de construtor de solicitações, na sua classe Startup.cs ou Program.cs para configurar o contêiner de serviços:
public void ConfigureServices(IServiceCollection services)
{
// Add Ocelot services to the service collection
services.AddOcelot();
}
public async void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// Use the developer exception page when in development mode
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
// Start Ocelot middleware
await app.UseOcelot();
}Public Sub ConfigureServices(services As IServiceCollection)
' Add Ocelot services to the service collection
services.AddOcelot()
End Sub
Public Async Sub Configure(app As IApplicationBuilder, env As IWebHostEnvironment)
' Use the developer exception page when in development mode
If env.IsDevelopment() Then
app.UseDeveloperExceptionPage()
End If
' Start Ocelot middleware
Await app.UseOcelot()
End SubO Ocelot utiliza um arquivo de configuração, normalmente ocelot.json , para definir as regras de roteamento. Aqui está um exemplo mais complexo que demonstra múltiplas configurações de rotas:
{
"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 configuração especifica como as solicitações para o gateway de API são roteadas para diferentes serviços downstream com base no caminho e no método HTTP, usando o arquivo JSON para configuração.
A combinação do Ocelot com a conversão de HTML para PDF do IronPDF em uma aplicação .NET oferece uma solução poderosa, permitindo direcionar solicitações de geração de PDF para um serviço específico ou tratá-las internamente. Neste guia, vou orientá-lo na configuração de um aplicativo .NET Core básico que usa o Ocelot como um gateway de API e o IronPDF para gerar PDFs a partir de HTML.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// Convert HTML file to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' Convert HTML string to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' Convert HTML file to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassPrimeiro, 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 OcelotWith IronPDF
cd OcelotWith IronPDFVocê precisa instalar o Ocelot e o IronPDF. Você pode adicionar esses pacotes via NuGet.
dotnet add package Ocelot
dotnet add package IronPdfAdicione 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"
}
}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 Sub ConfigureServices(services As IServiceCollection)
services.AddControllers()
services.AddOcelot()
End Sub
Public Async Sub Configure(app As IApplicationBuilder, 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 ClassCrie 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");
}
}
}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": {
"OcelotWith IronPDF": {
"commandName": "Project",
"launchBrowser": false,
"applicationUrl": "https://localhost:5001;http://localhost:5000",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
}
}
}Agora, execute sua aplicação e você deverá ser capaz de postar conteúdo HTML em http://localhost:5000/generatepdf e receber um PDF em 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.
Em conclusão, o Ocelot é uma excelente escolha para gerenciar e rotear requisições em uma arquitetura de microsserviços. Suas funcionalidades robustas, como roteamento, balanceamento de carga, suporte a middleware e autenticação, fazem dele uma ferramenta poderosa para qualquer desenvolvedor .NET . Seguindo os passos detalhados fornecidos, você pode integrar efetivamente o Ocelot em seus projetos .NET para otimizar suas necessidades de API Gateway.
Além disso, se você precisar de recursos de geração de PDF, a integração do IronPDF com o Ocelot é simples e aprimora a funcionalidade do seu aplicativo. O IronPDF oferece um período de teste gratuito e licenças a partir de uma solução econômica para suas necessidades de PDF.
Ao utilizar o Ocelot e o IronPDF em conjunto, você pode construir uma infraestrutura de microsserviços abrangente e eficiente que atenda aos requisitos de roteamento e geração de documentos.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
