Die Konvertierung von HTML in PDF in Azure Functions erfordert die Chrome-Rendering-Engine von IronPDF und eine entsprechende Azure-Konfiguration (mindestens B1-Tarif). Dadurch können Sie beliebige HTML-Inhalte – von einfachen Zeichenketten bis hin zu JavaScript-lastigen Seiten – in pixelgenaue PDFs umwandeln und gleichzeitig die Sandbox-Beschränkungen von Azure und die Einschränkungen von GDI+ berücksichtigen.
Die Konvertierung von HTML-Inhalten in PDF-Dokumente in Cloud-Umgebungen kann überraschend schwierig sein. Falls Sie jemals versucht haben, einen PDF-Generator in Azure Functions bereitzustellen, sind Sie wahrscheinlich auf mysteriöse Fehler im Zusammenhang mit GDI+ oder Sandbox-Beschränkungen gestoßen. Die gute Nachricht? Mit IronPDF und der richtigen Konfiguration können Sie beliebige HTML-Inhalte in pixelgenaue PDF-Dateien konvertieren.
Dieses Tutorial zeigt Ihnen, wie Sie mit IronPDF einen produktionsreifen HTML-zu-PDF-Konverter in Azure Functions bereitstellen. Sie lernen, wie Sie mit allem umgehen, von einfachen HTML-Zeichenketten bis hin zu JavaScript-lastigen Webseiten, und dabei die besonderen Umgebungsbeschränkungen von Azure berücksichtigen. Egal ob Sie einfache Rechnungen oder komplexe Berichte erstellen, am Ende dieses Kurses beherrschen Sie die HTML-zu-PDF-Konvertierung mit IronPDF und Azure.
Bevor wir uns mit der PDF-Konvertierung befassen, wollen wir verstehen, warum diese Aufgabe für Entwickler in Azure eine Herausforderung darstellt. Die Serverless- und App-Dienste von Azure laufen in einer Sicherheits-Sandbox, die Operationen einschränkt, auf die herkömmliche PDF-Bibliotheken angewiesen sind:
Diese Einschränkungen sind in den Azure-Tarifen Consumption und Free/Shared am strengsten. Deshalb ist für eine erfolgreiche HTML-zu-PDF-Konvertierung mindestens ein Azure Basic B1-Tarif oder ein Premium-Abonnement erforderlich. Diese stellen die notwendigen Berechtigungen und Ressourcen bereit, damit die Chrome-Rendering-Engine von IronPDF ordnungsgemäß funktioniert. Weitere Informationen zu den Azure-Hostingebenen und der PDF-Rendering-Leistung finden Sie im Azure-Bereitstellungsleitfaden von IronPDF .
Sie haben drei Bereitstellungsoptionen ( Windows , Linux oder Container ). Obwohl der Azure Function App Container empfohlen wird, funktionieren alle Optionen gut.
Heute konzentrieren wir uns auf den Container-Ansatz, der eine isolierte Umgebung mit minimaler Konfiguration und verbesserter Kompatibilität mit der Rendering-Engine von IronPDF bietet. Für spezialisierte Umgebungen wie Azure Government Cloud oder Azure China gelten die gleichen Prinzipien – passen Sie einfach Ihre Bereitstellungsendpunkte entsprechend an.
IronPDF zeichnet sich durch seine HTML-zu-PDF-Konvertierungsfunktionen in Azure dank seiner Chrome-Rendering-Engine aus. Dies ist nicht nur ein einfacher HTML-Parser – es ist dieselbe Technologie, die auch Google Chrome antreibt und dafür sorgt, dass Ihre PDF-Dokumente genau so angezeigt werden, wie sie es in einem modernen Browser tun würden.
Die Chrome-Engine bietet entscheidende Vorteile für die HTML-zu-PDF-Konvertierung :
Das bedeutet, dass Sie jede moderne Webseite – inklusive Bootstrap-Styling , JavaScript Frameworks oder komplexen Visualisierungen – ohne Kompatibilitätsprobleme in ein PDF konvertieren können. IronPDF handhabt das Ausführen einer headless Chrome-Instanz in der eingeschränkten Umgebung von Azure. Erfahren Sie mehr über die Chrome-Rendering-Funktionen von IronPDF und die pixelgenaue PDF-Erstellung .
Lassen Sie uns die Einrichtung einer Azure Function App durchgehen, die für die HTML-zu-PDF-Konvertierung mit IronPDF optimiert ist.
Stellen Sie sicher, dass Sie Folgendes haben:
Eine vollständige Anleitung zur Einrichtung der PDF-Generierung in Azure Functions finden Sie im Azure Functions-Tutorial von IronPDF .
Navigieren Sie zum Azure-Portal und klicken Sie auf "Ressource erstellen".
Suchen Sie nach "Function App" und klicken Sie auf "Erstellen"
Konfigurieren Sie die Grundlagen:
Veröffentlichen: Wählen Sie "Container" 6. Region: Wählen Sie Ihren bevorzugten Standort aus
Konfigurieren Sie den Hosting-Plan:
Klicken Sie unter Azure App Service Plan auf "Neu erstellen" 2. Preisstufe: Wählen Sie mindestens B1 (Basic) oder höher
Wichtig: Kostenlose, Shared- und Verbrauchstarife funktionieren nicht für die PDF-Darstellung.
Überprüfen und erstellen Sie Ihre Function App
Erstellen Sie zuerst ein neues Azure Functions-Projekt in Visual Studio (oder laden Sie ein bestehendes) und fügen Sie das IronPDF-Paket hinzu.
Für Windows-Bereitstellung:
Für Docker-Container-Bereitstellung (empfohlen)
Detaillierte Installationsanweisungen, einschließlich der Konfiguration von NuGet Paketen und plattformspezifischer Hinweise, finden Sie im IronPDF Installationshandbuch .
Konfigurieren Sie Ihre Funktions-App-.cs-Datei für eine optimale HTML-zu-PDF-Konvertierung :
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 ClassBeginnen wir mit dem häufigsten Szenario: der direkten Konvertierung von HTML-Zeichenketten in PDF . Dieser Ansatz eignet sich gut für dynamisch generierte Inhalte wie Rechnungen , Berichte oder Bestätigungs-E-Mails .
[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 ClassDiese nimmt den gegebenen HTML-String und rendert ihn in ein hochwertiges PDF-Dokument, komplett mit den benutzerdefinierten Rendering-Optionen, die wir mit der RenderingOptions Klasse konfiguriert haben.
Für bestehende Webseiten oder komplexe Anwendungen können Sie URLs direkt konvertieren :
[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
Moderne Webanwendungen sind für die Darstellung von Inhalten stark auf JavaScript angewiesen. Ob Diagramme , dynamische Formulare oder einseitige Anwendungen – die Rendering-Engine von IronPDF bewältigt alles.
In diesem Beispiel nehmen wir eine HTML-Datei mit JavaScript Inhalt und konvertieren sie in eine PDF-Datei.
[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
Nun konvertieren wir eine HTML-Datei mit Diagrammen :
[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 erhält die ursprüngliche JavaScript Interaktivität in der endgültigen PDF-Ausgabe .
Professional PDFs erfordern oft einheitliche Kopf- und Fußzeilen auf allen Seiten. IronPDF macht dies mit HTML-basierten Vorlagen für erweiterte Kopf- und Fußzeilenoptionen unkompliziert.
[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 ClassDadurch werden Ihre Kopfzeilen auf bestimmte PDF-Seitenbereiche angewendet.
Die Vielseitigkeit von IronPDF macht es für viele Anwendungsbereiche geeignet:
Selbst bei korrekter Konfiguration können Azure-spezifische Herausforderungen auftreten. Hier sind häufige Probleme und Lösungen:
Problem: Benutzerdefinierte Schriftarten werden nicht korrekt angezeigt oder es werden Systemschriftarten verwendet.
Lösung: Die Shared-Hosting-Tarife von Azure schränken den für benutzerdefinierte Schriftarten erforderlichen GDI+-Zugriff ein. Stellen Sie sicher, dass Sie mindestens die B1-Ebene verwenden und Schriftarten mit Base64-Kodierung einbetten.
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>"Bei anhaltenden Schriftartproblemen konsultieren Sie bitte den Leitfaden zur Fehlerbehebung für Schriftarten von IronPDF .
Problem: IronPDF kann Abhängigkeiten nicht laden, wenn "Aus Paketdatei ausführen" aktiviert ist.
Lösung: Diese Option erzeugt eine schreibgeschützte Umgebung, die verhindert, dass IronPDF notwendige Dateien extrahiert. Entweder deaktivieren Sie diese Option in Ihren Veröffentlichungseinstellungen oder Sie verwenden das IronPdf.Slim-Paket , das dieses Szenario besser handhabt.
Problem: Große HTML-Dokumente verursachen Timeouts oder Speicherausnahmen.
Lösung: Konfigurieren Sie geeignete Timeout- und Speichereinstellungen:
// 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
}Informationen zu den Timeout-Konfigurationen von Azure Functions finden Sie in der Timeout-Dokumentation von Microsoft . Entwickler tauschen außerdem Lösungen für die Verarbeitung großer Dokumentenmengen auf Stack Overflow unter dem Tag "Azure Functions" aus.
Weitere Szenarien zur Fehlerbehebung speziell bei der HTML-zu-PDF-Konvertierung in Azure finden Sie in der Azure-Fehlerbehebungsdokumentation von IronPDF .
Die Konvertierung von HTML zu PDF kann je nach Komplexität des Inhalts ressourcenintensiv sein. Hier sind die wichtigsten Optimierungsstrategien für Azure Functions:
Bei der Arbeit mit JavaScript-lastigen Seiten sollten geeignete Renderverzögerungen konfiguriert werden:
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 JavaScriptFür hochvolumige Situationen, ordnungsgemäße Freigabe von Ressourcen:
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 UsingCache generierte PDFs, wenn sich der Inhalt nicht häufig ändert:
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 FunctionDie Durchführung der HTML-zu-PDF-Konvertierung in Azure umfasst zwei Kostenkomponenten:
Die Preise variieren je nach Region und können sich im Laufe der Zeit ändern. In diesem IronPDF Leitfaden finden Sie Hilfe bei der Auswahl des für Ihre Bedürfnisse optimalen Tarifs.
IronPDF-Lizenzierung
IronPDF bietet verschiedene Lizenzoptionen an:
Auf der Lizenzseite von IronPDF finden Sie detaillierte Preisinformationen und einen Funktionsvergleich.
Obwohl wir uns auf die Konvertierung von HTML in PDF konzentriert haben, ist Sicherheit beim Umgang mit sensiblen PDF-Dateien von entscheidender Bedeutung. Um PDF-Inhalte vor unerwünschten Manipulationen zu schützen, erfahren Sie mehr über die Sicherung Ihrer Azure Functions:
Die Konvertierung von HTML zu PDF in Azure muss nicht kompliziert sein. Mit der Chrome-Rendering-Engine von IronPDF und der richtigen Azure-Konfiguration können Sie beliebige HTML-Inhalte in Professional PDFs umwandeln.
Wichtigste Erkenntnisse für eine erfolgreiche HTML-zu-PDF-Konvertierung in Azure:
IronPDF bietet mehr als nur die einfache Konvertierung von HTML in PDF. Dieser Artikel demonstrierte seine Fähigkeiten zur fortgeschrittenen PDF-Manipulation und zur Unterstützung von PDF-Bildern . IronPDF lässt sich problemlos in jede von Ihnen entwickelte Anwendung integrieren, einschließlich Konsolenanwendungen und .NET Core Anwendungen .
Start using IronPDF in your project today with a free trial.
Testen Sie IronPDF kostenlos, um auf seine leistungsstarken Funktionen zuzugreifen und noch heute mit der Konvertierung von HTML in PDF in Ihren Azure-Anwendungen zu beginnen!
Für den Einsatz in Produktionsumgebungen sollten Sie die Lizenzierungsoptionen von IronPDF prüfen, um den für Ihre Bedürfnisse passenden Plan zu finden. Mit umfassender Dokumentation , reaktionsschnellem Support und kontinuierlichen Updates bietet IronPDF alles, was Sie für eine zuverlässige HTML-zu-PDF-Konvertierung in Azure Functions und darüber hinaus benötigen.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
