A conversão de HTML para PDF no Azure Functions requer o mecanismo de renderização Chrome do IronPDF e a configuração adequada do Azure (nível B1 no mínimo), permitindo transformar qualquer conteúdo HTML — de strings simples a páginas com muito JavaScript — em PDFs perfeitos em pixels, mesmo com as restrições do sandbox do Azure e as limitações do GDI+.
Converter conteúdo HTML em documentos PDF em ambientes de nuvem pode ser surpreendentemente desafiador. Se você já tentou implantar um gerador de PDF no Azure Functions, provavelmente se deparou com erros misteriosos relacionados ao GDI+ ou às limitações do ambiente de teste (sandbox). A boa notícia? Com o IronPDF e a configuração correta, você pode converter qualquer conteúdo HTML em arquivos PDF com qualidade de imagem perfeita .
Este tutorial mostra como implantar um conversor de HTML para PDF pronto para produção no Azure Functions usando o IronPDF. Você aprenderá a lidar com tudo, desde strings HTML simples até páginas da web com uso intensivo de JavaScript, enquanto navega pelas restrições exclusivas do ambiente Azure . Quer esteja a criar faturas simples ou relatórios complexos, no final, terá dominado a conversão de HTML para PDF com o IronPDF e o Azure.
Antes de abordarmos a conversão de PDF , vamos entender por que essa tarefa representa um desafio para os desenvolvedores no Azure. Os serviços de aplicativos e sem servidor do Azure são executados em um ambiente de segurança isolado (sandbox) que restringe as operações das quais as bibliotecas de PDF tradicionais dependem:
Essas restrições são mais rigorosas no plano de Consumo e nos níveis Gratuito/Compartilhado do Azure. Por isso, a conversão bem-sucedida de HTML para PDF requer, no mínimo, uma assinatura do Azure Basic B1 ou Premium. Esses arquivos fornecem as permissões e os recursos necessários para que o mecanismo de renderização do Chrome do IronPDF funcione corretamente. Consulte o guia de implantação do IronPDF no Azure para obter mais informações sobre os níveis de hospedagem do Azure e o desempenho de renderização de PDF .
Você tem três opções de implantação ( Windows , Linux ou Container ). Embora o Azure Function App Container seja recomendado, qualquer opção funciona bem.
Hoje vamos nos concentrar na abordagem de contêiner, que fornece um ambiente isolado com configuração mínima e compatibilidade aprimorada com o mecanismo de renderização do IronPDF . Para ambientes especializados como o Azure Government Cloud ou o Azure China, os mesmos princípios se aplicam — basta ajustar os pontos de extremidade de implantação de acordo.
O IronPDF se destaca no Azure por suas capacidades de conversão de HTML para PDF, graças ao seu mecanismo de renderização Chrome . Não se trata apenas de um analisador HTML básico — é a mesma tecnologia que alimenta o Google Chrome, garantindo que seus documentos PDF sejam exibidos exatamente como seriam em um navegador moderno.
O mecanismo do Chrome traz benefícios cruciais para a conversão de HTML em PDF :
Isso significa que você pode pegar qualquer página da web moderna — completa com estilo Bootstrap , frameworks JavaScript ou visualizações complexas — e convertê-la para PDF sem problemas de compatibilidade. IronPDF lida com a execução de uma instância Headless Chrome no ambiente restrito da Azure. Saiba mais sobre os recursos de renderização do IronPDF no Chrome e a renderização de PDF com perfeição de pixels .
Vamos analisar como configurar um aplicativo de funções do Azure otimizado para conversão de HTML em PDF usando o IronPDF.
Antes de começar, certifique-se de que você tem:
Para obter instruções completas de configuração específicas para geração de PDFs no Azure Functions, consulte o tutorial do Azure Functions da IronPDF .
Acesse o Portal do Azure e clique em "Criar um recurso".
Pesquise por "Aplicativo de Função" e clique em "Criar".
Configure o básico:
Configure o plano de hospedagem:
Lembre-se: os planos Gratuito, Compartilhado e por Consumo não funcionam para renderização de PDF.
Revise e crie seu aplicativo de funções.
Primeiro, crie um novo projeto Azure Functions no Visual Studio (ou carregue um existente) e adicione o pacote IronPDF.
Para Implantação no Windows:
Para Implantação em Contêiner Docker (recomendado)
Para obter instruções detalhadas de instalação, incluindo a configuração de pacotes NuGet e considerações específicas da plataforma, visite o guia de instalação do IronPDF .
Configure seu arquivo .cs do aplicativo de funções para obter a melhor conversão de HTML para PDF :
using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
public class HtmlToPdfFunction
{
private readonly ILogger _logger;
public HtmlToPdfFunction(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger<HtmlToPdfFunction>();
// Configure IronPDF for Azure
ConfigureIronPdf();
}
private void ConfigureIronPdf()
{
// Set your license key (get a trial key from ___PROTECTED_URL_132___
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Essential Azure configurations
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
IronPdf.Installation.CustomDeploymentDirectory = "/tmp";
// Optional: Enable logging for troubleshooting
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
}
}Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports Microsoft.Extensions.Logging
Public Class HtmlToPdfFunction
Private ReadOnly _logger As ILogger
Public Sub New(loggerFactory As ILoggerFactory)
_logger = loggerFactory.CreateLogger(Of HtmlToPdfFunction)()
' Configure IronPDF for Azure
ConfigureIronPdf()
End Sub
Private Sub ConfigureIronPdf()
' Set your license key (get a trial key from ___PROTECTED_URL_132___)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Essential Azure configurations
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
IronPdf.Installation.CustomDeploymentDirectory = "/tmp"
' Optional: Enable logging for troubleshooting
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All
End Sub
End ClassVamos começar com o cenário mais comum: converter strings HTML diretamente para PDF . Essa abordagem funciona bem para conteúdo gerado dinamicamente, como faturas , relatórios ou e-mails de confirmação .
[Function("ConvertHtmlToPdf")]
public async Task<HttpResponseData> ConvertHtmlToPdf(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
_logger.LogInformation("Starting HTML to PDF conversion");
try
{
// Simple HTML invoice example
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
<meta charset='UTF-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.header { color: #333; border-bottom: 2px solid #0066cc; }
.invoice-details { margin: 20px 0; }
table { width: 100%; border-collapse: collapse; }
th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
.total { font-weight: bold; font-size: 1.2em; }
</style>
</head>
<body>
<div class='header'>
<h1>Invoice #12345</h1>
<p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
</div>
<div class='invoice-details'>
<table>
<tr>
<th>Item</th>
<th>Quantity</th>
<th>Price</th>
</tr>
<tr>
<td>Professional Services</td>
<td>10 hours</td>
<td>$1,000.00</td>
</tr>
<tr>
<td colspan='2' class='total'>Total</td>
<td class='total'>$1,000.00</td>
</tr>
</table>
</div>
</body>
</html>";
// Create Chrome renderer
var renderer = new ChromePdfRenderer();
// Configure rendering options
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;
// Convert HTML to PDF
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Return PDF as response
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
response.Headers.Add("Content-Disposition", "attachment; filename=invoice.pdf");
await response.Body.WriteAsync(pdf.BinaryData);
_logger.LogInformation("PDF generated successfully");
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error generating PDF");
var errorResponse = req.CreateResponse(HttpStatusCode.InternalServerError);
await errorResponse.WriteStringAsync($"Error: {ex.Message}");
return errorResponse;
}
}Imports System
Imports System.Net
Imports System.Threading.Tasks
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports IronPdf
<Function("ConvertHtmlToPdf")>
Public Class PdfConverter
Private ReadOnly _logger As ILogger
Public Sub New(logger As ILogger)
_logger = logger
End Sub
Public Async Function ConvertHtmlToPdf(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData,
executionContext As FunctionContext) As Task(Of HttpResponseData)
_logger.LogInformation("Starting HTML to PDF conversion")
Try
' Simple HTML invoice example
Dim htmlContent As String = "
<!DOCTYPE html>
<html>
<head>
<meta charset='UTF-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.header { color: #333; border-bottom: 2px solid #0066cc; }
.invoice-details { margin: 20px 0; }
table { width: 100%; border-collapse: collapse; }
th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
.total { font-weight: bold; font-size: 1.2em; }
</style>
</head>
<body>
<div class='header'>
<h1>Invoice #12345</h1>
<p>Date: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
</div>
<div class='invoice-details'>
<table>
<tr>
<th>Item</th>
<th>Quantity</th>
<th>Price</th>
</tr>
<tr>
<td>Professional Services</td>
<td>10 hours</td>
<td>$1,000.00</td>
</tr>
<tr>
<td colspan='2' class='total'>Total</td>
<td class='total'>$1,000.00</td>
</tr>
</table>
</div>
</body>
</html>"
' Create Chrome renderer
Dim renderer As New ChromePdfRenderer()
' Configure rendering options
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25
' Convert HTML to PDF
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Return PDF as response
Dim response = req.CreateResponse(HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
response.Headers.Add("Content-Disposition", "attachment; filename=invoice.pdf")
Await response.Body.WriteAsync(pdf.BinaryData)
_logger.LogInformation("PDF generated successfully")
Return response
Catch ex As Exception
_logger.LogError(ex, "Error generating PDF")
Dim errorResponse = req.CreateResponse(HttpStatusCode.InternalServerError)
Await errorResponse.WriteStringAsync($"Error: {ex.Message}")
Return errorResponse
End Try
End Function
End ClassIsso pega a string HTML fornecida e renderiza em um documento PDF de alta qualidade, completo com as opções de renderização personalizada que configuramos usando a classe RenderingOptions.
Para páginas web existentes ou aplicações complexas, você pode converter URLs diretamente :
[Function("ConvertUrlToPdf")]
public async Task<HttpResponseData> ConvertUrlToPdf(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
var requestBody = await req.ReadAsStringAsync();
var urlRequest = JsonSerializer.Deserialize<UrlRequest>(requestBody);
try
{
var renderer = new ChromePdfRenderer();
// Configure for web page rendering
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Enable JavaScript execution (important for dynamic content)
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 1000; // Wait for JS to execute
// Convert URL to PDF
var pdf = renderer.RenderUrlAsPdf(urlRequest.Url);
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
await response.Body.WriteAsync(pdf.BinaryData);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error converting URL to PDF");
throw;
}
}
public class UrlRequest
{
public string Url { get; set; }
}Imports System
Imports System.Net
Imports System.Text.Json
Imports System.Threading.Tasks
Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports Microsoft.Extensions.Logging
<Function("ConvertUrlToPdf")>
Public Class ConvertUrlToPdfFunction
Private ReadOnly _logger As ILogger
Public Sub New(loggerFactory As ILoggerFactory)
_logger = loggerFactory.CreateLogger(Of ConvertUrlToPdfFunction)()
End Sub
Public Async Function ConvertUrlToPdf(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData,
executionContext As FunctionContext) As Task(Of HttpResponseData)
Dim requestBody As String = Await req.ReadAsStringAsync()
Dim urlRequest As UrlRequest = JsonSerializer.Deserialize(Of UrlRequest)(requestBody)
Try
Dim renderer As New ChromePdfRenderer()
' Configure for web page rendering
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.PrintHtmlBackgrounds = True
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
' Enable JavaScript execution (important for dynamic content)
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.RenderDelay = 1000 ' Wait for JS to execute
' Convert URL to PDF
Dim pdf = renderer.RenderUrlAsPdf(urlRequest.Url)
Dim response = req.CreateResponse(HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
Await response.Body.WriteAsync(pdf.BinaryData)
Return response
Catch ex As Exception
_logger.LogError(ex, "Error converting URL to PDF")
Throw
End Try
End Function
End Class
Public Class UrlRequest
Public Property Url As String
End Class
Aplicações web modernas dependem muito de JavaScript para renderizar conteúdo. Sejam gráficos , formulários dinâmicos ou aplicativos de página única, o mecanismo de renderização do IronPDF lida com todos eles.
Neste exemplo, vamos pegar um arquivo HTML com conteúdo JavaScript e convertê-lo para PDF.
[Function("ConvertComplexHtmlToPdf")]
public async Task<HttpResponseData> ConvertComplexHtmlToPdf(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
try
{
// Load complex HTML from file
// [USER TO PROVIDE: complex-dashboard.html with charts and JavaScript]
string complexHtml = File.ReadAllText("Templates/complex-dashboard.html");
var renderer = new ChromePdfRenderer();
// JavaScript-specific configurations
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(3000); // Wait 3 seconds for JS
// Optional: Set the CSS media type for print or screen styles
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
// Set viewport for responsive designs
renderer.RenderingOptions.ViewPortWidth = 1920;
renderer.RenderingOptions.ViewPortHeight = 1080;
var pdf = renderer.RenderHtmlAsPdf(complexHtml);
// Add metadata
pdf.MetaData.Author = "Azure Function";
pdf.MetaData.CreationDate = DateTime.Now;
pdf.MetaData.Title = "Complex Dashboard Report";
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
await response.Body.WriteAsync(pdf.BinaryData);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error with complex HTML conversion");
throw;
}
}Imports System
Imports System.IO
Imports System.Net
Imports System.Threading.Tasks
Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
<Function("ConvertComplexHtmlToPdf")>
Public Class ConvertComplexHtmlToPdfFunction
Private ReadOnly _logger As ILogger
Public Sub New(loggerFactory As ILoggerFactory)
_logger = loggerFactory.CreateLogger(Of ConvertComplexHtmlToPdfFunction)()
End Sub
Public Async Function ConvertComplexHtmlToPdf(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData,
executionContext As FunctionContext) As Task(Of HttpResponseData)
Try
' Load complex HTML from file
' [USER TO PROVIDE: complex-dashboard.html with charts and JavaScript]
Dim complexHtml As String = File.ReadAllText("Templates/complex-dashboard.html")
Dim renderer As New ChromePdfRenderer()
' JavaScript-specific configurations
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.JavaScript(3000) ' Wait 3 seconds for JS
' Optional: Set the CSS media type for print or screen styles
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
' Set viewport for responsive designs
renderer.RenderingOptions.ViewPortWidth = 1920
renderer.RenderingOptions.ViewPortHeight = 1080
Dim pdf = renderer.RenderHtmlAsPdf(complexHtml)
' Add metadata
pdf.MetaData.Author = "Azure Function"
pdf.MetaData.CreationDate = DateTime.Now
pdf.MetaData.Title = "Complex Dashboard Report"
Dim response = req.CreateResponse(HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
Await response.Body.WriteAsync(pdf.BinaryData)
Return response
Catch ex As Exception
_logger.LogError(ex, "Error with complex HTML conversion")
Throw
End Try
End Function
End Class
Agora vamos converter um arquivo HTML contendo gráficos :
[Function("ConvertChartToPdf")]
public async Task<HttpResponseData> ConvertChartToPdf(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
try
{
// Load chart template
string chartHtml = File.ReadAllText("Templates/chart-template.html");
// Replace placeholders with actual data
var chartData = await GetChartDataAsync();
chartHtml = chartHtml.Replace("{{CHART_DATA}}", JsonSerializer.Serialize(chartData));
var renderer = new ChromePdfRenderer();
// Ensure charts render completely
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(2000);
// Set paper orientation for charts
renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
var pdf = renderer.RenderHtmlAsPdf(chartHtml);
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
await response.Body.WriteAsync(pdf.BinaryData);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Chart conversion error");
throw;
}
}Imports System
Imports System.IO
Imports System.Net
Imports System.Text.Json
Imports System.Threading.Tasks
Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
<Function("ConvertChartToPdf")>
Public Class ChartConverter
Private ReadOnly _logger As ILogger
Public Sub New(logger As ILogger)
_logger = logger
End Sub
Public Async Function ConvertChartToPdf(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData,
executionContext As FunctionContext) As Task(Of HttpResponseData)
Try
' Load chart template
Dim chartHtml As String = File.ReadAllText("Templates/chart-template.html")
' Replace placeholders with actual data
Dim chartData = Await GetChartDataAsync()
chartHtml = chartHtml.Replace("{{CHART_DATA}}", JsonSerializer.Serialize(chartData))
Dim renderer As New ChromePdfRenderer()
' Ensure charts render completely
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(2000)
' Set paper orientation for charts
renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape
Dim pdf = renderer.RenderHtmlAsPdf(chartHtml)
Dim response = req.CreateResponse(HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
Await response.Body.WriteAsync(pdf.BinaryData)
Return response
Catch ex As Exception
_logger.LogError(ex, "Chart conversion error")
Throw
End Try
End Function
Private Async Function GetChartDataAsync() As Task(Of Object)
' Placeholder for actual implementation
Return Await Task.FromResult(New Object())
End Function
End Class
O IronPDF mantém a interatividade original do JavaScript no PDF final gerado .
Arquivos PDF profissionais geralmente exigem cabeçalhos e rodapés consistentes em todas as páginas. O IronPDF simplifica isso com modelos baseados em HTML para opções avançadas de cabeçalho e rodapé .
[Function("ConvertWithHeaderFooter")]
public async Task<HttpResponseData> ConvertWithHeaderFooter(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
FunctionContext executionContext)
{
try
{
string mainContent = @"
<html>
<body>
<h1>Annual Report 2024</h1>
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit...</p>
<!-- Your main content here -->
</body>
</html>";
var renderer = new ChromePdfRenderer();
// Configure margins to accommodate headers/footers
renderer.RenderingOptions.MarginTop = 45;
renderer.RenderingOptions.MarginBottom = 45;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;
// HTML Header with merge fields
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
Height = 35,
HtmlFragment = @"
<div style='text-align: center; font-size: 12px; padding: 10px;'>
<div style='float: left;'>Annual Report 2024</div>
<div style='float: right;'>Page {page} of {total-pages}</div>
<div style='clear: both;'></div>
</div>",
DrawDividerLine = true
};
// HTML Footer
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
Height = 30,
HtmlFragment = @"
<div style='text-align: center; font-size: 10px; padding: 5px;'>
<div>Generated on {date} at {time}</div>
<div>© 2024 Your Company. All rights reserved.</div>
</div>",
DrawDividerLine = true
};
var pdf = renderer.RenderHtmlAsPdf(mainContent);
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
await response.Body.WriteAsync(pdf.BinaryData);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Header/Footer conversion error");
throw;
}
}
public async Task<PdfDocument> CreatePdfWithCustomHeaders(string htmlContent)
{
var renderer = new ChromePdfRenderer();
// First page header (cover page)
renderer.RenderingOptions.FirstPageNumber = 0; // Cover page is page 0
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
Height = 50,
HtmlFragment = "<div style='text-align: center; font-size: 24px;'>Company Logo</div>",
DrawDividerLine = false
};
// Different header for content pages
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Apply different headers to specific pages after rendering
for (int i = 1; i < pdf.PageCount; i++)
{
// Add page-specific content if needed
pdf.StampHtml(i, @"
<div style='position: absolute; top: 10px; right: 10px; font-size: 10px;'>
Section " + GetSectionName(i) + @"
</div>");
}
return pdf;
}
private string GetSectionName(int pageNumber)
{
// Logic to determine section based on page number
return pageNumber <= 5 ? "Introduction" : "Main Content";
}Imports System.Threading.Tasks
Public Class PdfCreator
Public Async Function CreatePdfWithCustomHeaders(htmlContent As String) As Task(Of PdfDocument)
Dim renderer As New ChromePdfRenderer()
' First page header (cover page)
renderer.RenderingOptions.FirstPageNumber = 0 ' Cover page is page 0
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
.Height = 50,
.HtmlFragment = "<div style='text-align: center; font-size: 24px;'>Company Logo</div>",
.DrawDividerLine = False
}
' Different header for content pages
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Apply different headers to specific pages after rendering
For i As Integer = 1 To pdf.PageCount - 1
' Add page-specific content if needed
pdf.StampHtml(i, "
<div style='position: absolute; top: 10px; right: 10px; font-size: 10px;'>
Section " & GetSectionName(i) & "
</div>")
Next
Return pdf
End Function
Private Function GetSectionName(pageNumber As Integer) As String
' Logic to determine section based on page number
Return If(pageNumber <= 5, "Introduction", "Main Content")
End Function
End ClassIsso aplica seus cabeçalhos a intervalos de páginas PDF especificados.
A versatilidade do IronPDF o torna adequado para diversos usos:
Mesmo com a configuração adequada, você pode encontrar desafios específicos do Azure. Aqui estão alguns problemas comuns e suas soluções:
Problema: As fontes personalizadas não estão sendo exibidas corretamente ou estão sendo usadas as fontes do sistema.
Soluções: Os planos de hospedagem compartilhada do Azure restringem o acesso GDI+ necessário para fontes personalizadas . Certifique-se de estar usando pelo menos o nível B1 e incorpore as fontes usando a codificação Base64 .
string htmlWithEmbeddedFont = @"
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,YOUR_BASE64_FONT_HERE) format('woff2');
}
body { font-family: 'CustomFont', Arial, sans-serif; }
</style>";Dim htmlWithEmbeddedFont As String = "
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,YOUR_BASE64_FONT_HERE) format('woff2');
}
body { font-family: 'CustomFont', Arial, sans-serif; }
</style>"Para problemas persistentes com fontes, consulte o guia de solução de problemas de fontes do IronPDF .
Problema: O IronPDF não consegue carregar as dependências quando a opção "Executar a partir do arquivo de pacote" está ativada.
Solução: Esta opção cria um ambiente somente leitura, impedindo o IronPDF de extrair os arquivos necessários. Você pode desativar essa opção nas configurações de publicação ou usar o pacote IronPdf.Slim , que lida melhor com esse cenário.
Problema: Documentos HTML grandes estão causando timeouts ou exceções de memória.
Solução: Configure as definições de tempo limite e memória adequadas:
// In your Function App configuration
renderer.RenderingOptions.Timeout = 120000; // 2 minutes
renderer.RenderingOptions.RequestContext = new RequestContext
{
MaxResponseContentBufferSize = 100 * 1024 * 1024 // 100MB
};' In your Function App configuration
renderer.RenderingOptions.Timeout = 120000 ' 2 minutes
renderer.RenderingOptions.RequestContext = New RequestContext With {
.MaxResponseContentBufferSize = 100 * 1024 * 1024 ' 100MB
}Para configurações de tempo limite do Azure Functions, consulte a documentação de tempo limite da Microsoft . Os desenvolvedores também compartilham soluções na tag Azure Functions do Stack Overflow para lidar com o processamento de documentos grandes.
Para obter mais informações sobre cenários de solução de problemas específicos para a conversão de HTML para PDF no Azure, visite a documentação de solução de problemas do Azure da IronPDF .
A conversão de HTML para PDF pode exigir muitos recursos, dependendo da complexidade do conteúdo. Aqui estão as principais estratégias de otimização para o Azure Functions:
Ao trabalhar com páginas que utilizam muito JavaScript, configure os atrasos de renderização apropriados:
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // Simple pages
renderer.RenderingOptions.WaitFor.RenderDelay = 2000; // Complex JavaScriptrenderer.RenderingOptions.WaitFor.RenderDelay = 500 ' Simple pages
renderer.RenderingOptions.WaitFor.RenderDelay = 2000 ' Complex JavaScriptPara cenários de alto volume, descarte os recursos adequadamente:
using (var renderer = new ChromePdfRenderer())
{
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
// Process PDF
return pdf.BinaryData;
}
}Imports System
Using renderer As New ChromePdfRenderer()
Using pdf = renderer.RenderHtmlAsPdf(html)
' Process PDF
Return pdf.BinaryData
End Using
End UsingArmazene em cache os PDFs gerados quando o conteúdo não for alterado com frequência:
private static readonly MemoryCache _pdfCache = new MemoryCache(new MemoryCacheOptions
{
SizeLimit = 100 // Limit cache size
});
public async Task<byte[]> GetCachedPdf(string cacheKey, string html)
{
if (!_pdfCache.TryGetValue(cacheKey, out byte[] cachedPdf))
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
cachedPdf = pdf.BinaryData;
_pdfCache.Set(cacheKey, cachedPdf, new MemoryCacheEntryOptions
{
Size = 1,
SlidingExpiration = TimeSpan.FromMinutes(10)
});
}
return cachedPdf;
}Imports System
Imports System.Threading.Tasks
Imports Microsoft.Extensions.Caching.Memory
Private Shared ReadOnly _pdfCache As New MemoryCache(New MemoryCacheOptions With {
.SizeLimit = 100 ' Limit cache size
})
Public Async Function GetCachedPdf(cacheKey As String, html As String) As Task(Of Byte())
Dim cachedPdf As Byte() = Nothing
If Not _pdfCache.TryGetValue(cacheKey, cachedPdf) Then
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
cachedPdf = pdf.BinaryData
_pdfCache.Set(cacheKey, cachedPdf, New MemoryCacheEntryOptions With {
.Size = 1,
.SlidingExpiration = TimeSpan.FromMinutes(10)
})
End If
Return cachedPdf
End FunctionA conversão de HTML para PDF no Azure envolve dois componentes de custo:
Os preços variam conforme a região e mudam com o tempo. Consulte este guia da IronPDF para saber como selecionar o plano mais adequado às suas necessidades.
Licenciamento IronPDF
O IronPDF oferece diversas opções de licenciamento :
Visite a página de licenciamento do IronPDF para obter preços detalhados e comparações de recursos.
Embora tenhamos nos concentrado na conversão de HTML para PDF , a segurança é crucial ao lidar com arquivos PDF confidenciais. Para proteger o conteúdo de PDFs contra adulterações indesejadas, saiba mais sobre como proteger suas Azure Functions:
Converter HTML para PDF no Azure não precisa ser complicado. Com o mecanismo de renderização Chrome do IronPDF e a configuração adequada do Azure , você pode transformar qualquer conteúdo HTML em PDFs profissionais.
Principais conclusões para uma conversão bem-sucedida de HTML para PDF no Azure:
O IronPDF oferece mais do que uma simples conversão de HTML para PDF. Este artigo demonstrou suas capacidades para manipulação avançada de PDFs e suporte a imagens em PDFs . O IronPDF se integra facilmente a qualquer aplicativo que você esteja desenvolvendo, incluindo aplicativos de console e aplicativos .NET Core .
Start using IronPDF in your project today with a free trial.
Experimente a versão de avaliação gratuita do IronPDF para acessar seus recursos avançados e comece a converter HTML em PDF em seus aplicativos do Azure hoje mesmo!
Para implantações em produção, explore as opções de licenciamento do IronPDF para encontrar o plano que melhor atenda às suas necessidades. Com documentação completa, suporte ágil e atualizações contínuas , o IronPDF oferece tudo o que você precisa para uma conversão confiável de HTML para PDF no Azure Functions e em outras plataformas.
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.
