Ocelot .NET (jak to działa dla programistów)

Routing

Podstawą funkcjonalności Ocelot jest jego zdolność do routingu. Dopasowuje przychodzące żądania do odpowiednich tras usługowych w oparciu o konfigurację określoną przez programistów i może być zintegrowany z mechanizmami wykrywania usług. Obejmuje to obsługę routingu z użyciem symboli wieloznacznych, co jest szczególnie przydatne w przypadku różnych wersji API lub licznych punktów końcowych usług.

Oprogramowanie pośredniczące / Delegowanie procedur obsługi

Ocelot pozwala programistom na wstrzykiwanie niestandardowego oprogramowania pośredniczącego lub procedur obsługi, które mogą przetwarzać żądania i odpowiedzi, zanim dotrą one do klienta lub usługi. Jest to przydatne do dodawania nagłówków, rejestrowania żądań, a nawet modyfikowania struktury odpowiedzi w razie potrzeby.

Równoważenie obciążenia

Ocelot obsługuje wiele gotowych strategii równoważenia obciążenia, takich jak Round Robin, Least Connection oraz dostawca niestandardowy, jeśli żadna z predefiniowanych strategii nie spełnia wymagań. Ta funkcja zapewnia równomierny rozkład obciążenia między dostępne usługi, zwiększając ogólną odporność i wydajność aplikacji.

Uwierzytelnianie i autoryzacja

Zabezpieczenie punktów końcowych API ma kluczowe znaczenie, a Ocelot zapewnia obsługę integracji z istniejącymi dostawcami uwierzytelniania, takimi jak Identity Server. Obsługuje popularne schematy uwierzytelniania, w tym JWT i OAuth2, oraz umożliwia precyzyjną kontrolę dostępu użytkowników do usług.

Ograniczanie przepustowości i jakość usług (QoS)

Ograniczanie szybkości jest niezbędne, aby zapobiegać nadużyciom i zapewnić uczciwe korzystanie z usług poprzez ograniczenie liczby żądań, które użytkownik może wysłać w danym okresie. Opcje jakości usług (QoS), takie jak ustawianie limitów czasu i ponownych prób, zapewniają dostępność i responsywność usług w różnych warunkach sieciowych i przy różnym obciążeniu.

Krok 1: Skonfiguruj aplikację internetową .NET Core

Najpierw utwórz nowy projekt .NET Core Web API. Można to zrobić za pomocą interfejsu CLI platformy .NET lub programu Visual Studio.

Korzystanie z interfejsu CLI platformy .NET:

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Krok 2: Dodaj niezbędne pakiety

Należy zainstalować Ocelot i IronPDF. Pakiety te można dodać za pośrednictwem NuGet.

dotnet add package Ocelot
dotnet add package IronPdf

dotnet add package Ocelot
dotnet add package IronPdf

Krok 3: Skonfiguruj Ocelot

Dodaj plik ocelot.json do katalogu głównego projektu z następującą treścią, aby skonfigurować routing Ocelot. Ta konfiguracja zakłada, że chcesz, aby Ocelot kierował żądania generowania plików PDF do określonej ścieżki, która będzie obsługiwana przez IronPDF w ramach tej samej aplikacji.

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

Krok 4: Skonfiguruj plik Startup.cs

Zaktualizuj plik Startup.cs, aby uwzględnić oprogramowanie pośredniczące Ocelot. Upewnij się również, że skonfigurowałeś swoją aplikację do korzystania z plików statycznych, ponieważ IronPDF może wymagać ładowania zasobów z lokalnego systemu plików.

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

Krok 5: Wdrożenie generowania plików PDF za pomocą IronPDF

Utwórz nowy kontroler PdfController.cs w folderze Controllers. Ten kontroler będzie obsługiwał żądania generowania plików 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

Krok 6: Uruchom aplikację

Upewnij się, że Twoja aplikacja jest poprawnie skonfigurowana do nasłuchiwania na portach określonych w pliku ocelot.json. Można to ustawić w pliku Properties/launchSettings.json.

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

Teraz uruchom aplikację, a powinieneś móc wysłać treść HTML do http://localhost:5000/generatepdf i otrzymać w odpowiedzi plik PDF.

Ten przykład przedstawia podstawową implementację Ocelot z IronPDF w tej samej aplikacji. W scenariuszach produkcyjnych należy rozważyć zabezpieczenie punktów końcowych, obsługę scenariuszy błędów oraz optymalizację procesu generowania plików PDF w oparciu o konkretne wymagania.