Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o ironpdf
  4. ASP HTML para PDF
USANDO O IRONPDF

Como converter HTML para PDF em ASP.NET Core

Curtis Chau
Curtis Chau
Atualizado:

O IronPDF permite a conversão perfeita de HTML para PDF no ASP.NET Core usando um mecanismo de renderização baseado no Chrome que preserva a formatação, o CSS e o JavaScript— essencial para gerar faturas, relatórios e documentos para download em aplicativos da web modernos.

Converter HTML dinâmico em documentos PDF é um requisito fundamental em aplicações ASP.NET modernas. Seja para gerar faturas, criar relatórios ou produzir arquivos para download, transformar conteúdo HTML em PDFs profissionais é essencial para oferecer experiências de usuário refinadas.

O IronPDF simplifica esse processo de conversão, fornecendo um mecanismo de renderização robusto baseado no Chrome que preserva perfeitamente a formatação HTML, o estilo CSS e a funcionalidade JavaScript nos documentos resultantes. Este tutorial apresenta métodos eficazes para converter HTML em PDF em aplicações ASP.NET Core usando a biblioteca IronPDF .

Por que os desenvolvedores precisam de conversão de HTML para PDF?

Aplicações ASP.NET Core frequentemente geram conteúdo HTML dinâmico que os usuários precisam baixar, compartilhar ou arquivar como PDFs. Converter HTML para PDF oferece diversas vantagens importantes em comparação com simplesmente salvar páginas da web ou tirar capturas de tela.

Os arquivos PDF mantêm uma formatação consistente em todos os dispositivos e plataformas, garantindo que suas faturas tenham a mesma aparência, seja visualizada no Windows, Mac ou em dispositivos móveis. São ideais para documentos que exigem assinaturas digitais , configurações de segurança ou impressão profissional. A conversão no servidor elimina a necessidade de os usuários instalarem softwares específicos e proporciona maior controle sobre o resultado final.

Os casos de uso comuns incluem a geração de relatórios financeiros a partir de dados de painéis de controle , a criação de faturas para download a partir de informações de pedidos, a produção de ingressos e passes com códigos QR e a conversão de envios de formulários em registros permanentes. Ao lidar com a conversão no servidor, você garante resultados consistentes independentemente do navegador ou dos recursos do dispositivo do usuário. O formato de arquivo PDF/A garante a preservação de documentos a longo prazo, enquanto a compressão PDF reduz o tamanho dos arquivos para armazenamento e transmissão eficientes.

Para os engenheiros da DevOps, essa abordagem do lado do servidor se integra perfeitamente com implantações em contêineres e pipelines de CI/CD , garantindo a geração confiável de PDFs em diferentes ambientes. Os recursos de otimização de desempenho permitem a utilização eficiente de recursos em implantações de produção. Os guias de implantação do Azure e a integração com o AWS Lambda fornecem estratégias de otimização específicas para cada plataforma.

Como funciona a instalação do IronPDF ?

Começar a usar o IronPDF em seu projeto ASP.NET Core é muito simples. A biblioteca oferece suporte ao .NET Core 2.0 e versões superiores, além do .NET 5, 6, 7 e 8, tornando-a compatível com todos os aplicativos ASP.NET Core modernos. Para ambientes conteinerizados, o IronPDF oferece suporte oficial ao Docker . A visão geral da instalação abrange todos os cenários de implantação.

Qual é o método de instalação mais rápido?

A maneira mais rápida de adicionar o IronPDF ao seu projeto é através do Gerenciador de Pacotes NuGet no Visual Studio. No Solution Explorer, clique com o botão direito do mouse no seu projeto, selecione "Gerenciar Pacotes NuGet " e procure por IronPDF. Clique em Instalar na versão mais recente para adicioná-la ao seu projeto. Para obter instruções detalhadas de instalação, consulte o guia de instalação do IronPDF . Métodos alternativos incluem o uso do Windows Installer ou configuração avançada do NuGet .

Install-Package IronPdf

Para implantações em contêineres, utilize o pacote IronPdf.Slim , que reduz o tamanho inicial da implantação:

dotnet add package IronPdf.Slim
dotnet add package IronPdf.Slim
SHELL

Essa abordagem beneficia implantações do AWS Lambda ou do Azure Functions , onde as restrições de tamanho de pacote são críticas. A comparação entre mecanismos de busca nativos e remotos ajuda a escolher a estratégia de implantação ideal.

De quais namespaces eu preciso?

Após a instalação, adicione o namespace IronPDF a qualquer arquivo C# onde você trabalhará com geração de PDFs:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Esta declaração de importação dá acesso a todas as funcionalidades do IronPDF , incluindo a classe ChromePdfRenderer para conversão em HTML e várias opções de configuração para personalizar a sua saída. A referência da API fornece documentação completa para todas as classes e métodos disponíveis.

Quais opções de configuração devo definir?

Para a maioria das aplicações ASP.NET Core , o IronPDF funciona imediatamente após a instalação, sem necessidade de configuração adicional. No entanto, você pode definir opções globais no seu arquivo Program.cs ou Startup.cs:

// Optional: Configure IronPDF settings
Installation.TempFolderPath = @"C:\Temp\IronPdf\";
Installation.LinuxAndDockerDependenciesAutoConfig = true;

// Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Optional: Configure IronPDF settings
Installation.TempFolderPath = @"C:\Temp\IronPdf\";
Installation.LinuxAndDockerDependenciesAutoConfig = true;

// Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Optional: Configure IronPDF settings
Installation.TempFolderPath = "C:\Temp\IronPdf\"
Installation.LinuxAndDockerDependenciesAutoConfig = True

' Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Essas opções de configuração ajudam a otimizar o IronPDF para seu ambiente de hospedagem específico, seja ele executado no Windows , Linux ou em contêineres Docker. Para evitar conflitos, certifique-se de que os arquivos de script e de aplicação não compartilhem o mesmo diretório. O guia da chave de licença explica a configuração correta do licenciamento, enquanto a resolução de problemas de implementação ajuda a solucionar problemas comuns.

Para implantações em produção, considere adicionar endpoints de verificação de integridade para monitorar os serviços de geração de PDF:

// Add health checks for monitoring
services.AddHealthChecks()
    .AddCheck("pdf-service", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var test = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
            return HealthCheckResult.Healthy();
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
// Add health checks for monitoring
services.AddHealthChecks()
    .AddCheck("pdf-service", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var test = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
            return HealthCheckResult.Healthy();
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
' Add health checks for monitoring
services.AddHealthChecks() _
    .AddCheck("pdf-service", Function() 
        Try
            Dim renderer = New ChromePdfRenderer()
            Dim test = renderer.RenderHtmlAsPdf("<p>Health Check</p>")
            Return HealthCheckResult.Healthy()
        Catch ex As Exception
            Return HealthCheckResult.Unhealthy(ex.Message)
        End Try
    End Function)
$vbLabelText   $csharpLabel

Para implantações do Kubernetes , implemente sondas de prontidão e de atividade para garantir a disponibilidade do serviço. O guia de assistência ao desempenho fornece estratégias adicionais de otimização.

Como faço para converter strings HTML em PDF?

A operação mais fundamental no IronPDF é a conversão direta de strings HTML em documentos PDF . Essa abordagem funciona perfeitamente ao criar conteúdo HTML dinamicamente em sua aplicação ASP.NET ou ao trabalhar com modelos. O tutorial completo aborda cenários avançados.

// Create a PDF converter instance
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF document
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " + DateTime.Now + "</p>");
// Save the resultant PDF document to a file
pdf.SaveAs("report.pdf");
// Create a PDF converter instance
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF document
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " + DateTime.Now + "</p>");
// Save the resultant PDF document to a file
pdf.SaveAs("report.pdf");
' Create a PDF converter instance
Dim renderer = New ChromePdfRenderer()
' Convert HTML string to PDF document
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " & DateTime.Now & "</p>")
' Save the resultant PDF document to a file
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Este código cria uma nova instância de ChromePdfRenderer, que usa o mecanismo Chromium para renderizar seu conteúdo HTML. O método RenderHtmlAsPdf aceita qualquer string HTML válida e retorna um objeto PdfDocument. Em seguida, você pode salvar este documento em disco ou transmiti-lo diretamente para os usuários como uma matriz de bytes. Saiba mais sobre a classe ChromePdfRenderer e suas funcionalidades. O guia de criação de PDFs oferece métodos de criação adicionais.

Para ambientes de produção com alta concorrência, implemente um gerenciamento de recursos adequado:

// Implement using statement for proper disposal
using (var renderer = new ChromePdfRenderer())
{
    // Configure for optimal performance
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent);

    // Use memory stream for better resource management
    using (var ms = new MemoryStream())
    {
        pdf.SaveAs(ms);
        return ms.ToArray();
    }
}
// Implement using statement for proper disposal
using (var renderer = new ChromePdfRenderer())
{
    // Configure for optimal performance
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent);

    // Use memory stream for better resource management
    using (var ms = new MemoryStream())
    {
        pdf.SaveAs(ms);
        return ms.ToArray();
    }
}
Imports IronPdf
Imports System.IO

' Implement Using block for proper disposal
Using renderer As New ChromePdfRenderer()
    ' Configure for optimal performance
    renderer.RenderingOptions.CreatePdfFormsFromHtml = False
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    renderer.RenderingOptions.PrintHtmlBackgrounds = True

    Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

    ' Use memory stream for better resource management
    Using ms As New MemoryStream()
        pdf.SaveAs(ms)
        Return ms.ToArray()
    End Using
End Using
$vbLabelText   $csharpLabel

O guia de fluxo de memória explica o processamento eficiente de PDFs na memória. Para operações assíncronas , utilize os métodos de renderização assíncrona para melhorar o desempenho.

Como o CSS e as imagens são gerenciados?

O IronPDF oferece suporte completo a estilos CSS e pode incorporar imagens de diversas fontes. O conversor processa todos os elementos com total fidelidade, incluindo várias tags e URLs de imagens . O suporte a gráficos SVG garante que as imagens vetoriais sejam renderizadas perfeitamente.

var html = @"
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
        .highlight { background-color: #f1c40f; padding: 5px; }
    </style>
    <h1>Monthly Report</h1>
    <p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
    <img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
var html = @"
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
        .highlight { background-color: #f1c40f; padding: 5px; }
    </style>
    <h1>Monthly Report</h1>
    <p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
    <img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
Dim html As String = "
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
        .highlight { background-color: #f1c40f; padding: 5px; }
    </style>
    <h1>Monthly Report</h1>
    <p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
    <img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

O renderizador processa estilos embutidos, arquivos CSS e até mesmo imagens codificadas em base64 . Isso garante que suas páginas mantenham a aparência exata do seu conteúdo HTML, incluindo recursos modernos do CSS3, como flexbox e layouts em grade . A conversão preserva todas as tags e estilos sem gerar páginas em branco. As fontes da web e as fontes de ícones são totalmente compatíveis, incluindo o Google Fonts .

Para ambientes conteinerizados, assegure-se de que os recursos externos estejam acessíveis ou incorporados:

// Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_105___");

// Or embed resources using data URIs for self-contained PDFs
var htmlWithEmbeddedResources = @"
    <style>
        @font-face {
            font-family: 'CustomFont';
            src: url(data:font/woff2;base64,...) format('woff2');
        }
    </style>";
// Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_105___");

// Or embed resources using data URIs for self-contained PDFs
var htmlWithEmbeddedResources = @"
    <style>
        @font-face {
            font-family: 'CustomFont';
            src: url(data:font/woff2;base64,...) format('woff2');
        }
    </style>";
' Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_105___")

' Or embed resources using data URIs for self-contained PDFs
Dim htmlWithEmbeddedResources As String = "
    <style>
        @font-face {
            font-family: 'CustomFont';
            src: url(data:font/woff2;base64,...) format('woff2');
        }
    </style>"
$vbLabelText   $csharpLabel

O guia de URLs base explica as estratégias adequadas para referenciar recursos. Para suporte a idiomas internacionais , certifique-se de que a codificação UTF-8 esteja correta.

Como faço para converter Views do ASP.NET Core em PDF?

Converter views inteiras do ASP.NET Core para PDF é uma prática comum, especialmente para gerar relatórios com base em modelos existentes. O IronPDF oferece diversas abordagens para esse cenário, seja trabalhando com uma única página ou com várias páginas . Os tutoriais de CSHTML para PDF abordam implementações específicas de cada framework.

Como faço para converter visualizações MVC?

No seu controlador ASP.NET Core , renderize uma view em HTML e, em seguida, converta-a em PDF usando os poderosos recursos de renderização do IronPDF:

[HttpGet]
public async Task<IActionResult> DownloadPdf()
{
    var invoiceModel = new InvoiceModel
    {
        InvoiceNumber = 12345,
        Date = DateTime.Now,
        CustomerName = "Acme Corporation",
        Items = new List<InvoiceItem>
        {
            new InvoiceItem { Description = "Service", Quantity = 1, Price = 100.0 }
        },
        Total = 100.0
    };
    // Render the view to HTML string
    var htmlContent = await RenderViewToString("Invoice", invoiceModel);
    // Convert HTML to PDF
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    // Return PDF to browser
    var contentType = "application/pdf";
    var fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf";
    return File(pdf.BinaryData, contentType, fileName);
}
private async Task<string> RenderViewToString(string viewName, object model)
{
    ViewData.Model = model;
    using (var writer = new StringWriter())
    {
        var viewResult = viewEngine.FindView(ControllerContext, viewName, false);
        var viewContext = new ViewContext(
            ControllerContext,
            viewResult.View,
            ViewData,
            TempData,
            writer,
            new HtmlHelperOptions()
        );
        await viewResult.View.RenderAsync(viewContext);
        return writer.GetStringBuilder().ToString();
    }
}
[HttpGet]
public async Task<IActionResult> DownloadPdf()
{
    var invoiceModel = new InvoiceModel
    {
        InvoiceNumber = 12345,
        Date = DateTime.Now,
        CustomerName = "Acme Corporation",
        Items = new List<InvoiceItem>
        {
            new InvoiceItem { Description = "Service", Quantity = 1, Price = 100.0 }
        },
        Total = 100.0
    };
    // Render the view to HTML string
    var htmlContent = await RenderViewToString("Invoice", invoiceModel);
    // Convert HTML to PDF
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    // Return PDF to browser
    var contentType = "application/pdf";
    var fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf";
    return File(pdf.BinaryData, contentType, fileName);
}
private async Task<string> RenderViewToString(string viewName, object model)
{
    ViewData.Model = model;
    using (var writer = new StringWriter())
    {
        var viewResult = viewEngine.FindView(ControllerContext, viewName, false);
        var viewContext = new ViewContext(
            ControllerContext,
            viewResult.View,
            ViewData,
            TempData,
            writer,
            new HtmlHelperOptions()
        );
        await viewResult.View.RenderAsync(viewContext);
        return writer.GetStringBuilder().ToString();
    }
}
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpGet>
Public Async Function DownloadPdf() As Task(Of IActionResult)
    Dim invoiceModel = New InvoiceModel With {
        .InvoiceNumber = 12345,
        .Date = DateTime.Now,
        .CustomerName = "Acme Corporation",
        .Items = New List(Of InvoiceItem) From {
            New InvoiceItem With {.Description = "Service", .Quantity = 1, .Price = 100.0}
        },
        .Total = 100.0
    }
    ' Render the view to HTML string
    Dim htmlContent = Await RenderViewToString("Invoice", invoiceModel)
    ' Convert HTML to PDF
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
    ' Return PDF to browser
    Dim contentType = "application/pdf"
    Dim fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf"
    Return File(pdf.BinaryData, contentType, fileName)
End Function

Private Async Function RenderViewToString(viewName As String, model As Object) As Task(Of String)
    ViewData.Model = model
    Using writer = New StringWriter()
        Dim viewResult = viewEngine.FindView(ControllerContext, viewName, False)
        Dim viewContext = New ViewContext(
            ControllerContext,
            viewResult.View,
            ViewData,
            TempData,
            writer,
            New HtmlHelperOptions()
        )
        Await viewResult.View.RenderAsync(viewContext)
        Return writer.GetStringBuilder().ToString()
    End Using
End Function
$vbLabelText   $csharpLabel

Essa abordagem primeiro renderiza sua visualização Razor em uma string HTML e, em seguida, a converte em PDF. O PDF é retornado como um arquivo baixado para o navegador do usuário com um nome de arquivo apropriado. Isso funciona perfeitamente tanto com arquivos ASPX quanto com visualizações Razor modernas. Para Razor Pages , utilize os métodos de renderização dedicados. O guia do MVC Framework abrange versões mais antigas do ASP.NET .

Para implantações em produção, implemente o cache para reduzir a carga do servidor:

private readonly IMemoryCache _cache;

[HttpGet]
public async Task<IActionResult> DownloadCachedPdf(int invoiceId)
{
    var cacheKey = $"invoice_pdf_{invoiceId}";

    if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
    {
        // Generate PDF if not cached
        var htmlContent = await RenderViewToString("Invoice", model);
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdf.BinaryData;

        // Cache for 1 hour
        _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
    }

    return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf");
}
private readonly IMemoryCache _cache;

[HttpGet]
public async Task<IActionResult> DownloadCachedPdf(int invoiceId)
{
    var cacheKey = $"invoice_pdf_{invoiceId}";

    if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
    {
        // Generate PDF if not cached
        var htmlContent = await RenderViewToString("Invoice", model);
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdfBytes = pdf.BinaryData;

        // Cache for 1 hour
        _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
    }

    return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf");
}
Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Caching.Memory

Private ReadOnly _cache As IMemoryCache

<HttpGet>
Public Async Function DownloadCachedPdf(invoiceId As Integer) As Task(Of IActionResult)
    Dim cacheKey = $"invoice_pdf_{invoiceId}"
    Dim pdfBytes As Byte() = Nothing

    If Not _cache.TryGetValue(cacheKey, pdfBytes) Then
        ' Generate PDF if not cached
        Dim htmlContent = Await RenderViewToString("Invoice", model)
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdfBytes = pdf.BinaryData

        ' Cache for 1 hour
        _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1))
    End If

    Return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf")
End Function
$vbLabelText   $csharpLabel

O guia de renderização sem interface gráfica mostra como gerar PDFs sem um contexto de interface gráfica, ideal para serviços em segundo plano.

Posso converter URLs externas?

Para páginas web já existentes, utilize o IronPDF para transformar qualquer URL diretamente em PDFs . Basta fornecer um endereço HTTP ou HTTPS:

[HttpGet]
public IActionResult GeneratePdfFromUrl()
{
    var renderer = new ChromePdfRenderer();
    // Convert a specified URL to PDF document
    var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___");
    // Stream the PDF file to the browser
    return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}
[HttpGet]
public IActionResult GeneratePdfFromUrl()
{
    var renderer = new ChromePdfRenderer();
    // Convert a specified URL to PDF document
    var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___");
    // Stream the PDF file to the browser
    return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}
<HttpGet>
Public Function GeneratePdfFromUrl() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Convert a specified URL to PDF document
    Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___")
    ' Stream the PDF file to the browser
    Return File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End Function
$vbLabelText   $csharpLabel

Esse método funciona bem quando você já possui páginas da web bem formatadas e deseja oferecê-las como PDFs para download. A biblioteca gerencia todos os recursos externos, incluindo folhas de estilo, scripts e imagens, garantindo uma renderização completa. O conversor retorna um código de status HTTP apropriado caso encontre uma URL inválida. Para páginas com uso intensivo de JavaScript , configure atrasos de renderização adequados.

Para ambientes conteinerizados, configure as definições de rede adequadamente:

// Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000; // 60 second timeout
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor = new WaitFor()
{
    RenderDelay = 500, // Wait 500ms after page load
    NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
};
// Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000; // 60 second timeout
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor = new WaitFor()
{
    RenderDelay = 500, // Wait 500ms after page load
    NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
};
' Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000 ' 60 second timeout
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor = New WaitFor() With {
    .RenderDelay = 500, ' Wait 500ms after page load
    .NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
}
$vbLabelText   $csharpLabel

O guia de opções de renderização fornece detalhes completos de configuração. Para conteúdo WebGL , habilite a aceleração por GPU.

Como devo lidar com páginas autenticadas?

Ao converter páginas autenticadas com autenticação de formulários .NET ou outros mecanismos de segurança, passe cookies ou cabeçalhos para manter a sessão do usuário. Isso impede o redirecionamento para telas de login durante a conversão:

var renderer = new ChromePdfRenderer();
// Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies["auth_token"]);
// Convert protected web pages to PDF
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___");
var renderer = new ChromePdfRenderer();
// Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies["auth_token"]);
// Convert protected web pages to PDF
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___");
Dim renderer As New ChromePdfRenderer()
' Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies("auth_token"))
' Convert protected web pages to PDF
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___")
$vbLabelText   $csharpLabel

Isso garante que o conteúdo protegido possa ser convertido em PDFs, mantendo a segurança. O processo de conversão respeita a autenticação básica e a autenticação de formulários do seu aplicativo, impedindo o acesso não autorizado a documentos confidenciais. Você também pode passar argumentos de nome de usuário e senha quando necessário para cenários de autenticação básica. O guia de gerenciamento de cookies explica o manuseio avançado de cookies. Para autenticação Kerberos , configure as credenciais apropriadas.

Para arquiteturas de microsserviços, considere a autenticação serviço a serviço:

// Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken());
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id);

// Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_108___");
// Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken());
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id);

// Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_108___");
' Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken())
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id)

' Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_108___")
$vbLabelText   $csharpLabel

Como posso personalizar a saída em PDF?

O IronPDF oferece amplas opções de personalização para controlar como seus documentos são gerados a partir de HTML. Essas configurações ajudam você a criar PDFs profissionais que atendem a requisitos específicos de layout e formatação de página. Os exemplos de configurações de renderização demonstram implementações práticas.

Como controlar o layout da página?

var renderer = new ChromePdfRenderer();
// Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
// Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var renderer = new ChromePdfRenderer();
// Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
// Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
Dim renderer As New ChromePdfRenderer()
' Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
' Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
$vbLabelText   $csharpLabel

Essas configurações controlam o layout físico das suas páginas. Você pode escolher entre tamanhos de papel padrão ou definir dimensões personalizadas , selecionar a orientação retrato ou paisagem e ajustar as margens para atender às suas necessidades de design. O sistema de modelos gráficos garante um estilo consistente em todas as páginas. Para quebras de página , use propriedades CSS para controlar o fluxo de conteúdo.

Para considerações de design responsivo:

// Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024;
renderer.RenderingOptions.ViewportHeight = 768;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom;
renderer.RenderingOptions.Zoom = 100;
// Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024;
renderer.RenderingOptions.ViewportHeight = 768;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom;
renderer.RenderingOptions.Zoom = 100;
' Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024
renderer.RenderingOptions.ViewportHeight = 768
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom
renderer.RenderingOptions.Zoom = 100
$vbLabelText   $csharpLabel

O guia de configuração da viewport explica as configurações ideais para diferentes tipos de conteúdo. Para saída em tons de cinza , habilite a opção de renderização apropriada.

Como adiciono cabeçalhos e rodapés?

Adicionar cabeçalhos e rodapés consistentes melhora a aparência profissional dos seus documentos:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center'>Company Report</div>",
    MaxHeight = 20
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center'>Company Report</div>",
    MaxHeight = 20
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
Imports System

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align: center'>Company Report</div>",
    .MaxHeight = 20
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
    .MaxHeight = 20
}
$vbLabelText   $csharpLabel

Os cabeçalhos e rodapés suportam formatação HTML com espaços reservados especiais para números de página , datas e outros conteúdos dinâmicos em todas as páginas. O código a seguir demonstra como adicionar cabeçalhos profissionais aos seus documentos gerados. O guia de cabeçalhos HTML mostra opções avançadas de formatação. Para cabeçalhos que contenham apenas texto , utilize os métodos de API mais simples.

Para configurações avançadas de cabeçalho/rodapé com conteúdo dinâmico:

// Create dynamic headers with metadata
var headerHtml = $@"
    <div style='display: flex; justify-content: space-between; font-size: 10px;'>
        <span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
        <span>Environment: {Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}</span>
    </div>";

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = headerHtml,
    MaxHeight = 30,
    DrawDividerLine = true
};
// Create dynamic headers with metadata
var headerHtml = $@"
    <div style='display: flex; justify-content: space-between; font-size: 10px;'>
        <span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
        <span>Environment: {Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}</span>
    </div>";

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = headerHtml,
    MaxHeight = 30,
    DrawDividerLine = true
};
' Create dynamic headers with metadata
Dim headerHtml = $"
    <div style='display: flex; justify-content: space-between; font-size: 10px;'>
        <span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
        <span>Environment: {Environment.GetEnvironmentVariable(""ASPNETCORE_ENVIRONMENT"")}</span>
    </div>"

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = headerHtml,
    .MaxHeight = 30,
    .DrawDividerLine = True
}
$vbLabelText   $csharpLabel

O guia de cabeçalhos em páginas específicas demonstra a aplicação condicional de cabeçalhos/rodapés.

Quais são as melhores práticas de implantação do Docker?

A implementação do IronPDF em ambientes conteinerizados requer considerações específicas para otimizar o desempenho e a confiabilidade. Aqui está um exemplo de Dockerfile pronto para produção:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Install IronPDF Linux dependencies
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libx11-6 \
    libxcomposite1 \
    libxdamage1 \
    libxext6 \
    libxfixes3 \
    libxrandr2 \
    libxrender1 \
    libxtst6 \
    fonts-liberation \
    libnss3 \
    libatk-bridge2.0-0 \
    libdrm2 \
    libxkbcommon0 \
    libgbm1 \
    libasound2 \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourProject.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Set IronPDF temp folder for container environment
ENV IRONPDF_TEMP_FOLDER=/tmp/ironpdf

ENTRYPOINT ["dotnet", "YourProject.dll"]

O guia de integração do Docker fornece instruções completas de implantação. Para tamanhos de contêiner mínimos , use compilações em várias etapas. O guia de implantação do Linux aborda as dependências específicas da plataforma.

Para implantações do Kubernetes, configure os limites de recursos apropriados:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pdf-service
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: pdf-generator
        image: your-registry/pdf-service:latest
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
        env:
        - name: IRONPDF_LICENSE_KEY
          valueFrom:
            secretKeyRef:
              name: ironpdf-license
              key: key
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
apiVersion: apps/v1
kind: Deployment
metadata:
  name: pdf-service
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: pdf-generator
        image: your-registry/pdf-service:latest
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
        env:
        - name: IRONPDF_LICENSE_KEY
          valueFrom:
            secretKeyRef:
              name: ironpdf-license
              key: key
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
YAML

O guia de pastas de tempo de execução explica o gerenciamento de dependências em contêineres. Para o Red Hat Enterprise Linux , configurações adicionais podem ser necessárias.

Quais são as melhores práticas para implantação em produção?

Para garantir o melhor desempenho e qualidade na conversão de HTML para PDF, siga estas práticas comprovadas. Considere implementar o processamento assíncrono para melhor utilização dos recursos em cenários de alto tráfego. O guia de processamento paralelo demonstra técnicas de geração simultânea de PDFs.

Sempre teste a renderização do seu HTML em um navegador primeiro para verificar o estilo e o layout antes de gerar PDFs. Use URLs absolutas para recursos externos sempre que possível, pois caminhos relativos podem causar problemas durante a conversão. Para páginas complexas com uso intensivo de JavaScript , adicione atrasos de renderização para garantir o carregamento completo. Considere implementar o armazenamento em cache para documentos gerados com frequência a fim de reduzir a carga do servidor. Para obter mais informações sobre as melhores práticas do ASP.NET Core , consulte a documentação oficial da Microsoft. O guia de renderização com precisão de pixels garante a melhor qualidade de saída.

Ao implantar em produção, configure os caminhos de pastas temporárias apropriados e certifique-se de que seu ambiente de hospedagem tenha as dependências necessárias instaladas, especialmente para implantações em Linux . Evite colocar o script e a lógica de conversão no mesmo diretório para prevenir conflitos. Consulte nosso guia de solução de problemas para cenários de implantação comuns. Sempre verifique se a entrada não é uma URL quando você pretende processar conteúdo HTML diretamente para evitar comportamentos inesperados. O guia inicial de otimização de renderização aborda os gargalos de desempenho mais comuns.

Para cenários de alto desempenho, implemente o agrupamento de conexões e o gerenciamento de recursos:

public class PdfGeneratorService : IDisposable
{
    private readonly SemaphoreSlim _semaphore;
    private readonly ILogger<PdfGeneratorService> _logger;

    public PdfGeneratorService(ILogger<PdfGeneratorService> logger)
    {
        _logger = logger;
        // Limit concurrent PDF generations
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount * 2);
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        try
        {
            using (var renderer = new ChromePdfRenderer())
            {
                var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
                return pdf.BinaryData;
            }
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public void Dispose()
    {
        _semaphore?.Dispose();
    }
}
public class PdfGeneratorService : IDisposable
{
    private readonly SemaphoreSlim _semaphore;
    private readonly ILogger<PdfGeneratorService> _logger;

    public PdfGeneratorService(ILogger<PdfGeneratorService> logger)
    {
        _logger = logger;
        // Limit concurrent PDF generations
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount * 2);
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        try
        {
            using (var renderer = new ChromePdfRenderer())
            {
                var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
                return pdf.BinaryData;
            }
        }
        finally
        {
            _semaphore.Release();
        }
    }

    public void Dispose()
    {
        _semaphore?.Dispose();
    }
}
Imports System
Imports System.Threading
Imports System.Threading.Tasks
Imports Microsoft.Extensions.Logging

Public Class PdfGeneratorService
    Implements IDisposable

    Private ReadOnly _semaphore As SemaphoreSlim
    Private ReadOnly _logger As ILogger(Of PdfGeneratorService)

    Public Sub New(logger As ILogger(Of PdfGeneratorService))
        _logger = logger
        ' Limit concurrent PDF generations
        _semaphore = New SemaphoreSlim(Environment.ProcessorCount * 2)
    End Sub

    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Await _semaphore.WaitAsync()
        Try
            Using renderer As New ChromePdfRenderer()
                Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))
                Return pdf.BinaryData
            End Using
        Finally
            _semaphore.Release()
        End Try
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _semaphore?.Dispose()
    End Sub
End Class
$vbLabelText   $csharpLabel

O guia de multithreading fornece padrões avançados de concorrência. Para evitar vazamento de memória , implemente padrões de descarte adequados.

Monitore as métricas de desempenho usando registros personalizados :

// Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom;
Installation.CustomLogger = (level, message) =>
{
    _logger.Log(
        level == IronPdf.Logging.LogLevels.Error ? LogLevel.Error : LogLevel.Information,
        "IronPDF: {Message}",
        message
    );
};
// Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom;
Installation.CustomLogger = (level, message) =>
{
    _logger.Log(
        level == IronPdf.Logging.LogLevels.Error ? LogLevel.Error : LogLevel.Information,
        "IronPDF: {Message}",
        message
    );
};
' Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom
Installation.CustomLogger = Sub(level, message)
    _logger.Log(
        If(level = IronPdf.Logging.LogLevels.Error, LogLevel.Error, LogLevel.Information),
        "IronPDF: {Message}",
        message
    )
End Sub
$vbLabelText   $csharpLabel

O guia de arquivos de log do Azure e o gerenciamento de logs da AWS explicam estratégias de registro específicas para cada nuvem. Implementar a integração do suporte de engenharia para uma resolução rápida de problemas.

Para maior segurança, implemente criptografia de PDF e assinaturas digitais . O guia de segurança CVE aborda preocupações comuns de segurança. Considere a higienização de PDFs para conteúdo enviado pelo usuário.

Pronto para implementar a conversão de HTML para PDF?

Converter HTML para PDF em aplicações ASP.NET Core torna-se simples com o IronPDF. A renderização da biblioteca baseada no Chrome garante uma conversão precisa, ao mesmo tempo que oferece amplas opções de personalização para a geração de documentos profissionais.

Seja trabalhando com strings HTML, URLs ou páginas web completas, o IronPDF preserva a formatação exata, o estilo CSS e o comportamento do JavaScript . Essa ferramenta baseada em .NET lida com todo o processo de conversão de forma eficiente. O suporte ao Docker e os recursos de otimização de desempenho da biblioteca a tornam ideal para implantações conteinerizadas modernas e arquiteturas de microsserviços.

Comece seu teste gratuito de 30 dias ou agende uma demonstração com nossa equipe.

Perguntas frequentes

Qual é a função principal do IronPDF em aplicações ASP.NET?

O IronPDF é usado para converter conteúdo HTML em documentos PDF profissionais em aplicações ASP.NET. Ele permite que desenvolvedores gerem faturas, criem relatórios e produzam arquivos PDF para download de forma eficiente.

Por que a conversão de HTML para PDF é importante em projetos ASP.NET?

Converter HTML para PDF é crucial em projetos ASP.NET porque ajuda a oferecer experiências de usuário refinadas, transformando conteúdo dinâmico em documentos PDF profissionais e compartilháveis, como faturas e relatórios.

O IronPDF consegue lidar com conteúdo HTML dinâmico em ASP.NET?

Sim, o IronPDF foi projetado para lidar com conteúdo HTML dinâmico, tornando-o ideal para gerar PDFs a partir de páginas e aplicativos da web ASP.NET dinâmicos.

Quais são alguns casos de uso comuns para conversão de HTML para PDF em ASP.NET?

Os casos de uso mais comuns incluem a geração de faturas, a criação de relatórios e o fornecimento de arquivos PDF para download a partir de aplicativos da web.

O IronPDF suporta formatação em documentos PDF convertidos?

Sim, o IronPDF suporta estilização CSS, permitindo que os desenvolvedores mantenham a aparência do conteúdo HTML original nos documentos PDF convertidos.

Como o IronPDF melhora a experiência do usuário em aplicações ASP.NET?

O IronPDF melhora a experiência do usuário, permitindo que os desenvolvedores ofereçam documentos PDF de alta qualidade, como relatórios e faturas, diretamente de seus aplicativos ASP.NET, garantindo consistência e profissionalismo.

É possível automatizar a geração de PDFs usando o IronPDF?

Sim, o IronPDF permite a automação da geração de PDFs, possibilitando que os desenvolvedores criem e gerenciem documentos PDF programaticamente em seus aplicativos ASP.NET.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim