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

Polly est une bibliothèque .NET de stratégies de résilience et de gestion des défaillances transitoires, permettant aux développeurs d'exprimer des politiques de résilience telles que la politique de réessai, les disjoncteurs, le délai d'attente, la politique d'isolation des cloisons et le repli. Polly cible ASP.NET Core, ce qui en fait un outil essentiel pour la résilience de .NET Core. Polly est sécurisé par des threads et permet de traiter plusieurs requêtes simultanées avec une réponse satisfaisante.

Ce tutoriel fournira plus de détails sur la bibliothèque .NET de gestion des défauts transitoires, Polly, et sur la manière de l'utiliser avec IronPDF dans une application ASP.NET Core. Nous allons plonger dans chaque aspect de Polly, expliquer les mécanismes du modèle de disjoncteur, discuter de l'isolation des cloisons et des délais, et montrer comment gérer des exceptions spécifiques ou un service défaillant avec une réponse d'échec d'une manière contrôlée et sûre pour les threads.

Politiques de Polly

Les erreurs transitoires se produisent souvent lorsque votre application tente de se connecter à un service web par le biais d'une requête HTTP, d'une base de données ou d'autres ressources externes. Ces défaillances, telles que les pannes de réseau, les problèmes temporaires de connectivité ou les dépassements de délai, sont brèves et se corrigent généralement d'elles-mêmes après un court laps de temps.

Polly gère ces défauts transitoires en appliquant différentes stratégies et politiques expresses telles que la politique de réessai, la politique de disjoncteur avancé, la politique de temporisation, la politique de repli et la politique d'isolation des cloisons.

Politique de réessai

La politique de relance relance automatiquement les demandes concurrentes qui ont échoué en utilisant la logique de relance. Il peut être configuré pour effectuer des tentatives permanentes ou des tentatives automatiques pendant un certain nombre de fois, et il peut attendre un intervalle de temps défini entre les tentatives ou utiliser un délai exponentiel.

Disjoncteur

La stratégie Circuit Breaker permet à votre système de prendre en charge le jeton d'annulation pour essayer un service particulier après un seuil préconfiguré de demandes infructueuses. La stratégie du coupe-circuit est analogue à l'ingénierie du chaos ou à la fermeture des portes étanches d'un navire pour localiser les dégâts : une seule défaillance ne fera pas couler tout le navire.

Politique de temporisation

La politique de délai d'attente fixe la durée maximale d'exécution d'un élément particulier du code de résilience .NET. Il existe deux types de délais : le délai optimiste et le délai pessimiste.

Politique de repli

La politique de repli est utilisée pour fournir une valeur ou un comportement de remplacement en cas de défaillance. Cette politique peut être utile lorsqu'un service défaillant ne doit pas interrompre l'ensemble du processus.

Isolation des cloisons

L'isolation de la tête de pont est utilisée pour limiter le nombre de demandes simultanées qui peuvent être faites à une opération spécifique, limitant ainsi le potentiel d'épuisement de la prise et maintenant un nombre contrôlé de créneaux d'exécution.

Politique de cache

La politique de cache met en cache la réponse réussie d'une exécution de sorte que si la même exécution est invoquée à nouveau, Polly peut renvoyer la valeur du cache distribué.

Enveloppe de la politique

Il nous permet de regrouper plusieurs politiques afin qu'elles fonctionnent comme une seule unité.

Créer et configurer des politiques

Politique de réessai

Une politique de réessai est simple : lorsqu'une exception spécifique ou une erreur se produit, Polly essaie d'exécuter à nouveau le délégué sous-jacent. Vous pouvez définir le nombre de tentatives, l'intervalle de temps entre les tentatives ou utiliser une stratégie de recul exponentiel, faute de quoi la tentative sera permanente. En voici un exemple :

//extension method
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
    });

//extension method
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        // This is the OnRetry delegate, where you can log or monitor failed requests
    });

'extension method
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
End Sub)

Politique en matière de disjoncteur

La politique du coupe-circuit permet à la bibliothèque Polly de surveiller les erreurs et, si le nombre d'erreurs dépasse un seuil configuré au cours d'une période donnée, le circuit est "interrompu" et les demandes ultérieures sont bloquées pendant une période donnée. C'est ce qu'on appelle l'état "ouvert". Après ce délai, le circuit entre dans un état "semi-ouvert", où il autorise un certain trafic pour vérifier l'état de santé du service en question. Si ces demandes aboutissent et qu'aucune erreur ne se produit, le circuit se ferme, sinon il s'ouvre à nouveau.

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))

Politique de temporisation

Les règles de temporisation permettent de gérer les scénarios dans lesquels un service ne répond pas dans un délai raisonnable. Polly propose deux types de délais : Optimiste et Pessimiste. Un timeout optimiste fonctionne sur un thread séparé et annule l'opération sous-jacente via un CancellationToken. Un délai pessimiste bloque le thread parent jusqu'à ce que l'opération soit terminée ou que le délai soit écoulé.

var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds

var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds

IRON VB CONVERTER ERROR developers@ironsoftware.com

Isolation des cloisons

L'isolation des cloisons est utilisée pour limiter le nombre d'actions simultanées sur un service particulier. Il permet d'isoler les fautes et d'éviter qu'elles ne se reproduisent en cascade. Il limite également la charge que nous faisons peser sur nos dépendances.

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions

IRON VB CONVERTER ERROR developers@ironsoftware.com

Politique de repli

Les politiques de repli sont utiles lorsque vous devez fournir un comportement par défaut ou une valeur de remplacement en cas d'échec.

var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);

var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);

Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong)

Envelopper les politiques

Plusieurs politiques peuvent être combinées de manière flexible à l'aide d'une PolicyWrap :

var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

IRON VB CONVERTER ERROR developers@ironsoftware.com

Pour commencer

Pour commencer à utiliser Polly avec IronPDF, assurez-vous que Visual Studio est installé et créez un nouveau projet d'application console dans .NET Core. Ouvrez la console NuGet Package Manager dans Visual Studio et installez les paquets Polly et IronPdf :

Install-Package Polly

Install-Package IronPdf

Utilisation de Polly avec IronPDF Conversion d'une URL en PDF

L'une des principales caractéristiques d'IronPDF est son HTML vers PDF en veillant à ce que les mises en page et les styles soient intacts. Cette fonction transforme le contenu web en PDF, ce qui est parfait pour les rapports, les factures et la documentation. Il permet de convertir des fichiers HTML, des URL et des chaînes HTML en PDF.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. 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");
        // 2. 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");
        // 3. 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();
        // 1. 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");
        // 2. 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");
        // 3. 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()
		' 1. 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")
		' 2. 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")
		' 3. 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

Voyons un exemple d'utilisation de Polly avec IronPDF pour convertir une URL en PDF. Supposons que nous ayons un service web qui tombe occasionnellement en panne à cause d'erreurs transitoires, et que nous voulions gérer ces pannes de manière élégante en utilisant Polly.

Tout d'abord, importons les espaces de noms nécessaires dans notre fichier Program.cs :

using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;

using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;

Imports System
Imports System.Threading.Tasks
Imports Polly
Imports Polly.Wrap
Imports IronPdf

Ensuite, nous définirons nos politiques. Dans cet exemple, nous utiliserons une combinaison de politiques de réessai et de disjoncteur pour gérer les défaillances :

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

IRON VB CONVERTER ERROR developers@ironsoftware.com

La politique retryPolicy réessaie la requête échouée jusqu'à trois fois avec une stratégie de backoff exponentielle, en attendant 2 secondes, 4 secondes et 8 secondes entre les réessais. La circuitBreakerPolicy ouvrira le circuit si deux défaillances consécutives se produisent dans un intervalle de temps de 30 secondes.

Définissons maintenant notre code IronPDF pour convertir une URL en PDF :

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(() =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
// var result
        var result = htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });
pdfBytes.SaveAs("output.pdf");

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(() =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
// var result
        var result = htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });
pdfBytes.SaveAs("output.pdf");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans l'exemple de code ci-dessus, nous enveloppons nos retryPolicy et circuitBreakerPolicy en utilisant la méthode WrapAsync. Cela nous permet d'appliquer plusieurs politiques aux nouvelles demandes de manière séquentielle. La méthode ExecuteAsync exécute le délégué fourni, qui dans le code ci-dessus est la méthode RenderUrlAsPdfAsync d'IronPDF.

En appliquant les politiques Polly, nous nous assurons que notre code est résistant aux fautes transitoires. Si une demande échoue, Polly la relance automatiquement conformément à la politique de relance. Si le nombre d'échecs consécutifs dépasse le seuil préconfiguré, la politique du coupe-circuit ouvre le circuit, empêchant toute nouvelle demande pendant une durée déterminée.

Cas de test pour les politiques Polly

Pour tester l'efficacité de nos politiques Polly, simulons des demandes qui échouent. Modifiez l'URL vers un point de terminaison inexistant et ajoutez quelques cas de test :

var testUrls = new []
{
                "https://ironpdf.com",
                "https://notexistingdomain.com/",
                "http://httpbin.org/delay/120"
};
foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));
        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}

var testUrls = new []
{
                "https://ironpdf.com",
                "https://notexistingdomain.com/",
                "http://httpbin.org/delay/120"
};
foreach (var url in testUrls)
{
    try
    {
        var pdfBytes = await retryPolicy
            .WrapAsync(circuitBreakerPolicy)
            .ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));
        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
        Console.WriteLine($"Successfully converted {url} to PDF.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans le code ci-dessus, nous itérons sur un ensemble d'URL de test et tentons de convertir chacun d'entre eux en PDF. Si une demande échoue, l'exception est prise en compte et un message approprié est affiché dans la console.

Conclusion

Polly est une bibliothèque puissante et flexible pour mettre en œuvre la résilience et la gestion des fautes transitoires dans les applications .NET Core. En combinant des politiques telles que le retry et le circuit breaker, les développeurs peuvent construire des systèmes robustes et tolérants aux pannes qui gèrent les défaillances avec élégance.

Dans ce tutoriel, nous avons exploré comment utiliser Polly avec IronPDF pour convertir une URL en PDF. Nous avons appris à définir et à appliquer les politiques Polly, y compris la réessai et le coupe-circuit. Nous avons également testé nos politiques avec différentes URL. Nous pouvons également le faire pour convertir HTML en PDF.

IronPDF offre un service de essai gratuitet les licences commencent à partir de $749, ce qui vous permet d'exploiter ses capacités dans vos projets.