Konwersja HTML do PDF w Azure Functions wymaga silnika renderującego IronPDF dla przeglądarki Chrome oraz odpowiedniej konfiguracji Azure (minimum poziom B1), co pozwala przekształcić dowolną zawartość HTML — od prostych ciągów znaków po strony z dużą ilością kodu JavaScript — w pliki PDF o idealnej rozdzielczości, przy jednoczesnym uwzględnieniu ograniczeń środowiska testowego Azure oraz ograniczeń GDI+.
Konwersja treści HTML do dokumentów PDF w środowiskach chmurowych może być zaskakująco trudna. Jeśli kiedykolwiek próbowałeś wdrożyć generator plików PDF w Azure Functions, prawdopodobnie napotkałeś tajemnicze błędy związane z GDI+ lub ograniczeniami piaskownicy. Dobra wiadomość? Dzięki IronPDF i odpowiedniej konfiguracji możesz przekonwertować dowolną treść HTML na pliki PDF o idealnej jakości.
Ten samouczek pokazuje, jak wdrożyć gotowy do użycia w środowisku produkcyjnym konwerter HTML na PDF w usłudze Azure Functions przy użyciu IronPDF. Dowiesz się, jak radzić sobie ze wszystkim, od prostych ciągów HTML po strony internetowe z dużą ilością kodu JavaScript, jednocześnie poruszając się po specyficznych ograniczeniach środowiska Azure. Niezależnie od tego, czy tworzysz proste faktury, czy złożone raporty, w końcu opanujesz konwersję HTML do PDF za pomocą IronPDF i Azure.
Zanim przejdziemy do konwersji plików PDF, spróbujmy zrozumieć, dlaczego zadanie to stanowi wyzwanie dla programistów korzystających z platformy Azure. Usługi bezserwerowe i aplikacyjne platformy Azure działają w bezpiecznej piaskownicy, która ogranicza operacje, od których zależą tradycyjne biblioteki PDF:
Ograniczenia te są najsurowsze w planie konsumpcyjnym Azure oraz w warstwach bezpłatnych/współdzielonych. Dlatego udana konwersja HTML do PDF wymaga co najmniej subskrypcji Azure Basic B1 lub Premium. Zapewniają one niezbędne uprawnienia i zasoby do prawidłowego działania silnika renderującego IronPDF w przeglądarce Chrome. Zapoznaj się z przewodnikiem wdrożeniowym IronPDF dla platformy Azure, aby uzyskać więcej informacji na temat poziomów hostingu Azure i wydajności renderowania plików PDF.
Dostępne są trzy opcje wdrożenia (Windows, Linux lub kontener). Chociaż zalecane jest użycie Azure Function App Container, każda opcja działa dobrze.
Dzisiaj skupimy się na podejściu kontenerowym, które zapewnia izolowane środowisko przy minimalnej konfiguracji i lepszej kompatybilności z silnikiem renderującym IronPDF. W przypadku środowisk specjalistycznych, takich jak Azure Government Cloud lub Azure China, obowiązują te same zasady — wystarczy odpowiednio dostosować punkty końcowe wdrożenia.
IronPDF wyróżnia się możliwościami konwersji HTML do PDF w Azure dzięki silnikowi renderowania Chrome. To nie jest tylko podstawowy parser HTML — to ta sama technologia, która napędza przeglądarkę Google Chrome, zapewniająca, że dokumenty PDF wyświetlają się dokładnie tak, jak w nowoczesnej przeglądarce.
Silnik Chrome zapewnia kluczowe korzyści przy konwersji HTML do PDF:
Oznacza to, że można wziąć dowolną nowoczesną stronę internetową — wraz ze stylami Bootstrap, frameworkami JavaScript lub złożonymi wizualizacjami — i przekonwertować ją do formatu PDF bez problemów z kompatybilnością. IronPDF obsługuje uruchamianie instancji bezgłowego Chrome w ograniczonym środowisku Azure. Dowiedz się więcej o możliwościach renderowania IronPDF w przeglądarce Chrome oraz o renderowaniu plików PDF z idealną dokładnością pikselową.
Przejdźmy przez proces konfiguracji aplikacji Azure Function zoptymalizowanej pod kątem konwersji HTML do PDF przy użyciu IronPDF.
Przed rozpoczęciem upewnij się, że masz:
Pełne instrukcje konfiguracji dotyczące generowania plików PDF w Azure Functions można znaleźć w samouczku IronPDF dotyczącym Azure Functions.
Przejdź do portalu Azure i kliknij "Utwórz zasób"
Wyszukaj "Function App" i kliknij "Utwórz"
Skonfiguruj podstawowe ustawienia:
Skonfiguruj plan hostingowy:
Pamiętaj: plany Free, Shared i Consumption nie obsługują renderowania plików PDF
Przejrzyj i utwórz swoją aplikację Function App
Najpierw utwórz nowy projekt funkcji Azure w Visual Studio (lub załaduj istniejący) i dodaj pakiet IronPDF.
Dla wdrożenia w Windows:
Dla wdrożenia w kontenerze Docker (zalecane)
Szczegółowe instrukcje instalacji, w tym konfigurację pakietów NuGet i uwagi dotyczące poszczególnych platform, można znaleźć w przewodniku instalacji IronPDF.
Skonfiguruj plik .cs aplikacji Function App w celu uzyskania optymalnej konwersji HTML do 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 ClassZacznijmy od najczęstszego scenariusza: bezpośredniej konwersji ciągów HTML do formatu PDF. Takie podejście sprawdza się dobrze w przypadku treści generowanych dynamicznie, takich jak faktury, raporty czy e-maile z potwierdzeniami.
[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 ClassTo pobiera dany ciąg HTML i renderuje go do wysokiej jakości dokumentu PDF, zawierającego niestandardowe opcje renderowania, które skonfigurowaliśmy za pomocą klasy RenderingOptions.
W przypadku istniejących stron internetowych lub złożonych aplikacji można bezpośrednio konwertować adresy URL:
[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
Nowoczesne aplikacje internetowe w dużym stopniu opierają się na JavaScript do renderowania treści. Niezależnie od tego, czy chodzi o wykresy, formularze dynamiczne czy aplikacje jednostronicowe, silnik renderujący IronPDF obsługuje je wszystkie.
W tym przykładzie weźmiemy plik HTML z treścią JavaScript i przekonwertujemy go do formatu 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
Teraz przekonwertujmy plik HTML zawierający wykresy:
[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
IronPDF zachowuje oryginalną interaktywność JavaScript w końcowym pliku PDF.
Profesjonalne pliki PDF często wymagają spójnych nagłówków i stopek na wszystkich stronach. IronPDF ułatwia to dzięki szablonom opartym na HTML, oferującym zaawansowane opcje nagłówków i stopek.
[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 ClassSpowoduje to zastosowanie nagłówków do określonych zakresów stron pliku PDF.
Wszechstronność IronPDF sprawia, że nadaje się on do wielu zastosowań:
Nawet przy prawidłowej konfiguracji mogą pojawić się problemy specyficzne dla platformy Azure. Oto typowe problemy i rozwiązania:
Problem: Niestandardowe czcionki nie wyświetlają się poprawnie lub zastępowane są czcionkami systemowymi.
Rozwiązania: Poziomy hostingu współdzielonego platformy Azure ograniczają dostęp do GDI+, niezbędny do obsługi niestandardowych czcionek. Upewnij się, że korzystasz z co najmniej poziomu B1 i osadzasz czcionki przy użyciu kodowania 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>"W przypadku utrzymujących się problemów z czcionkami zapoznaj się z przewodnikiem IronPDF dotyczącym rozwiązywania problemów z czcionkami.
Problem: IronPDF nie ładuje zależności, gdy włączona jest opcja "Uruchom z pliku pakietu".
Rozwiązanie: Ta opcja tworzy środowisko tylko do odczytu, uniemożliwiające IronPDF wyodrębnianie niezbędnych plików. Wyłącz tę opcję w ustawieniach publikacji lub skorzystaj z pakietu IronPdf.Slim, który lepiej radzi sobie w tej sytuacji.
Problem: Duże dokumenty HTML powodują przekroczenie limitu czasu lub wyjątki pamięci.
Rozwiązanie: Skonfiguruj odpowiednie ustawienia limitu czasu i pamięci:
// 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
}Aby uzyskać informacje na temat konfiguracji limitów czasu w Azure Functions, zapoznaj się z dokumentacją Microsoftu dotyczącą limitów czasu. Programiści dzielą się również rozwiązaniami na Stack Overflow w tagu Azure Functions, dotyczącym przetwarzania dużych dokumentów.
Aby uzyskać więcej informacji na temat rozwiązywania problemów związanych z konwersją HTML do PDF w Azure, odwiedź dokumentację IronPDF dotyczącą rozwiązywania problemów w Azure.
Konwersja HTML do PDF może wymagać dużych zasobów w zależności od złożoności treści. Oto kluczowe strategie optymalizacji dla Azure Functions:
Podczas pracy ze stronami zawierającymi dużo kodu JavaScript należy skonfigurować odpowiednie opóźnienia renderowania:
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 JavaScriptW przypadku scenariuszy o dużej objętości należy odpowiednio utylizować zasoby:
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 UsingBuforuj wygenerowane pliki PDF, gdy treść nie zmienia się często:
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 FunctionKonwersja plików HTML do formatu PDF w platformie Azure wiąże się z dwoma składnikami kosztów:
Ceny różnią się w zależności od regionu i zmieniają się w czasie. Zapoznaj się z tym przewodnikiem IronPDF, aby wybrać plan najlepiej odpowiadający Twoim potrzebom.
Licencjonowanie IronPDF
IronPDF oferuje kilka opcji licencyjnych:
Odwiedź stronę licencyjną IronPDF, aby zapoznać się ze szczegółowymi cenami i porównaniem funkcji.
Chociaż skupiliśmy się na konwersji HTML do PDF, bezpieczeństwo ma kluczowe znaczenie podczas pracy z poufnymi plikami PDF. Aby zabezpieczyć zawartość plików PDF przed niepożądanymi zmianami, dowiedz się więcej o zabezpieczaniu Azure Functions Functions:
Konwersja HTML do PDF w Azure nie musi być skomplikowana. Dzięki silnikowi renderowania IronPDF dla przeglądarki Chrome i odpowiedniej konfiguracji platformy Azure można przekształcić dowolną zawartość HTML w profesjonalne pliki PDF.
Najważniejsze wskazówki dotyczące udanej konwersji HTML do PDF w Azure:
IronPDF oferuje więcej niż tylko prostą konwersję HTML do PDF. W tym artykułe zaprezentowano możliwości zaawansowanej obróbki plików PDF oraz obsługę obrazów w formacie PDF. IronPDF łatwo integruje się z każdą tworzoną aplikacją, w tym z aplikacjami konsolowymi i aplikacjami .NET Core.
Start using IronPDF in your project today with a free trial.
Wypróbuj bezpłatną wersję próbną IronPDF, aby uzyskać dostęp do jego zaawansowanych funkcji i już dziś zacznij konwertować pliki HTML do formatu PDF w swoich aplikacjach Azure!
W przypadku wdrożeń produkcyjnych zapoznaj się z opcjami licencyjnymi IronPDF, aby znaleźć plan dostosowany do Twoich potrzeb. Dzięki obszernej dokumentacji, responsywnemu wsparciu technicznemu i ciągłym aktualizacjom IronPDF zapewnia wszystko, czego potrzebujesz do niezawodnej konwersji HTML do PDF w Azure Functions i nie tylko.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
