Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Ocelot .NET
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

Ocelot API Gateway est une bibliothèque .NET qui implémente le modèle de passerelle API couramment utilisé dans les passerelles API pour gérer les demandes à travers plusieurs microservices. Il agit comme une passerelle API légère, routant les demandes des clients vers les services en aval. Cet article fournit un regard approfondi sur la façon dont la passerelle Ocelot API se situe entre les clients et les services en aval, couvrant son installation, sa configuration, ses principales caractéristiques et des exemples pratiques pour démontrer ses capacités. Nous explorerons également Vue d'ensemble d'IronPDF et Ocelot API combinés.

Qu'est-ce qu'Ocelot .NET ?

Ocelot .NET (Comment cela fonctionne pour les développeurs) : Figure 1 - Page d'accueil Ocelot .NET

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

Caractéristiques clés d'Ocelot

Routage

Au cœur de la fonctionnalité d'Ocelot se trouve sa capacité de routage. Il associe les requêtes entrantes aux routes de service appropriées en fonction de la configuration spécifiée par les développeurs, et peut être intégré avec des mécanismes de découverte de services. Cela inclut la prise en charge du routage par caractère générique, particulièrement utile lors de la gestion de versions API variables ou de nombreux points de terminaison de service.

Middleware / Gestionnaires délégués

Ocelot permet aux développeurs d'injecter des middleware ou des gestionnaires personnalisés pouvant traiter les requêtes et réponses avant qu'elles n'atteignent le client ou le service. Cela est utile pour ajouter des en-têtes, consigner des requêtes ou même modifier la structure de la réponse selon les besoins.

Équilibrage de charge

Ocelot prend en charge une variété de stratégies d'équilibrage de charge par défaut, comme le Round Robin, la connexion la moins utilisée, et un fournisseur personnalisé si aucune des stratégies prédéfinies ne répond à l'exigence. Cette fonctionnalité garantit que la charge est répartie de manière uniforme entre les services disponibles, améliorant la résilience et l'efficacité globales de l'application.

Authentification et autorisation

Sécuriser les points de terminaison de l'API est crucial, et Ocelot offre un support pour l'intégration avec des fournisseurs d'authentification existants, tels que Identity Server. Il prend en charge les schémas d'authentification populaires, y compris JWT et OAuth2, et permet un contrôle granulé de l'accès utilisateur aux services.

Limitation de vitesse et QoS

La limitation de vitesse est essentielle pour prévenir les abus et assurer une utilisation équitable des services en limitant le nombre de requêtes qu'un utilisateur peut faire dans une période donnée. Les options de Qualité de Service (QoS) comme la configuration des délais d'attente et des réessais assurent que les services restent disponibles et réactifs dans diverses conditions et charges réseau.

Configuration d'Ocelot dans un projet .NET

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

dotnet add package Ocelot

Ocelot .NET (Comment cela fonctionne pour les développeurs): Figure 2 - Installer Ocelot .NET via le gestionnaire de packages NuGet

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

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(ByVal services As IServiceCollection)
	' Add Ocelot services to the service collection
	services.AddOcelot()
End Sub

Public Async Sub Configure(ByVal app As IApplicationBuilder, ByVal 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
$vbLabelText   $csharpLabel

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 illustre plusieurs configurations de routes :

{
    "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 précise comment les requêtes vers la passerelle API sont routées vers différents services en aval sur la base du chemin et de la méthode HTTP, en utilisant le fichier JSON pour la configuration.

Utiliser IronPDF avec Ocelot .NET

Ocelot .NET (Comment cela fonctionne pour les développeurs) : Figure 3 - Page d'accueil d'IronPDF

Combiner Ocelot avec Conversion HTML-en-PDF d'IronPDF dans une application .NET fournit une solution puissante où vous pouvez router les requêtes de génération de PDF vers un service spécifique ou les gérer en interne. Ici, je vais vous guider à travers la configuration d'une application .NET Core de base qui utilise Ocelot comme passerelle API et IronPDF pour générer des PDF à partir de HTML.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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
$vbLabelText   $csharpLabel

Étape 1 : Configurer l'application web .NET Core

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

En utilisant le .NET CLI :

dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF
dotnet new webapi -n OcelotWithIronPDF
cd OcelotWithIronPDF
SHELL

Étape 2 : Ajouter les packages nécessaires

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

dotnet add package Ocelot
dotnet add package IronPdf
dotnet add package Ocelot
dotnet add package IronPdf
SHELL

Étape 3 : Configurer 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 route les requêtes 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 : Configurer Startup.cs

Mettez à jour Startup.cs pour inclure le middleware d'Ocelot. Assurez-vous également de configurer votre application pour utiliser des fichiers statiques, car IronPDF peut avoir besoin de charger des ressources depuis le 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
$vbLabelText   $csharpLabel

Étape 5 : Implémenter 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 requêtes 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 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
$vbLabelText   $csharpLabel

É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 définir ceci 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 pouvoir envoyer du contenu HTML à http://localhost:5000/generatepdf et recevoir un PDF en réponse.

Ocelot .NET (Comment cela fonctionne pour les développeurs) : Figure 4

Cet exemple illustre une implémentation basique d'Ocelot avec IronPDF dans la même application. Pour des scénarios de production, envisagez de sécuriser vos points de terminaison, traiter des scénarios d'erreur et optimiser le processus de génération de PDF selon vos exigences spécifiques.

Conclusion

Ocelot .NET (Comment cela fonctionne pour les développeurs) : Figure 5 - Page de licence IronPDF

En conclusion, Ocelot est un excellent choix pour gérer et router les demandes dans une architecture de microservices. Ses fonctionnalités robustes comme le routage, l'équilibrage de charge, le support du middleware, 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 Ocleot dans vos projets .NET pour rationaliser vos besoins en passerelle API.

De plus, si vous avez besoin de capacités de génération de PDF, intégrer IronPDF avec Ocelot est simple et améliore la fonctionnalité de votre application. IronPDF offre un essai gratuit et les licences commencent à partir d'une solution économique pour vos besoins en PDF.

En tirant parti d'Ocelot et IronPDF ensemble, 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.

Questions Fréquemment Posées

Comment Ocelot peut-il améliorer la communication entre microservices dans les applications .NET ?

Ocelot agit comme une passerelle API, facilitant le routage efficace et la gestion des requêtes HTTP à travers plusieurs microservices dans une application .NET. Il propose des fonctionnalités telles que le routage, la répartition de charge et l'authentification pour simplifier la communication entre les services.

Quels sont les avantages d'utiliser Ocelot avec IronPDF ?

Intégrer Ocelot avec IronPDF permet aux développeurs de router efficacement les requêtes de génération de PDF au sein d'une application .NET. IronPDF garantit que les conversions HTML en PDF conservent les dispositions et styles originaux, le rendant idéal pour générer du contenu Web tel que des rapports et des factures.

Comment configurez-vous Ocelot pour la répartition de charge ?

Ocelot prend en charge diverses stratégies de répartition de charge, y compris le Round Robin et la Moindre Connexion, qui peuvent être configurées via un fichier JSON généralement nommé ocelot.json. Cela assure une répartition équitable du trafic à travers les microservices.

Quel rôle joue le middleware dans l'architecture d'Ocelot ?

Le middleware dans Ocelot permet aux développeurs d'insérer des gestionnaires personnalisés pour traiter les requêtes et les réponses. Ceci est utile pour des tâches comme l'ajout d'en-têtes, la journalisation ou la modification des réponses, améliorant ainsi la flexibilité et la fonctionnalité de la passerelle API.

Comment pouvez-vous configurer Ocelot dans un projet .NET ?

Pour configurer Ocelot dans un projet .NET, installez le package Ocelot via NuGet, puis configurez-le en ajoutant des services Ocelot dans la classe Program et en définissant des routes dans un fichier de configuration. Cette configuration facilite le routage et la gestion des requêtes API.

Quelles stratégies Ocelot utilise-t-il pour gérer le routage ?

Ocelot utilise un routage basé sur la configuration, spécifié dans un fichier ocelot.json, pour diriger les requêtes de la passerelle API vers les services en aval appropriés. Il prend en charge le routage par joker et les mécanismes de découverte de services pour des configurations de routage flexibles.

Comment Ocelot assure-t-il un accès sécurisé aux API ?

Ocelot s'intègre avec des fournisseurs d'authentification comme Identity Server et prend en charge les schémas JWT et OAuth2, permettant un accès sécurisé aux API en contrôlant les permissions des utilisateurs et en assurant la protection des points de terminaison.

Ocelot peut-il être utilisé pour optimiser les flux de travail de génération de PDF ?

Oui, Ocelot peut router les requêtes vers des services spécifiques dédiés à la génération de PDF, tels que ceux utilisant IronPDF. Cette configuration optimise les flux de travail PDF en gérant efficacement les requêtes et en préservant la fidélité du document lors de la conversion.

Comment Ocelot s'intègre-t-il avec les mécanismes de découverte de services ?

Ocelot prend en charge l'intégration avec des mécanismes de découverte de services comme Consul et Eureka, ce qui lui permet de router dynamiquement les requêtes en fonction de l'état actuel des services. Cette intégration simplifie la gestion des services dans une architecture de microservices.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit