Ocelot .NET (Funktionsweise für Entwickler)

Routing

At the core of Ocelot's functionality is its routing capability. It matches incoming requests to the appropriate service routes based on the configuration specified by developers, and it can be integrated with service discovery mechanisms. This includes support for wildcard routing, which is particularly useful when dealing with varying API versions or numerous service endpoints.

Middleware / Delegating Handlers

Ocelot allows developers to inject custom middleware or handlers that can process requests and responses before they reach the client or the service. This is useful for adding headers, logging requests, or even modifying the response structure as needed.

Load Balancing

Ocelot supports a variety of load-balancing strategies out of the box, such as Round Robin, Least Connection, and a custom provider if none of the predefined strategies fit the requirement. This feature ensures that the load is distributed evenly among the available services, enhancing the overall resilience and efficiency of the application.

Authentication and Authorization

Securing API endpoints is critical, and Ocelot provides support for integrating with existing authentication providers, such as Identity Server. It supports popular authentication schemes, including JWT and OAuth2, and allows for fine-grained control over user access to services.

Rate Limiting and QoS

Rate limiting is essential to prevent abuse and ensure fair use of the services by limiting the number of requests a user can make in a given period. Quality of Service (QoS) options like setting timeouts and retries ensure that services remain available and responsive under various network conditions and loads.

Step 1: Set Up the .NET Core Web Application

First, create a new .NET Core Web API project. You can do this using the .NET CLI or Visual Studio.

Using the .NET CLI:

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Step 2: Add Necessary Packages

You need to install Ocelot and IronPDF. You can add these packages via NuGet.

dotnet add package Ocelot
dotnet add package IronPdf

dotnet add package Ocelot
dotnet add package IronPdf

Step 3: Configure Ocelot

Add an ocelot.json file to the root of your project with the following content to configure Ocelot’s routing. This setup assumes you want Ocelot to route PDF generation requests to a specific path that will be handled by IronPDF within the same application.

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

Step 4: Configure Startup.cs

Update Startup.cs to include Ocelot’s middleware. Ensure you also configure your application to use static files, as IronPDF may need to load assets from the local file system.

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

Step 5: Implement PDF Generation with IronPDF

Create a new controller PdfController.cs in your Controllers folder. This controller will handle the PDF generation requests.

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

Step 6: Run the Application

Make sure your application is correctly configured to listen on the ports specified in ocelot.json. You can set this in Properties/launchSettings.json.

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

Now, run your application, and you should be able to post HTML content to http://localhost:5000/generatepdf and receive a PDF in response.

This example showcases a basic implementation of Ocelot with IronPDF within the same application. For production scenarios, consider securing your endpoints, handling error scenarios, and optimizing the PDF generation process based on your specific requirements.