Ocelot .NET (Comment ça marche pour les développeurs)

Passerelle API Ocelot est une bibliothèque .NET qui met en œuvre le modèle de passerelle API couramment utilisé dans les passerelles API, pour gérer les demandes à travers plusieurs microservices. Elle agit comme une passerelle API légère, acheminant les demandes des clients vers les services en aval. Cet article explique en détail comment la passerelle API Ocelot se situe entre les clients et les services en aval, en couvrant son installation, sa configuration, ses principales caractéristiques et des exemples pratiques pour démontrer ses capacités. Nous explorerons également IronPDF et Ocelot API combinés.

Qu'est-ce qu'Ocelot .NET ?

Ocelot est une solution de passerelle API open-source pour les applications .NET, conçue pour faciliter l'acheminement des demandes à travers plusieurs microservices. Il agit comme un proxy inverse, en gérant les requêtes HTTP des clients et en les acheminant vers les services appropriés dans un environnement ASP.NET Core. Développé sur ASP.NET Core, Ocelot s'intègre parfaitement à l'écosystème .NET, offrant un ensemble robuste de fonctionnalités cruciales pour les applications modernes.

Caractéristiques principales d'Ocelot

Routage

Au cœur de la fonctionnalité d'Ocelot se trouve sa capacité de routage. Il fait correspondre les demandes entrantes aux itinéraires de service appropriés sur la base de la configuration spécifiée par les développeurs, et il peut être intégré à des mécanismes de découverte de services. Cela inclut la prise en charge du routage par caractères génériques, ce qui est particulièrement utile lorsque l'on a affaire à des versions d'API différentes ou à de nombreux points d'extrémité de service.

Middleware / Delegating Handlers

Ocelot permet aux développeurs d'injecter des intergiciels ou des gestionnaires personnalisés qui peuvent traiter les demandes et les réponses avant qu'elles n'atteignent le client ou le service. Cela permet d'ajouter des en-têtes, d'enregistrer les demandes ou même de modifier la structure de la réponse en fonction des besoins.

Équilibrage de la charge

Ocelot prend en charge une variété de stratégies d'équilibrage de charge, telles que Round Robin, Least Connection, et un fournisseur personnalisé si aucune des stratégies prédéfinies ne répond à l'exigence. Cette fonction garantit que la charge est répartie uniformément entre les services disponibles, ce qui améliore la résilience et l'efficacité globales de l'application.

Authentification et autorisation

La sécurisation des points d'extrémité de l'API est essentielle, et Ocelot prend en charge l'intégration avec les fournisseurs d'authentification existants, tels que Identity Server. Il prend en charge les schémas d'authentification les plus courants, notamment JWT et OAuth2, et permet un contrôle fin de l'accès des utilisateurs aux services.

Limitation du débit et qualité de service

La limitation du débit est essentielle pour prévenir les abus et garantir une utilisation équitable des services en limitant le nombre de demandes qu'un utilisateur peut effectuer au cours d'une période donnée. Qualité du service (Qualité de service) des options telles que la définition de délais d'attente et de tentatives garantissent que les services restent disponibles et réactifs dans diverses conditions et charges de réseau.

Configuration d'Ocelot dans un projet .NET

Pour intégrer Ocelot dans votre projet, vous devez installer le paquetage Ocelot via NuGet et le configurer dans la classe Program :

Install-Package IronPdf

Configurez les services, y compris l'intergiciel de construction de requêtes, dans votre classe Startup.cs ou Program pour configurer le conteneur de services :

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

Configuration des routes dans Ocelot

Ocelot utilise un fichier de configuration, généralement ocelot.json, pour définir les règles de routage. Voici un exemple plus complexe qui montre plusieurs configurations d'itinéraires :

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

Cette configuration spécifie comment les demandes adressées à la passerelle API sont acheminées vers différents services en aval en fonction du chemin d'accès et de la méthode HTTP, en utilisant le fichier JSON pour la configuration.

Utilisation d'IronPDF avec Ocelot .NET

En combinant Ocelot avec IronPDF dans une application .NET constitue une solution puissante qui permet d'acheminer les demandes de génération de PDF vers un service spécifique ou de les traiter en interne. Ici, je vais vous guider dans la configuration d'une application .NET Core de base qui utilise Ocelot en tant que passerelle API et IronPDF pour générer des PDF à partir de HTML.

Étape 1 : Configuration de l'application Web .NET Core

Tout d'abord, créez un nouveau projet .NET Core Web API. Vous pouvez le faire à l'aide de l'interface de programmation .NET ou de Visual Studio.

Utiliser le logiciel .NET :

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF

Étape 2 : Ajouter les paquets nécessaires

Vous devez installer Ocelot et IronPDF. Vous pouvez ajouter ces paquets via NuGet.

dotnet add package Ocelot
dotnet add package IronPdf

Étape 3 : Configuration d'Ocelot

Ajoutez un fichier ocelot.json à la racine de votre projet avec le contenu suivant pour configurer le routage d'Ocelot. Cette configuration suppose que vous souhaitez qu'Ocelot achemine les demandes de génération de PDF vers un chemin spécifique qui sera géré par IronPDF au sein de la même application.

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

Étape 4 : Configuration du fichier Startup.cs

Mettre à jour Startup.cs pour inclure le middleware d'Ocelot. Veillez également à configurer votre application pour qu'elle utilise des fichiers statiques, car IronPDF peut avoir besoin de charger des ressources à partir du système de fichiers 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 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

Étape 5 : Mise en œuvre de la génération de PDF avec IronPDF

Créez un nouveau contrôleur PdfController.cs dans votre dossier Controllers. Ce contrôleur traitera les demandes de génération 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 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

Étape 6 : Exécuter l'application

Assurez-vous que votre application est correctement configurée pour écouter sur les ports spécifiés dans ocelot.json. Vous pouvez le définir dans Properties/launchSettings.json.

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

Maintenant, exécutez votre application et vous devriez être en mesure d'envoyer du contenu HTML à http://localhost:5000/generatepdf et recevoir un PDF en réponse.

Cet exemple présente une implémentation basique d'Ocelot avec IronPDF au sein de la même application. Pour les scénarios de production, pensez à sécuriser vos points finaux, à gérer les scénarios d'erreur et à optimiser le processus de génération de PDF en fonction de vos besoins spécifiques.

Conclusion

En conclusion, Ocelot est un excellent choix pour la gestion et le routage des requêtes dans une architecture microservices. Ses fonctions robustes telles que le routage, l'équilibrage de charge, la prise en charge des logiciels intermédiaires et l'authentification en font un outil puissant pour tout développeur .NET. En suivant les étapes détaillées fournies, vous pouvez intégrer efficacement Ocelot dans vos projets .NET afin de rationaliser vos besoins en matière de passerelle API.

En outre, si vous avez besoin de capacités de génération de PDF, l'intégration d'IronPDF avec Ocelot est simple et améliore la fonctionnalité de votre application. IronPDF offre un service de essai gratuitet les licences commencent à partir de $749, ce qui constitue une solution rentable pour vos besoins en PDF.

En tirant parti conjointement d'Ocelot et d'IronPDF, vous pouvez construire une infrastructure de microservices complète et efficace qui répond à la fois aux exigences de routage et de génération de documents.