.NET Core Polly (Cómo funciona para desarrolladores)
Polly es una biblioteca de estrategias de resiliencia y manejo de fallas transitorias en .NET, que permite a los desarrolladores expresar políticas de resiliencia como política de reintento, interruptores automáticos, tiempo de espera, política de aislamiento de compartimentos y reserva. Polly tiene como objetivo ASP.NET Core, convirtiéndose en una herramienta vital para la resiliencia de .NET Core. Polly es seguro para el uso de hilos y admite el manejo de múltiples solicitudes concurrentes con respuestas exitosas.
Este tutorial proporcionará más detalles sobre la biblioteca de manejo de fallas transitorias .NET, Polly, y cómo usarla con IronPDF en una aplicación ASP.NET Core. Profundizaremos en cada aspecto de Polly, explicaremos la mecánica del patrón de interruptor automático, discutiremos el aislamiento de compartimentos y los tiempos de espera, y mostraremos cómo manejar excepciones específicas o servicios fallidos con respuestas de falla de manera controlada y segura para usar con hilos.
Políticas de Polly
Las fallas transitorias a menudo ocurren cuando tu aplicación intenta conectarse con un servicio web a través de una solicitud HTTP, base de datos u otros recursos externos. Estas fallas, como fallas de red, problemas de conectividad temporales o tiempos de espera, son breves y generalmente se corrigen solos después de un corto tiempo.
Polly gestiona estas fallas transitorias aplicando diferentes estrategias y expresando políticas como la política de reintento, política avanzada de interruptor automático, política de tiempo de espera, política de reserva y política de aislamiento de compartimentos.
Política de traducción
La política de reintento reintenta automáticamente solicitudes concurrentes fallidas utilizando lógica de reintento. Se puede configurar para reintentar indefinidamente o hacer reintentos automáticos por un número determinado de veces, y puede esperar un intervalo de tiempo establecido entre reintentos o usar una retroalimentación exponencial.
Interruptor automático
La política de interruptor automático permite que tu sistema admita un token de cancelación para intentar un servicio particular después de un umbral preconfigurado de solicitudes fallidas. La estrategia del interruptor automático es análoga a la ingeniería del caos o un barco cerrando puertas herméticas para localizar daños: una falla no hundirá todo el barco.
Política de plazos
La política de tiempo de espera impone un tiempo máximo que una pieza particular del código de resiliencia de .NET puede ejecutarse. Viene en dos variantes: tiempo de espera optimista y tiempo de espera pesimista.
Política de devoluciones
La política de reserva se utiliza para proporcionar un valor o comportamiento sustituto en caso de falla. Esta política puede ser útil cuando un servicio fallido no debe detener todo el proceso.
Aislamiento de cabezales
El aislamiento de compartimentos se utiliza para limitar cuántas solicitudes concurrentes se pueden hacer a una operación específica, limitando así el potencial de agotamiento de sockets y manteniendo un número controlado de espacios de ejecución.
Política de caché
La política de caché almacena en caché la respuesta exitosa de una ejecución para que si se invoca nuevamente la misma ejecución, Polly pueda devolver el valor de la caché distribuida.
Policy Wrap
Nos permite agrupar múltiples políticas juntas para que puedan funcionar como una sola unidad.
Crear y configurar políticas
Política de traducción
Una política de reintento es simple: cuando ocurre una excepción específica o una falla, Polly intentará ejecutar el delegado subyacente nuevamente. Puedes definir cuántas veces reintentar, el intervalo de tiempo entre reintentos o usar una estrategia de retroalimentación exponencial, de lo contrario, intentará indefinidamente. Aquí hay un ejemplo:
// Retry policy for handling HttpRequestException with exponential back-off
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
Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
});// Retry policy for handling HttpRequestException with exponential back-off
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
Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
});Política de interruptores
La política de interruptor automático permite que la biblioteca Polly monitoree las fallas, y si el número de fallas excede un umbral configurado dentro de un período específico, el circuito se 'rompe' y se bloquean más solicitudes por un tiempo especificado. Esto se llama estado 'abierto'. Después de este tiempo, el circuito entra en un estado 'medio abierto', donde permite algo de tráfico para verificar la salud del servicio particular. Si estas solicitudes tienen éxito y no ocurren fallas, el circuito se cierra; de lo contrario, se abre nuevamente.
// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
.Handle<HttpRequestException>()
.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
.Handle<HttpRequestException>()
.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));Política de plazos
Las políticas de tiempo de espera manejan escenarios donde un servicio no responde dentro de un marco de tiempo razonable. Polly ofrece dos tipos de tiempos de espera: Optimista y Pesimista. Un tiempo de espera optimista trabaja en un hilo separado y cancela la operación subyacente a través de un CancellationToken. Un tiempo de espera pesimista bloquea el hilo principal hasta que la operación se complete o finalice el período de tiempo de espera.
// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 secondsAislamiento de cabezales
El aislamiento de compartimentos se utiliza para limitar el número de acciones concurrentes contra un servicio particular. Proporciona una forma de aislar fallas y evitar que se propaguen. También limita la carga que ponemos en nuestras dependencias.
// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slotsPolítica de devoluciones
Las políticas de reserva son útiles cuando necesitas proporcionar un comportamiento predeterminado o un valor sustituto cuando todo lo demás falla.
// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
.Handle<Exception>()
.FallbackAsync<FallbackResult>(
FallbackResult.SomethingWentWrong,
(exception, context) =>
{
Console.WriteLine($"Fallback triggered due to: {exception.Message}");
return Task.CompletedTask;
});// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
.Handle<Exception>()
.FallbackAsync<FallbackResult>(
FallbackResult.SomethingWentWrong,
(exception, context) =>
{
Console.WriteLine($"Fallback triggered due to: {exception.Message}");
return Task.CompletedTask;
});Envolver las políticas
Las políticas múltiples se pueden combinar de manera flexible usando un PolicyWrap:
// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);Empezando
Para comenzar a usar Polly con IronPDF, asegúrate de tener instalado Visual Studio y crea un nuevo proyecto de Aplicación de Consola en .NET Core. Abre la Consola del Administrador de Paquetes NuGet en Visual Studio e instala los paquetes Polly y IronPDF:
Install-Package Polly
Install-Package IronPdf
Uso de Polly con IronPDF Conversión de una URL a PDF
Una característica destacada de IronPDF es su capacidad de HTML a PDF, asegurando que los diseños y estilos se mantengan intactos. Esta función convierte contenido web en PDFs, lo que es perfecto para informes, facturas y documentación. Admite la conversión de archivos HTML, URLs y cadenas HTML a PDFs.
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");
}
}Veamos un ejemplo de uso de Polly con IronPDF para convertir una URL a PDF. Supón que tenemos un servicio web que ocasionalmente falla debido a fallas transitorias, y queremos manejar esas fallas de manera elegante usando Polly.
Primero, importemos 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;A continuación, definiremos nuestras políticas. En este ejemplo, usaremos una combinación de políticas de reintento e interruptor automático para manejar fallas:
// Retry policy with exponential backoff
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));// Retry policy with exponential backoff
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));La retryPolicy intentará nuevamente la solicitud fallida hasta tres veces con una estrategia de retroalimentación exponencial, esperando 2 segundos, 4 segundos y 8 segundos entre reintentos. La circuitBreakerPolicy abrirá el circuito si ocurren dos fallas consecutivas dentro de un intervalo de tiempo de 30 segundos.
Ahora, definamos nuestro código de IronPDF para convertir una URL a un PDF:
var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
.WrapAsync(circuitBreakerPolicy)
.ExecuteAsync(async () =>
{
Console.WriteLine("Attempting to convert URL to PDF...");
var result = await 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(async () =>
{
Console.WriteLine("Attempting to convert URL to PDF...");
var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
Console.WriteLine("Conversion successful!");
return result;
});
pdfBytes.SaveAs("output.pdf");En el ejemplo de código anterior, envolvemos nuestra retryPolicy y circuitBreakerPolicy usando el método WrapAsync. Esto nos permite aplicar múltiples políticas a nuevas solicitudes de manera 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 de Polly, aseguramos que nuestro código sea resistente a fallas transitorias. Si una solicitud falla, Polly la reintentará automáticamente según la política de reintento. Si el número de fallas consecutivas cruza el umbral preconfigurado, la política de interruptor automático abrirá el circuito, previniendo más solicitudes por una duración especificada.
Casos de prueba de las políticas de Polly
Para probar la efectividad de nuestras políticas de Polly, simulemos algunas solicitudes fallidas. Modifica la URL a un punto final inexistente y agrega algunos casos de prueba:
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}");
}
}En el código anterior, iteramos un conjunto de URLs de prueba e intentamos convertir cada una de ellas a PDF. Si una solicitud falla, la excepción será capturada, y se mostrará un mensaje apropiado en la consola.
Conclusión
Polly es una biblioteca poderosa y flexible para implementar resiliencia y manejo de fallas transitorias en aplicaciones .NET Core. Combinando políticas como reintento e interruptor automático, los desarrolladores pueden construir sistemas robustos y tolerantes a fallas que manejan fallas de manera elegante.
En este tutorial, exploramos cómo usar Polly con IronPDF para convertir una URL a PDF. Aprendimos cómo definir y aplicar políticas de Polly, incluyendo reintento e interruptor automático. También probamos nuestras políticas con diferentes URLs. También podemos hacerlo para convertir HTML a PDF.
IronPDF ofrece una prueba gratuita, y las licencias comienzan a precios competitivos, lo que te permite aprovechar sus capacidades en tus proyectos.
Preguntas Frecuentes
¿Qué es Polly y cómo mejora la resiliencia de .NET Core?
Polly es una biblioteca .NET diseñada para la resiliencia y el manejo de fallos transitorios, especialmente para aplicaciones ASP.NET Core. Mejora la resiliencia proporcionando estrategias como Reintento, Disyuntores, Tiempo de espera, Aislamiento de compartimentos y Respaldo, asegurando sistemas robustos y tolerantes a fallos.
¿Cómo puedo usar Polly para implementar una política de reintento en .NET Core?
En .NET Core, puedes usar Polly para implementar una política de reintento configurándolo para que reintente automáticamente las solicitudes fallidas. Esto se puede hacer estableciendo el número de reintentos y el intervalo de tiempo entre los intentos, permitiendo una gestión efectiva de los fallos transitorios.
¿Cómo previene la Política de Disyuntor fallos en cascada en aplicaciones .NET?
La Política de Disyuntor en Polly previene fallos en cascada monitoreando fallos y abriendo el circuito para bloquear solicitudes cuando se alcanza un umbral de fallos. Esto detiene solicitudes adicionales hasta que el circuito se reinicia, permitiendo que el sistema se recupere antes de aceptar nuevas solicitudes.
¿Qué papel desempeña el Aislamiento de Compartimentos en la gestión del agotamiento de recursos?
El Aislamiento de Compartimentos en Polly limita el número de solicitudes concurrentes a un servicio, previniendo el agotamiento de recursos al controlar los espacios de ejecución. Esta política ayuda a contener fallos y asegura una gestión eficiente de recursos dentro de una aplicación .NET Core.
¿Cómo puede la Política de Tiempo de Espera de Polly mejorar la capacidad de respuesta de mi aplicación?
La Política de Tiempo de Espera de Polly impone un tiempo máximo de ejecución para operaciones, lo que ayuda a gestionar escenarios donde los servicios no responden puntualmente. Al establecer tiempos de espera optimistas o pesimistas, los desarrolladores pueden asegurar que sus aplicaciones permanezcan receptivas.
¿Se puede usar Polly para mejorar la fiabilidad de la conversión de URL a PDF?
Sí, Polly puede mejorar la fiabilidad de la conversión de URL a PDF integrando sus políticas de Reintento y Disyuntor con herramientas de generación de PDF. Esto asegura que los procesos de conversión sean resistentes a fallos transitorios, manteniendo la fiabilidad.
¿Cómo asegura la Política de Respaldo en Polly una degradación elegante del servicio?
Una Política de Respaldo en Polly proporciona respuestas o comportamientos alternativos cuando un servicio falla. Esto ayuda a asegurar que un fallo no detenga toda la aplicación, permitiendo una degradación elegante y operación continua.
¿Cómo se combinan múltiples políticas de Polly en una aplicación .NET?
En una aplicación .NET, se pueden combinar múltiples políticas de Polly usando envolturas de políticas. Esto permite a los desarrolladores ejecutar diferentes estrategias de resiliencia juntas, habilitando un enfoque más integral y flexible para manejar fallos.
¿Cómo maneja la integración de Polly con IronPDF los fallos transitorios en la generación de PDF?
Al integrar Polly con IronPDF, los desarrolladores pueden manejar fallos transitorios durante la generación de PDF a través de políticas como reintento y disyuntor. Esta integración asegura una generación de PDF estable y fiable a pesar de interrupciones ocasionales en el servicio.
¿Cuáles son algunas estrategias comunes de solución de problemas al usar Polly con .NET Core?
Las estrategias comunes de solución de problemas incluyen verificar configuraciones de políticas, como intervalos de reintento y umbrales de disyuntor, y probar políticas con diferentes escenarios para asegurar un manejo adecuado de fallos y la resiliencia del sistema.
Comience gratis
Comience gratis
Reserve demostración en vivo gratis
No se requiere tarjeta de crédito ni creación de cuenta
