Ocelot .NET (Wie es für Entwickler funktioniert)

Ocelot API-Gateway ist eine .NET-Bibliothek, die das API-Gateway-Muster implementiert, das häufig in API-Gateways verwendet wird, um Anfragen über mehrere Microservices hinweg zu bearbeiten. Es fungiert als leichtgewichtiges API-Gateway, das Anfragen von Clients an nachgelagerte Dienste weiterleitet. Dieser Artikel bietet einen detaillierten Einblick in die Funktionsweise des Ocelot-API-Gateways, das zwischen Clients und nachgelagerten Diensten sitzt, und behandelt seine Installation, Konfiguration, Hauptfunktionen und praktische Beispiele zur Demonstration seiner Fähigkeiten. Wir werden auch Folgendes erforschen IronPDF und Ocelot API kombiniert.

Was ist Ocelot .NET?

Ocelot ist eine Open-Source-API-Gateway-Lösung für .NET-Anwendungen, die das Routing von Anfragen über mehrere Microservices hinweg erleichtern soll. Er fungiert als Reverse-Proxy, der HTTP-Anfragen von Clients verwaltet und sie an die entsprechenden Dienste in einer ASP.NET Core-Umgebung weiterleitet. Ocelot wurde auf der Basis von ASP.NET Core entwickelt und fügt sich nahtlos in das .NET-Ökosystem ein und bietet eine Reihe robuster Funktionen, die für moderne Anwendungen von entscheidender Bedeutung sind.

Hauptmerkmale von Ocelot

Weiterleitung

Das Herzstück der Funktionalität von Ocelot ist seine Routing-Funktion. Es ordnet eingehende Anfragen den entsprechenden Dienstrouten auf der Grundlage der von den Entwicklern festgelegten Konfiguration zu und kann in Mechanismen zur Diensterkennung integriert werden. Dazu gehört auch die Unterstützung von Wildcard-Routing, was besonders nützlich ist, wenn es um unterschiedliche API-Versionen oder zahlreiche Service-Endpunkte geht.

Middleware / Delegierende Bearbeiter

Ocelot ermöglicht es Entwicklern, benutzerdefinierte Middleware oder Handler einzubinden, die Anfragen und Antworten verarbeiten können, bevor sie den Client oder den Dienst erreichen. Dies ist nützlich, um Header hinzuzufügen, Anfragen zu protokollieren oder sogar die Antwortstruktur nach Bedarf zu ändern.

Lastausgleich

Ocelot unterstützt von Haus aus eine Vielzahl von Lastausgleichsstrategien, wie Round Robin, Least Connection und einen benutzerdefinierten Provider, wenn keine der vordefinierten Strategien den Anforderungen entspricht. Diese Funktion stellt sicher, dass die Last gleichmäßig auf die verfügbaren Dienste verteilt wird, was die allgemeine Ausfallsicherheit und Effizienz der Anwendung erhöht.

Authentifizierung und Autorisierung

Die Sicherung von API-Endpunkten ist von entscheidender Bedeutung, und Ocelot bietet Unterstützung für die Integration mit bestehenden Authentifizierungsanbietern, wie z. B. Identity Server. Es unterstützt gängige Authentifizierungsverfahren, darunter JWT und OAuth2, und ermöglicht eine fein abgestufte Kontrolle des Benutzerzugriffs auf Dienste.

Ratenbegrenzung und QoS

Die Ratenbegrenzung ist wichtig, um Missbrauch zu verhindern und eine faire Nutzung der Dienste zu gewährleisten, indem die Anzahl der Anfragen, die ein Nutzer in einem bestimmten Zeitraum stellen kann, begrenzt wird. Qualität der Dienstleistung (QoS) optionen wie die Einstellung von Timeouts und Wiederholungsversuchen stellen sicher, dass die Dienste unter verschiedenen Netzbedingungen und -lasten verfügbar und reaktionsfähig bleiben.

Einrichten von Ocelot in einem .NET-Projekt

Um Ocelot in Ihr Projekt zu integrieren, müssen Sie das Ocelot-Paket über NuGet installieren und es in der Programmklasse konfigurieren:

Install-Package IronPdf

Konfigurieren Sie die Dienste, einschließlich der Request Builder-Middleware, in Ihrer Startup.cs oder Programmklasse, um den Dienstcontainer einzurichten:

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

Routen in Ocelot konfigurieren

Ocelot verwendet eine Konfigurationsdatei, typischerweise ocelot.json, um die Routing-Regeln zu definieren. Hier ist ein komplexeres Beispiel, das mehrere Routenkonfigurationen zeigt:

{
    "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"
    }
}

Diese Konfiguration legt fest, wie Anfragen an das API-Gateway auf der Grundlage des Pfads und der HTTP-Methode an verschiedene nachgelagerte Dienste weitergeleitet werden, wobei die JSON-Datei zur Einrichtung verwendet wird.

Verwendung von IronPDF mit Ocelot .NET

Kombination von Ocelot mit IronPDF in einer .NET-Anwendung bietet eine leistungsstarke Lösung, mit der Sie PDF-Generierungsanforderungen an einen bestimmten Dienst weiterleiten oder intern verarbeiten können. Hier führe ich Sie durch die Einrichtung einer einfachen .NET Core-Anwendung, die Ocelot als API-Gateway und IronPDF verwendet, um pDFs aus HTML generieren.

Schritt 1: Einrichten der .NET Core-Webanwendung

Erstellen Sie zunächst ein neues .NET Core Web API-Projekt. Sie können dies mit der .NET CLI oder Visual Studio tun.

Die Verwendung der .NET:

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Schritt 2: Notwendige Pakete hinzufügen

Sie müssen Ocelot und IronPDF installieren. Sie können diese Pakete über NuGet hinzufügen.

dotnet add package Ocelot
dotnet add package IronPdf

Schritt 3: Ocelot konfigurieren

Fügen Sie eine ocelot.json-Datei mit folgendem Inhalt in das Stammverzeichnis Ihres Projekts ein, um das Routing von Ocelot zu konfigurieren. Dieses Setup geht davon aus, dass Sie möchten, dass Ocelot PDF-Erzeugungsanfragen an einen bestimmten Pfad weiterleitet, der von IronPDF innerhalb derselben Anwendung bearbeitet wird.

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

Schritt 4: Startup.cs konfigurieren

Aktualisieren Sie Startup.cs, um die Middleware von Ocelot einzubeziehen. Stellen Sie sicher, dass Sie Ihre Anwendung auch für die Verwendung von statischen Dateien konfigurieren, da IronPDF möglicherweise Assets aus dem lokalen Dateisystem laden muss.

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

Schritt 5: Implementierung der PDF-Erzeugung mit IronPDF

Erstellen Sie einen neuen Controller PdfController.cs in Ihrem Ordner Controllers. Dieser Controller wird die PDF-Erzeugungsanforderungen verarbeiten.

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

Schritt 6: Ausführen der Anwendung

Vergewissern Sie sich, dass Ihre Anwendung korrekt konfiguriert ist, um auf den in ocelot.json angegebenen Ports zu lauschen. Sie können dies in Properties/launchSettings.json einstellen.

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

Führen Sie nun Ihre Anwendung aus, und Sie sollten in der Lage sein, HTML-Inhalte an http://localhost:5000/generatepdf und erhalten als Antwort eine PDF-Datei.

Dieses Beispiel zeigt eine grundlegende Implementierung von Ocelot mit IronPDF innerhalb derselben Anwendung. Für Produktionsszenarien sollten Sie die Sicherung Ihrer Endpunkte, die Behandlung von Fehlerszenarien und die Optimierung des PDF-Erzeugungsprozesses auf der Grundlage Ihrer spezifischen Anforderungen in Betracht ziehen.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass Ocelot eine ausgezeichnete Wahl für die Verwaltung und Weiterleitung von Anfragen in einer Microservices-Architektur ist. Seine robusten Funktionen wie Routing, Lastausgleich, Middleware-Unterstützung und Authentifizierung machen ihn zu einem leistungsstarken Werkzeug für jeden .NET-Entwickler. Wenn Sie die detaillierten Schritte befolgen, können Sie Ocelot effektiv in Ihre .NET-Projekte integrieren, um Ihre API-Gateway-Anforderungen zu rationalisieren.

Wenn Sie außerdem PDF-Erzeugungsfunktionen benötigen, ist die Integration von IronPDF mit Ocelot unkompliziert und erweitert die Funktionalität Ihrer Anwendung. IronPDF bietet eine kostenloser Testund Lizenzen sind ab $749 erhältlich und bieten eine kostengünstige Lösung für Ihre PDF-Anforderungen.

Durch den gemeinsamen Einsatz von Ocelot und IronPDF können Sie eine umfassende und effiziente Microservices-Infrastruktur aufbauen, die sowohl die Anforderungen an das Routing als auch an die Dokumentenerstellung erfüllt.