Ocelot API Gateway ist eine .NET-Bibliothek, die das API-Gateway-Muster implementiert, das üblicherweise in API-Gateways verwendet wird, um Anfragen über mehrere Microservices hinweg zu bearbeiten. Es fungiert als leichtgewichtiges API-Gateway und leitet Anfragen von Clients an nachgelagerte Dienste weiter. Dieser Artikel bietet einen detaillierten Einblick in die Rolle des Ocelot API Gateway zwischen Clients und nachgelagerten Diensten und behandelt deren Installation, Konfiguration, wichtige Funktionen und praxisnahe Beispiele, um deren Fähigkeiten zu demonstrieren. Wir werden auch IronPDF Overview und Ocelot API kombiniert erkunden.

Was ist Ocelot .NET?

Ocelot ist eine Open-Source-API-Gateway-Lösung for .NET-Anwendungen, die entwickelt wurde, um das Routing von Anfragen über mehrere Mikrodienste zu erleichtern. Es fungiert als Reverse Proxy, der HTTP-Anfragen von Clients verwaltet und sie an die entsprechenden Dienste in einer ASP.NET Core-Umgebung weiterleitet. Entwickelt auf ASP.NET Core integriert sich Ocelot nahtlos in das .NET-Ökosystem und bietet ein umfangreiches Set an Funktionen, die für moderne Anwendungen unerlässlich sind.

Schlüsselmerkmale von Ocelot

Routing

Im Kern der Funktionalität von Ocelot steht seine Routing-Fähigkeit. Es gleicht eingehende Anfragen mit den entsprechenden Servicerouten aufgrund der von Entwicklern festgelegten Konfiguration ab und kann mit Service-Discovery-Mechanismen integriert werden. Dies beinhaltet die Unterstützung von Wildcard-Routing, was besonders nützlich ist, wenn es um unterschiedliche API-Versionen oder zahlreiche Serviceendpunkte geht.

Middleware / Delegierende Handler

Ocelot ermöglicht es Entwicklern, benutzerdefinierte Middleware oder Handler zu injizieren, die Anfragen und Antworten verarbeiten können, bevor sie den Client oder den Dienst erreichen. Dies ist nützlich für das Hinzufügen von Headern, das Protokollieren von Anfragen oder sogar das Ändern der Antwortstruktur nach Bedarf.

Lastausgleich

Ocelot unterstützt eine Vielzahl von Lastverteilungsstrategien von Haus aus, wie Round Robin, Least Connection und einen benutzerdefinierten Anbieter, wenn keine der vordefinierten Strategien die Anforderungen erfüllt. Diese Funktion stellt sicher, dass die Last gleichmäßig auf die verfügbaren Dienste verteilt wird, was die allgemeine Robustheit und Effizienz der Anwendung verbessert.

Authentifizierung und Autorisierung

Die Sicherung von API-Endpunkten ist kritisch, und Ocelot bietet Unterstützung für die Integration mit bestehenden Authentifizierungsanbietern wie Identity Server. Es unterstützt beliebte Authentifizierungsschemata, einschließlich JWT und OAuth2, und ermöglicht eine granulare Kontrolle über den Benutzerzugriff auf Dienste.

Rate Limiting und QoS

Die Ratenbegrenzung ist wichtig, um Missbrauch zu verhindern und eine faire Nutzung der Dienste zu gewährleisten, indem die Anzahl der Anfragen beschränkt wird, die ein Benutzer in einem bestimmten Zeitraum stellen kann. Quality of Service (QoS)-Optionen wie das Festlegen von Zeitlimits und Wiederholungen stellen sicher, dass Dienste unter verschiedenen Netzwerkbedingungen und Lasten verfügbar und reaktionsschnell 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 Program-Klasse konfigurieren:

dotnet add package Ocelot

Konfigurieren Sie die Dienste, einschließlich der Request-Builder-Middleware, in Ihrer Startup.cs oder Program.cs Klasse, um den Service-Container einzurichten:

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 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 Sub

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 Sub

Konfiguration von Routen in Ocelot

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

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

{
    "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 spezifiziert, wie Anfragen zum API-Gateway über den Pfad und die HTTP-Methode zu verschiedenen nachgelagerten Diensten weitergeleitet werden, wobei die JSON-Datei für die Einrichtung verwendet wird.

Verwendung von IronPDF mit Ocelot .NET

Die Kombination von Ocelot mit der HTML-zu-PDF-Konvertierung von IronPDF in einer .NET-Anwendung bietet eine leistungsstarke Lösung, bei der Sie PDF-Generierungsanfragen an einen bestimmten Dienst weiterleiten oder sie intern bearbeiten können. Hier führe ich Sie durch die Einrichtung einer grundlegenden .NET Core-Anwendung, die Ocelot als API-Gateway und IronPDF zur Erstellung von PDFs aus HTML verwendet.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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");
    }
}

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 Class

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 Class

Schritt 1: Einrichten der .NET Core Webanwendung

Erstellen Sie zuerst ein neues .NET Core-Web-API-Projekt. Sie können dies mit der .NET CLI oder Visual Studio machen.

Verwendung der .NET CLI:

dotnet new webapi -n OcelotWith IronPDF
cd OcelotWith IronPDF

dotnet new webapi -n OcelotWith IronPDF
cd OcelotWith IronPDF

Schritt 2: Hinzufügen notwendiger Pakete

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

dotnet add package Ocelot
dotnet add package IronPdf

dotnet add package Ocelot
dotnet add package IronPdf

Schritt 3: Ocelot konfigurieren

Fügen Sie eine ocelot.json-Datei zum Stamm Ihres Projekts hinzu, um das Routing von Ocelot zu konfigurieren. Diese Einrichtung geht davon aus, dass Ocelot PDF-Generierungsanfragen an einen bestimmten Pfad weiterleiten soll, der innerhalb der gleichen Anwendung von IronPDF behandelt wird.

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

{
    "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 einzuschließen. Stellen Sie sicher, dass Sie Ihre Anwendung auch zur Verwendung statischer Dateien konfigurieren, da IronPDF möglicherweise Assets vom 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(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 Class

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 Class

Schritt 5: PDF-Erzeugung mit IronPDF implementieren

Erstellen Sie einen neuen Controller PdfController.cs in Ihrem Controller-Ordner. Dieser Controller wird die PDF-Generierungsanfragen bearbeiten.

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");
        }
    }
}

Schritt 6: Ausführen der Anwendung

Stellen Sie sicher, dass Ihre Anwendung richtig konfiguriert ist, um auf den in ocelot.json angegebenen Ports zu lauschen. Sie können dies in Properties/launchSettings.json festlegen.

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

{
  "profiles": {
    "OcelotWith IronPDF": {
      "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 zu senden und ein PDF als Antwort zu erhalten.

Dieses Beispiel zeigt eine grundlegende Implementierung von Ocelot mit IronPDF innerhalb der gleichen Anwendung. Für Produktionsszenarien sollten Sie in Erwägung ziehen, Ihre Endpunkte zu sichern, Fehlerszenarien zu behandeln und den PDF-Erstellungsprozess gemäß Ihren spezifischen Anforderungen zu optimieren.

Abschluss

Abschließend ist Ocelot eine ausgezeichnete Wahl zur Verwaltung und Weiterleitung von Anfragen in einer Microservices-Architektur. Seine robusten Funktionen wie Routing, Lastverteilung, Middleware-Unterstützung und Authentifizierung machen es zu einem leistungsstarken Werkzeug für jeden .NET-Entwickler. Indem Sie den bereitgestellten detaillierten Schritten folgen, können Sie Ocelot effektiv in Ihre .NET-Projekte integrieren, um Ihre API-Gateway-Bedürfnisse zu optimieren.

Zusätzlich, wenn Sie PDF-Generierungsfunktionen benötigen, ist die Integration von IronPDF mit Ocelot unkompliziert und verbessert die Funktionalität Ihrer Anwendung. IronPDF bietet eine kostenlose Testversion und Lizenzen beginnen mit einer kostengünstigen Lösung für Ihre PDF-Bedürfnisse.

Durch die Kombination von Ocelot und IronPDF können Sie eine umfassende und effiziente Microservices-Infrastruktur aufbauen, die sowohl Routing- als auch Dokumentenerstellungsanforderungen erfüllt.