.NET Core Polly (Cómo funciona para desarrolladores)

Polly es una librería .NET de estrategias de resiliencia y gestión de fallos transitorios, que permite a los desarrolladores expresar políticas de resiliencia como la política de reintentos, disyuntores, tiempos de espera, política de aislamiento de mamparos y Fallback. Polly está orientado a ASP.NET Core, lo que lo convierte en una herramienta vital para la resiliencia de .NET Core. Polly tiene un modo seguro para hilos y soporta el manejo de múltiples peticiones concurrentes con respuesta exitosa.

Este tutorial proporcionará más detalles sobre el manejo de fallos transitorios .NET biblioteca, Polly y cómo usarlo con IronPDF en una aplicación ASP.NET Core. Nos sumergiremos en profundidad en cada aspecto de Polly, explicaremos la mecánica del patrón de interruptores, discutiremos el aislamiento de mamparos y los tiempos de espera, y mostraremos cómo manejar excepciones específicas o fallos de servicio con respuesta a fallos de una manera segura y controlada.

Políticas de Polly

Los fallos transitorios suelen producirse cuando su aplicación intenta conectarse con un servicio web a través de una petición HTTP, una base de datos u otros recursos externos. Estos fallos, como los fallos de red, los problemas temporales de conectividad o los tiempos de espera, son breves y suelen corregirse solos al cabo de poco tiempo.

Polly gestiona estos fallos transitorios aplicando diferentes estrategias y políticas expresas como la política de reintentos, la política avanzada de disyuntores, la política de tiempos de espera, la política de Fallback y la política de aislamiento de mamparas.

Política de reintentos

La política de reintentos reintenta automáticamente las solicitudes concurrentes fallidas utilizando la lógica de reintentos. Puede configurarse para que reintente siempre o para que reintente automáticamente un determinado número de veces, y puede esperar un intervalo de tiempo determinado entre reintentos o utilizar un retardo exponencial.

Interruptor automático

La política Circuit Breaker permite que su sistema admita el token de cancelación para intentar un servicio concreto tras un umbral preconfigurado de solicitudes fallidas. La estrategia del disyuntor es análoga a la ingeniería del caos o a un barco que cierra las puertas estancas para localizar los daños: un fallo no hundirá todo el barco.

Política de plazos

La política de tiempo de espera impone un tiempo máximo de ejecución de un determinado fragmento de código de resiliencia .NET. Hay dos tipos: tiempo de espera optimista y tiempo de espera pesimista.

Política de emergencia

La política de Fallback se utiliza para proporcionar un valor o comportamiento sustitutivo en caso de fallo. Esta política puede ser útil cuando un servicio que falla no debe detener todo el proceso.

Aislamiento de mamparos

El aislamiento masivo se utiliza para limitar el número de peticiones concurrentes que se pueden hacer a una operación específica, limitando así el potencial de agotamiento del socket y manteniendo un número controlado de ranuras de ejecución.

Política de caché

La política de caché almacena en caché la respuesta satisfactoria de una ejecución, de modo que si se vuelve a invocar la misma ejecución, Polly puede devolver el valor de caché distribuido.

Política

Permite agrupar varias pólizas para que funcionen como una sola.

Crear y configurar políticas

Política de reintentos

Una política de reintento es simple: cuando se produce una excepción específica o un fallo, Polly intentará ejecutar de nuevo el delegado subyacente. Puedes definir cuántas veces reintentar, el intervalo de tiempo entre reintentos, o utilizar una estrategia de retroceso exponencial, de lo contrario reintentará para siempre. He aquí un ejemplo:

//método de extensión
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        //  Este es el delegado OnRetry, donde puede registrar o supervisar las solicitudes fallidas
    });

//método de extensión
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), 
    (exception, timeSpan, retryCount, context) =>
    {
        //  Este es el delegado OnRetry, donde puede registrar o supervisar las solicitudes fallidas
    });

'método de extensión
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
End Sub)

Política de disyuntores

La política de Interruptor de Circuito permite a la biblioteca Polly monitorizar los fallos, y si el número de fallos excede un umbral configurado dentro de un periodo especificado, el circuito se "rompe", y se bloquean más peticiones durante un tiempo especificado. Esto se denomina estado "abierto". Transcurrido este tiempo, el circuito entra en un estado "semiabierto", en el que permite cierto tráfico para comprobar la salud del servicio en cuestión. Si estas solicitudes tienen éxito y no se producen fallos, el circuito se cierra; en caso contrario, se abre de nuevo.

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

Política de plazos

Las políticas de tiempo de espera gestionan situaciones en las que un servicio no responde en un plazo de tiempo razonable. Polly ofrece dos tipos de tiempos de espera: Optimista y Pesimista. Un tiempo de espera optimista funciona en un hilo separado y cancela la operación subyacente a través de un CancellationToken. Un tiempo de espera pesimista bloquea el hilo padre hasta que la operación se completa o transcurre el periodo de tiempo de espera.

var timeoutPolicy = Policy.TimeoutAsync(30); //  Tiempo de espera optimista de 30 segundos

var timeoutPolicy = Policy.TimeoutAsync(30); //  Tiempo de espera optimista de 30 segundos

Dim timeoutPolicy = Policy.TimeoutAsync(30) '  Tiempo de espera optimista de 30 segundos

Aislamiento de mamparos

El aislamiento de mamparos se utiliza para limitar el número de acciones concurrentes contra un servicio concreto. Proporciona una forma de aislar los fallos y evitar que se produzcan en cascada. También limita la carga que imponemos a nuestras dependencias.

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); //  10 acciones concurrentes, cola de 20 acciones adicionales

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); //  10 acciones concurrentes, cola de 20 acciones adicionales

Dim bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20) '  10 acciones concurrentes, cola de 20 acciones adicionales

Política de emergencia

Las políticas de emergencia son útiles cuando se necesita proporcionar un comportamiento por defecto o un valor sustitutivo cuando todo lo demás falla.

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)

Envolver las políticas

Se pueden combinar varias políticas de forma flexible utilizando un 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

Primeros pasos

Para empezar a utilizar Polly con IronPDF, asegúrese de tener Visual Studio instalado y cree un nuevo proyecto de aplicación de consola en .NET Core. Abre la consola del gestor de paquetes NuGet en Visual Studio e instala los paquetes Polly e IronPdf:

Install-Package Polly

Install-Package IronPdf

Uso de Polly con IronPDF Conversión de una URL a PDF

Veamos un ejemplo del uso de Polly con IronPDF para convertir una URL en PDF. Supongamos que tenemos un servicio web que ocasionalmente falla debido a fallos transitorios, y queremos manejar esos fallos con gracia usando Polly.

En primer lugar, vamos a importar los espacios de nombres necesarios en nuestro archivo 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

A continuación, definiremos nuestras políticas. En este ejemplo, utilizaremos una combinación de políticas de reintento y disyuntor para gestionar los fallos:

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

Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))

Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))

La retryPolicy reintentará la petición fallida hasta tres veces con una estrategia de backoff exponencial, esperando 2 segundos, 4 segundos y 8 segundos entre reintentos. La circuitBreakerPolicy abrirá el circuito si se producen dos fallos consecutivos en un intervalo de tiempo de 30 segundos.

Ahora, definamos nuestro código IronPDF para convertir una URL en un PDF:

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(() =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
//  var resultado
        var result = htmlToPdf.RenderUrlAsPdfAsync("https://ejemplo.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 resultado
        var result = htmlToPdf.RenderUrlAsPdfAsync("https://ejemplo.com");
        Console.WriteLine("Conversion successful!");
        return result;
    });

pdfBytes.SaveAs("output.pdf");

Dim htmlToPdf = New ChromePdfRenderer()
Dim pdfBytes = Await retryPolicy.WrapAsync(circuitBreakerPolicy).ExecuteAsync(Function()
		Console.WriteLine("Attempting to convert URL to PDF...")
'  var resultado
		Dim result = htmlToPdf.RenderUrlAsPdfAsync("https://ejemplo.com")
		Console.WriteLine("Conversion successful!")
		Return result
End Function)

pdfBytes.SaveAs("output.pdf")

En el código de ejemplo anterior, envolvemos nuestra retryPolicy y circuitBreakerPolicy utilizando el método WrapAsync. Esto nos permite aplicar varias políticas a las nuevas solicitudes de forma secuencial. El método ExecuteAsync ejecuta el delegado proporcionado, que en este código es el método RenderUrlAsPdfAsync de IronPDF.

Aplicando las políticas Polly, nos aseguramos de que nuestro código es resistente a los fallos transitorios. Si una solicitud falla, Polly la reintentará automáticamente de acuerdo con la política de reintentos. Si el número de fallos consecutivos supera el umbral preconfigurado, la política de interruptores abrirá el circuito, impidiendo nuevas solicitudes durante un tiempo determinado.

Casos de prueba de las políticas de Polly

Para probar la eficacia de nuestras políticas Polly, vamos a simular algunas peticiones fallidas. Modifica la URL a un endpoint inexistente y añade algunos casos de prueba:

var testUrls = new []
{
                "https://ironpdf.com",
                "https://notexistingdomain.com/",
                "http://httpbin.org/retraso/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/retraso/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}");
    }
}

Dim testUrls = { "https://ironpdf.com", "https://notexistingdomain.com/", "http://httpbin.org/retraso/120" }

For Each url In testUrls
	Try
		Dim pdfBytes = Await retryPolicy.WrapAsync(circuitBreakerPolicy).ExecuteAsync(Function() htmlToPdf.RenderUrlAsPdfAsync(url))

		pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf")
		Console.WriteLine($"Successfully converted {url} to PDF.")
	Catch ex As Exception
		Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}")
	End Try
Next url

En el código anterior, iteramos sobre un conjunto de URL de prueba e intentamos convertir cada una de ellas a PDF. Si una solicitud falla, se capturará la excepción y se mostrará un mensaje apropiado en la consola.

Conclusión

Polly es una biblioteca potente y flexible para implementar la resiliencia y la gestión de fallos transitorios en aplicaciones .NET Core. Combinando políticas como el reintento y el disyuntor, los desarrolladores pueden crear sistemas robustos y tolerantes a fallos que los gestionen con elegancia.

En este tutorial, exploramos cómo utilizar Polly con IronPDF para convertir una URL a PDF. Aprendimos a definir y aplicar políticas Polly, incluyendo reintento y disyuntor. También probamos nuestras políticas con diferentes URL. También podemos hacerlo para convertir HTML a PDF.

IronPDF ofrece un prueba gratuita y las licencias comienzan a partir de $749, lo que le permite aprovechar sus capacidades en sus proyectos.