Polly é uma biblioteca .NET para estratégias de resiliência e tratamento de falhas transitórias, permitindo que desenvolvedores expressem políticas de resiliência como política de repetição, disjuntores, tempo limite, política de isolamento de anteparo e fallback. O Polly tem como alvo o ASP.NET Core, tornando-se uma ferramenta vital para a resiliência do .NET Core . Polly é thread-safe e suporta o processamento de múltiplas requisições simultâneas com respostas bem-sucedidas.
Este tutorial fornecerá mais detalhes sobre a biblioteca .NET para tratamento de falhas transitórias, Polly, e como usá-la com o IronPDF em uma aplicação ASP.NET Core . Analisaremos detalhadamente cada aspecto do Polly, explicaremos a mecânica do padrão Circuit Breaker, discutiremos o isolamento de bulkhead e os timeouts, e mostraremos como lidar com exceções específicas ou serviços com falha, com respostas de falha, de maneira controlada e segura para threads.
Falhas transitórias geralmente ocorrem quando seu aplicativo tenta se conectar a um serviço web por meio de uma solicitação HTTP, banco de dados ou outros recursos externos. Essas falhas, como problemas de rede, instabilidade temporária ou timeouts, são breves e normalmente se corrigem sozinhas após um curto período.
Polly gerencia essas falhas transitórias aplicando diferentes estratégias e expressando políticas como Política de Repetição, Política Avançada de Disjuntor, Política de Tempo Limite, Política de Recuo e Política de Isolamento de Anteparo.
A política de repetição tenta novamente, automaticamente, solicitações simultâneas com falha, utilizando lógica de repetição. Ele pode ser configurado para tentar novamente indefinidamente ou realizar novas tentativas automaticamente um determinado número de vezes, podendo aguardar um intervalo de tempo definido entre as tentativas ou usar um recuo exponencial.
A política Circuit Breaker permite que seu sistema suporte um token de cancelamento para tentativas de acesso a um serviço específico após um limite predefinido de solicitações com falha. A estratégia do disjuntor é análoga à engenharia do caos ou a um navio fechando portas estanques para localizar danos: uma falha não afundará o navio inteiro.
A política de tempo limite define um tempo máximo que um determinado trecho de código de resiliência do .NET pode ser executado. Ele vem em duas versões: tempo limite otimista e tempo limite pessimista.
A política de fallback é usada para fornecer um valor ou comportamento alternativo em caso de falha. Essa política pode ser útil quando uma falha em um serviço não deve interromper todo o processo.
O isolamento de anteparo é usado para limitar o número de solicitações simultâneas que podem ser feitas a uma operação específica, limitando assim o potencial de esgotamento de sockets e mantendo um número controlado de slots de execução.
A política de cache armazena em cache a resposta bem-sucedida de uma execução, de forma que, se a mesma execução for invocada novamente, o Polly possa retornar o valor do cache distribuído.
Permite agrupar várias políticas para que funcionem como uma única unidade.
A política de repetição é simples: quando ocorre uma exceção ou falha específica, o Polly tentará executar o delegado subjacente novamente. Você pode definir quantas tentativas devem ser feitas, o intervalo de tempo entre as tentativas ou usar uma estratégia de recuo exponencial; caso contrário, as tentativas serão indefinidas. Eis um exemplo:
// 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
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}")
End Sub)A política Circuit Breaker permite que a biblioteca Polly monitore falhas e, se o número de falhas exceder um limite configurado dentro de um período especificado, o circuito é "interrompido" e novas solicitações são bloqueadas por um tempo determinado. Isso é chamado de estado "aberto". Após esse período, o circuito entra em um estado "semiaberto", permitindo que algum tráfego verifique o funcionamento do serviço em questão. Se essas solicitações forem bem-sucedidas e nenhuma falha ocorrer, o circuito se fecha; Caso contrário, ele se abre novamente.
// 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
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))As políticas de tempo limite lidam com cenários em que um serviço não responde dentro de um prazo razoável. Polly oferece dois tipos de pausas: Otimista e Pessimista. Um timeout otimista funciona em um thread separado e cancela a operação subjacente via CancellationToken. Um tempo limite pessimista bloqueia a thread principal até que a operação seja concluída ou o período de tempo limite expire.
// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds' Timeout policy with a 30-second optimistic timeout
Dim timeoutPolicy = Policy.TimeoutAsync(30) ' 30 secondsO isolamento de anteparo é usado para limitar o número de ações simultâneas em um serviço específico. Ele fornece uma maneira de isolar falhas e impedir que elas se propaguem. Isso também limita a carga que impomos às nossas dependências.
// 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
Dim bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20) ' 10 concurrent actions, 20 queue slotsAs políticas de fallback são úteis quando você precisa fornecer um comportamento padrão ou um valor substituto quando todas as outras opções falharem.
// 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
Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong, Function(exception, context)
Console.WriteLine($"Fallback triggered due to: {exception.Message}")
Return Task.CompletedTask
End Function)Várias políticas podem ser combinadas de forma flexível usando um PolicyWrap:
// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);' Combining multiple policies using PolicyWrap
Dim policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy)Para começar a usar o Polly com o IronPDF, certifique-se de ter o Visual Studio instalado e crie um novo projeto de Aplicativo de Console no .NET Core. Abra o Console do Gerenciador de Pacotes NuGet no Visual Studio e instale os pacotes Polly e IronPDF:
Uma característica importante do IronPDF é sua capacidade de converter HTML em PDF , garantindo que os layouts e estilos sejam mantidos intactos. Essa função transforma conteúdo da web em PDFs, o que é perfeito para relatórios, faturas e documentação. Ele permite a conversão de arquivos HTML, URLs e strings HTML em 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");
}
}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 ClassVamos analisar um exemplo de como usar o Polly com o IronPDF para converter uma URL em PDF . Suponha que temos um serviço web que ocasionalmente falha devido a problemas transitórios, e queremos lidar com essas falhas de forma adequada usando o Polly.
Primeiro, vamos importar os namespaces necessários em nosso arquivo Program.cs:
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 IronPdfEm seguida, definiremos nossas políticas. Neste exemplo, usaremos uma combinação de políticas de repetição e disjuntor para lidar com falhas:
// 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
Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))
' Circuit breaker policy to block requests after consecutive failures
Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))O retryPolicy irá tentar novamente a solicitação falhada até três vezes com uma estratégia de backoff exponencial, esperando 2 segundos, 4 segundos e 8 segundos entre as tentativas. O circuitBreakerPolicy abrirá o circuito se duas falhas consecutivas ocorrerem dentro de um intervalo de tempo de 30 segundos.
Agora, vamos definir nosso código IronPDF para converter uma URL em um 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");Dim htmlToPdf = New ChromePdfRenderer()
Dim pdfBytes = Await retryPolicy.WrapAsync(circuitBreakerPolicy).ExecuteAsync(Async Function()
Console.WriteLine("Attempting to convert URL to PDF...")
Dim result = Await htmlToPdf.RenderUrlAsPdfAsync("https://example.com")
Console.WriteLine("Conversion successful!")
Return result
End Function)
pdfBytes.SaveAs("output.pdf")No exemplo de código acima, envolvemos nossos retryPolicy e circuitBreakerPolicy usando o método WrapAsync. Isso nos permite aplicar várias políticas a novas solicitações sequencialmente. O método ExecuteAsync executa o delegate fornecido, que neste código é o método RenderUrlAsPdfAsync do IronPDF.
Ao aplicar as políticas do Polly, garantimos que nosso código seja resiliente a falhas transitórias. Se uma solicitação falhar, o Polly tentará novamente automaticamente, de acordo com a política de repetição. Se o número de falhas consecutivas ultrapassar o limite pré-configurado, a política de disjuntor abrirá o circuito, impedindo novas solicitações por um período especificado.
Para testar a eficácia de nossas políticas Polly, vamos simular algumas requisições com falha. Modifique a URL para um endpoint inexistente e adicione alguns casos de teste:
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}");
}
}Imports System
Dim testUrls = {
"https://ironpdf.com",
"https://notexistingdomain.com/",
"http://httpbin.org/delay/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
NextNo código acima, iteramos sobre um conjunto de URLs de teste e tentamos converter cada uma delas em PDF. Se uma solicitação falhar, a exceção será capturada e uma mensagem apropriada será exibida no console.
Polly é uma biblioteca poderosa e flexível para implementar resiliência e tratamento de falhas transitórias em aplicações .NET Core . Ao combinar políticas como repetição e disjuntor, os desenvolvedores podem construir sistemas robustos e tolerantes a falhas que lidam com falhas de forma adequada.
Neste tutorial, exploramos como usar o Polly com o IronPDF para converter uma URL em PDF. Aprendemos como definir e aplicar políticas do Polly, incluindo repetição e disjuntor. Também testamos nossas políticas com URLs diferentes. Também podemos fazer isso para converter HTML em PDF .
O IronPDF oferece um período de teste gratuito e as licenças têm preços iniciais competitivos, permitindo que você aproveite seus recursos em seus projetos.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
