Die Erstellung von Azure-PDFs wird unkompliziert, wenn man die Professional Rendering-Engine von IronPDF mit der flexiblen Cloud-Infrastruktur von Azure kombiniert. Dieser Leitfaden zeigt Ihnen, wie Sie einen produktionsreifen PDF-Generator erstellen, bereitstellen und optimieren, der alles von der HTML-Konvertierung bis hin zur komplexen Dokumentmanipulation abdeckt.
Der Aufbau eines zuverlässigen, cloudbasierten PDF-Generators stellt einzigartige Herausforderungen dar. Aufgrund von Sandbox-Beschränkungen, Speicherbegrenzungen und der Komplexität verteilter Systeme haben viele Entwickler Schwierigkeiten, eine produktionsreife Lösung zu finden. Hier arbeiten Azure und IronPDF gut zusammen – IronPDF bietet Professional PDF-Generierung , die mit Ihrem Arbeitsaufkommen skaliert und gleichzeitig die wichtigsten Funktionen beibehält.
Egal ob Sie Rechnungen oder Berichte erstellen oder Webinhalte in PDFs konvertieren möchten – dieser Leitfaden zeigt Ihnen, wie Sie einen zuverlässigen Azure PDF-Generator erstellen. Sie übernehmen alle Aufgaben von der einfachen HTML-Konvertierung bis hin zur komplexen Dokumentenmanipulation und optimieren dabei Leistung und Kosten.
Starten Sie mit einer kostenlosen Testversion von IronPDF und folgen Sie den Anweisungen, um Ihre Cloud-PDF-Lösung zu erstellen.
Nicht alle PDF-Lösungen funktionieren gut in Cloud-Umgebungen. Ein produktionsreifer Azure PDF-Generator muss über die einfache Dokumentenerstellung hinausgehende, kritische Anforderungen erfüllen. Das Verständnis der Bereitstellungsoptionen von Azure Functions gewährleistet den Erfolg.
Leistungsfähigkeit und Skalierbarkeit bestimmen den Erfolg Ihrer Lösung. Ihr Generator muss gleichzeitige Anfragen ohne Engpässe verarbeiten, bei Lastspitzen automatisch skalieren und auch bei komplexen Dokumenten konsistente Antwortzeiten gewährleisten. Wählen Sie eine Bibliothek, die für Cloud-Umgebungen entwickelt wurde und die Nuancen der serverlosen Architektur versteht.
Die Azure-Plattform bringt spezifische Überlegungen mit sich. Die App-Dienst-Sandbox schränkt Win32/Grafik-APIs ein – Bibliotheken, die Desktop-Grafikstacks verwenden, können fehlschlagen. Speicherbeschränkungen in Verbrauchsplänen führen bei größeren Dokumenten zu Fehlern. Die verteilte Architektur erfordert effiziente zustandslose Operationen. Detaillierte Informationen zur Fehlerbehebung bei Azure-Bereitstellungen finden Sie in der vollständigen Dokumentation zur Fehlerbehebung .
Enterprise benötigen mehr als nur HTML-Konvertierung. Moderne PDF-Generatoren müssen JavaScript Rendering unterstützen, komplexes CSS verarbeiten können und Sicherheitsfunktionen wie Verschlüsselung und digitale Signaturen bieten. IronPDF begegnet diesen Herausforderungen mit seiner auf Chrome basierenden Rendering-Engine und eignet sich daher hervorragend für den Einsatz in Azure.
Azure App-Diensts und Azure Functions hosten beide Cloud-Anwendungen, dienen aber unterschiedlichen Zwecken. Die Wahl der richtigen Lösung beeinflusst Ihre Architektur, Ihr Kostenmodell und Ihren Bereitstellungsansatz.
Azure App-Diensts bietet vollständig verwaltetes Hosting für Webanwendungen, REST-APIs und mobile Backends. Es bietet persistente Ressourcen, unterstützt langlaufende Prozesse und beinhaltet integrierte Skalierung, Bereitstellungsslots und CI/CD-Integration. Diese Eigenschaften machen es ideal für kontinuierlich laufende Anwendungen.
Azure Functions bietet serverlose Rechenleistung für ereignisgesteuerte, kurzlebige Aufgaben. Funktionen werden nur bei Bedarf (HTTP-Anfrage, Timer oder Nachrichtenwarteschlange) ausgeführt, und Sie zahlen nur für die Ausführungszeit. Sie eignen sich hervorragend für Hintergrundprozesse, Datenverarbeitung, Automatisierungsskripte und Microservices, ohne dass ständig Hosts laufen müssen.
| Merkmal | App-Dienst | Azure Functions |
|---|---|---|
| Abrechnungsmodell | Fester monatlicher Betrag | Pro Ausführung |
| Leerlaufkosten | Immer in Rechnung gestellt | Null im Leerlauf |
| Kaltstartrisiko | Minimal | Ja (Verbrauchsplan) |
| Langlaufende PDFs | Unterstützt | Es gelten Zeitlimits. |
| Kundenspezifische Container | Unterstützt | Nur Premium/Dedicated |
Für die Einrichtung von IronPDF in Azure Functions ist die Auswahl des richtigen Pakets erforderlich. Die Bibliothek bietet Optionen für Windows- und Linux-Umgebungen. Die richtige Auswahl der Komponenten gewährleistet optimale Leistung und vermeidet Kompatibilitätsprobleme.
Für Windows-basierte Azure Functions verwenden Sie das Standard- IronPDF Paket, das auf NuGet verfügbar ist. Für Linux-Container verwenden Sie IronPdf.Linux mit Run-from-Package-Bereitstellung für schnellere Kaltstarts.
# NuGet Package Manager (Windows / App-Dienst)
Install-Package IronPdf
# .NET CLI (cross-platform)
dotnet add package IronPdf# Linux / container deployments
Install-Package IronPdf.Linux
# .NET CLI alternative
dotnet add package IronPdf.LinuxHier ist eine vollständige Azure-Funktion zur PDF-Generierung mit korrekter Konfiguration for .NET 10 unter Verwendung von Anweisungen auf oberster Ebene:
using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;
// Configure IronPDF once at startup
License.LicenseKey = Environment.GetEnvironmentVariable("IronPdfLicenseKey") ?? string.Empty;
Installation.LinuxAndDockerDependenciesAutoConfig = true;
Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
Installation.CustomDeploymentDirectory = "/tmp";
var host = new HostBuilder()
.ConfigureFunctionsWorkerDefaults()
.Build();
host.Run();
// Azure Function class
public class PdfGeneratorFunction
{
private readonly ILogger _logger;
public PdfGeneratorFunction(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger<PdfGeneratorFunction>();
}
[Function("GeneratePdf")]
public async Task<HttpResponseData> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "generate-pdf")] HttpRequestData req)
{
string htmlContent = await req.ReadAsStringAsync() ?? string.Empty;
var response = req.CreateResponse(HttpStatusCode.OK);
if (string.IsNullOrWhiteSpace(htmlContent))
{
response.StatusCode = HttpStatusCode.BadRequest;
await response.WriteStringAsync("HTML content is required.");
return response;
}
try
{
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
MarginTop = 10,
MarginBottom = 10,
MarginLeft = 10,
MarginRight = 10,
EnableJavaScript = true
}
};
using var pdf = renderer.RenderHtmlAsPdf(htmlContent);
response.Headers.Add("Content-Type", "application/pdf");
await response.WriteBytesAsync(pdf.BinaryData);
_logger.LogInformation("Generated PDF with {PageCount} pages.", pdf.PageCount);
return response;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error generating PDF.");
response.StatusCode = HttpStatusCode.InternalServerError;
await response.WriteStringAsync($"PDF generation failed: {ex.Message}");
return response;
}
}
}Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports Microsoft.Extensions.Logging
Imports System.Net
' Configure IronPDF once at startup
License.LicenseKey = If(Environment.GetEnvironmentVariable("IronPdfLicenseKey"), String.Empty)
Installation.LinuxAndDockerDependenciesAutoConfig = True
Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
Installation.CustomDeploymentDirectory = "/tmp"
Dim host = New HostBuilder() _
.ConfigureFunctionsWorkerDefaults() _
.Build()
host.Run()
' Azure Function class
Public Class PdfGeneratorFunction
Private ReadOnly _logger As ILogger
Public Sub New(loggerFactory As ILoggerFactory)
_logger = loggerFactory.CreateLogger(Of PdfGeneratorFunction)()
End Sub
<Function("GeneratePdf")>
Public Async Function Run(
<HttpTrigger(AuthorizationLevel.Function, "post", Route:="generate-pdf")> req As HttpRequestData) As Task(Of HttpResponseData)
Dim htmlContent As String = Await req.ReadAsStringAsync() OrElse String.Empty
Dim response = req.CreateResponse(HttpStatusCode.OK)
If String.IsNullOrWhiteSpace(htmlContent) Then
response.StatusCode = HttpStatusCode.BadRequest
Await response.WriteStringAsync("HTML content is required.")
Return response
End If
Try
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.MarginTop = 10,
.MarginBottom = 10,
.MarginLeft = 10,
.MarginRight = 10,
.EnableJavaScript = True
}
}
Using pdf = renderer.RenderHtmlAsPdf(htmlContent)
response.Headers.Add("Content-Type", "application/pdf")
Await response.WriteBytesAsync(pdf.BinaryData)
_logger.LogInformation("Generated PDF with {PageCount} pages.", pdf.PageCount)
Return response
End Using
Catch ex As Exception
_logger.LogError(ex, "Error generating PDF.")
response.StatusCode = HttpStatusCode.InternalServerError
Await response.WriteStringAsync($"PDF generation failed: {ex.Message}")
Return response
End Try
End Function
End ClassDie Konfigurationseinstellungen gewährleisten den Erfolg der Azure-Bereitstellung. LinuxAndDockerDependenciesAutoConfig konfiguriert Chrome-Abhängigkeiten korrekt und das Deaktivieren des GPU-Modus verhindert Probleme beim serverlosen Rendering. Das Festlegen des Bereitstellungsverzeichnisses auf /tmp ermöglicht Schreibzugriff in eingeschränkten Azure Functions-Umgebungen, was eine häufige Quelle für "Zugriff verweigert"-Fehler ist.
Die PDF-Erstellung mit IronPDF erfordert mehr Rechen- und Grafikleistung als weniger umfangreiche Arbeitslasten. Sowohl Microsoft als auch IronPDF raten aufgrund von GDI+-Beschränkungen, Begrenzungen der gemeinsam genutzten Rechenleistung und unzureichendem Speicher von den Tarifen Free, Shared und Consumption ab.
| Stufe | GDI+-Unterstützung | Geeignet für PDF | Anmerkungen |
|---|---|---|---|
| Kostenlos / Gemeinsam | Nein | Nein | Eingeschränkter Sandkasten |
| Verbrauch (Funktionen) | Begrenzt | Begrenzt | Speicherbegrenzungen gelten |
| Basis / Standard | Ja | Ja | Mindestempfehlung |
| Premium / Isoliert | Ja | Ja (am besten) | Voller Funktionszugriff |
Für Workloads mit hohem Volumen bieten die Premium- oder Isolated-Tarife dedizierte Rechenkapazität, VNET-Integration und keine Kaltstartverzögerungen – alles Faktoren, die den PDF-Durchsatz und die Zuverlässigkeit direkt verbessern.
Die Entwicklung einer serverlosen PDF-API mit Azure Functions bietet automatische Skalierung, nutzungsbasierte Abrechnung und minimalen Infrastrukturverwaltungsaufwand. Die unten stehende Funktion akzeptiert JSON-Anfragen mit optionalen Sicherheitseinstellungen und gibt einen PDF-Byte-Stream zurück.
using IronPdf;
using IronPdf.Editing;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;
using System.Text.Json;
public class PdfApiFunction
{
private static readonly ChromePdfRenderer Renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
PrintHtmlBackgrounds = true,
CreatePdfFormsFromHtml = true,
CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
}
};
[Function("ConvertUrlToPdf")]
public async Task<HttpResponseData> ConvertUrl(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
{
var body = await req.ReadAsStringAsync() ?? "{}";
var request = JsonSerializer.Deserialize<ConvertUrlRequest>(body);
if (string.IsNullOrEmpty(request?.Url))
{
var bad = req.CreateResponse(HttpStatusCode.BadRequest);
await bad.WriteStringAsync("URL is required.");
return bad;
}
using var pdf = Renderer.RenderUrlAsPdf(request.Url);
if (request.AddWatermark)
{
pdf.ApplyWatermark(
"<h2>CONFIDENTIAL</h2>",
30,
VerticalAlignment.Middle,
HorizontalAlignment.Center);
}
if (request.ProtectWithPassword && !string.IsNullOrEmpty(request.Password))
{
pdf.SecuritySettings.UserPassword = request.Password;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
}
var response = req.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
await response.WriteBytesAsync(pdf.BinaryData);
return response;
}
}
public class ConvertUrlRequest
{
public string Url { get; set; } = string.Empty;
public bool AddWatermark { get; set; }
public bool ProtectWithPassword { get; set; }
public string Password { get; set; } = string.Empty;
}Imports IronPdf
Imports IronPdf.Editing
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports System.Net
Imports System.Text.Json
Public Class PdfApiFunction
Private Shared ReadOnly Renderer As New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
.PrintHtmlBackgrounds = True,
.CreatePdfFormsFromHtml = True,
.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
}
}
<Function("ConvertUrlToPdf")>
Public Async Function ConvertUrl(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData) As Task(Of HttpResponseData)
Dim body As String = Await req.ReadAsStringAsync() ?? "{}"
Dim request As ConvertUrlRequest = JsonSerializer.Deserialize(Of ConvertUrlRequest)(body)
If String.IsNullOrEmpty(request?.Url) Then
Dim bad As HttpResponseData = req.CreateResponse(HttpStatusCode.BadRequest)
Await bad.WriteStringAsync("URL is required.")
Return bad
End If
Using pdf = Renderer.RenderUrlAsPdf(request.Url)
If request.AddWatermark Then
pdf.ApplyWatermark(
"<h2>CONFIDENTIAL</h2>",
30,
VerticalAlignment.Middle,
HorizontalAlignment.Center)
End If
If request.ProtectWithPassword AndAlso Not String.IsNullOrEmpty(request.Password) Then
pdf.SecuritySettings.UserPassword = request.Password
pdf.SecuritySettings.AllowUserCopyPasteContent = False
End If
Dim response As HttpResponseData = req.CreateResponse(HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
Await response.WriteBytesAsync(pdf.BinaryData)
Return response
End Using
End Function
End Class
Public Class ConvertUrlRequest
Public Property Url As String = String.Empty
Public Property AddWatermark As Boolean
Public Property ProtectWithPassword As Boolean
Public Property Password As String = String.Empty
End ClassDiese Konstruktion bietet Flexibilität bei gleichzeitiger Gewährleistung einer sauberen Trennung. Die Funktion akzeptiert JSON-Anfragen, verarbeitet diese inklusive Fehlerbehandlung und gibt PDFs mit optionaler Sicherheitsfunktion zurück. Sie können Wasserzeichen hinzufügen, Passwortschutz implementieren und digitale Signaturen anwenden.
Die Erstellung von Produktions-PDFs erfordert besondere Aufmerksamkeit hinsichtlich Leistung, Zuverlässigkeit und Ressourcenmanagement. Diese bewährten Verfahren gewährleisten eine optimale Leistung unter realen Bedingungen bei gleichzeitigen Anfragen.
Bei gleichzeitigen Anfragen wird die Speicherverwaltung entscheidend. Entsorgen Sie PDF-Objekte immer mit using-Anweisungen. Bei großen Dokumenten sollte die Ausgabe als Stream erfolgen, anstatt ganze PDFs in den Speicher zu laden. Implementieren Sie eine Anforderungsdrosselung, um Speichererschöpfung bei Lastspitzen zu verhindern.
using IronPdf;
using Microsoft.Extensions.Logging;
public static class PdfProductionService
{
// Limit concurrent PDF operations to avoid memory exhaustion
private static readonly SemaphoreSlim Throttle = new SemaphoreSlim(5);
public static async Task<byte[]> GeneratePdfAsync(string html, ILogger log)
{
await Throttle.WaitAsync();
try
{
using var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
Timeout = 60,
UseMarginsOnHeaderAndFooter = UseMargins.Neinne
}
};
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
using var pdf = renderer.RenderHtmlAsPdf(html);
log.LogInformation(
"PDF generated: {Pages} pages, {Bytes} bytes",
pdf.PageCount,
pdf.BinaryData.Length);
return pdf.BinaryData;
}
finally
{
Throttle.Release();
}
}
}Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System.Threading
Public Module PdfProductionService
' Limit concurrent PDF operations to avoid memory exhaustion
Private ReadOnly Throttle As New SemaphoreSlim(5)
Public Async Function GeneratePdfAsync(html As String, log As ILogger) As Task(Of Byte())
Await Throttle.WaitAsync()
Try
Using renderer As New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.Timeout = 60,
.UseMarginsOnHeaderAndFooter = UseMargins.Neinne
}
}
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
Using pdf = renderer.RenderHtmlAsPdf(html)
log.LogInformation("PDF generated: {Pages} pages, {Bytes} bytes", pdf.PageCount, pdf.BinaryData.Length)
Return pdf.BinaryData
End Using
End Using
Finally
Throttle.Release()
End Try
End Function
End ModuleDie Überwachung ermöglicht es Ihnen, den Zustand Ihres PDF-Generators einzusehen. Verwenden Sie Application Insights, um Generierungszeiten, Fehlerraten und Ressourcenverbrauch zu verfolgen. Richten Sie Warnmeldungen für Anomalien wie vermehrte Fehler oder eine Verschlechterung der Reaktionsfähigkeit ein. Protokollieren Sie detaillierte Informationen zu jeder Anfrage zur Fehlerbehebung.
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;
// Track custom metrics using Application Insights
var telemetry = new TelemetryClient(TelemetryConfiguration.CreateDefault());
var sw = System.Diagnostics.Stopwatch.StartNew();
var pdfBytes = await PdfProductionService.GeneratePdfAsync(html, logger);
sw.Stop();
telemetry.TrackMetric("PdfGenerationTimeMs", sw.Elapsed.TotalMilliseconds);
telemetry.TrackMetric("PdfFileSizeBytes", pdfBytes.Length);Imports Microsoft.ApplicationInsights
Imports Microsoft.ApplicationInsights.Extensibility
Imports System.Diagnostics
' Track custom metrics using Application Insights
Dim telemetry As New TelemetryClient(TelemetryConfiguration.CreateDefault())
Dim sw As Stopwatch = Stopwatch.StartNew()
Dim pdfBytes = Await PdfProductionService.GeneratePdfAsync(html, logger)
sw.Stop()
telemetry.TrackMetric("PdfGenerationTimeMs", sw.Elapsed.TotalMilliseconds)
telemetry.TrackMetric("PdfFileSizeBytes", pdfBytes.Length)Die erweiterten Funktionen von IronPDF erweitern Ihren PDF-Generator über die grundlegende PDF-Erstellung hinaus. Diese Funktionen werden in Azure vollständig unterstützt und ermöglichen Professional Workflows zur Dokumentenverarbeitung.
IronPDF unterstützt Passwortschutz und Berechtigungsverwaltung für eine detaillierte Dokumentenkontrolle. Die Funktion für PDF-Berechtigungen und Passwörter verwendet AES-256-Verschlüsselung:
using IronPdf;
// Load or generate the PDF
using var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Secure Report</h1>");
// Apply password protection
pdf.SecuritySettings.UserPassword = "view-password";
pdf.SecuritySettings.OwnerPassword = "admin-password";
// Restrict permissions
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SaveAs("azure-secure-report.pdf");Imports IronPdf
' Load or generate the PDF
Using pdf = New ChromePdfRenderer().RenderHtmlAsPdf("<h1>Secure Report</h1>")
' Apply password protection
pdf.SecuritySettings.UserPassword = "view-password"
pdf.SecuritySettings.OwnerPassword = "admin-password"
' Restrict permissions
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SaveAs("azure-secure-report.pdf")
End UsingSie können Verschlüsselung mit digitalen Signaturen kombinieren, um unanfechtbare, fälschungssichere Dokumente zu erstellen.
Das Hinzufügen von Kopf- und Fußzeilen mit dynamischen Seitenzahlen und benutzerdefinierten Wasserzeichen funktioniert in Azure genauso wie in jeder anderen .NET Umgebung:
using IronPdf;
using var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Report content goes here.</p>");
// Add dynamic header with page numbers
var header = new HtmlHeaderFooter
{
HtmlFragment = "<div style='text-align:right;font-size:10px'>Page {page} of {total-pages}</div>",
Height = 15
};
pdf.AddHTMLHeaders(header);
// Apply a draft watermark when needed
pdf.ApplyWatermark(
"<h1 style='color:gray;opacity:0.3'>DRAFT</h1>",
45,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center);
pdf.SaveAs("report-with-header.pdf");Imports IronPdf
Using pdf = New ChromePdfRenderer().RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Report content goes here.</p>")
' Add dynamic header with page numbers
Dim header As New HtmlHeaderFooter With {
.HtmlFragment = "<div style='text-align:right;font-size:10px'>Page {page} of {total-pages}</div>",
.Height = 15
}
pdf.AddHTMLHeaders(header)
' Apply a draft watermark when needed
pdf.ApplyWatermark(
"<h1 style='color:gray;opacity:0.3'>DRAFT</h1>",
45,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center)
pdf.SaveAs("report-with-header.pdf")
End UsingSie können auch PDFs zusammenführen oder aufteilen, Text extrahieren, PDFs in Bilder konvertieren und mit PDF-Formularen arbeiten.
Selbst bei korrekter Konfiguration treten beim Einsatz von PDF-Generatoren in Azure häufig bestimmte Probleme auf. Das Verständnis dieser Probleme spart wertvolle Zeit bei der Fehlersuche.
Fehler der Art "Zugriff auf den Pfad verweigert" treten auf, wenn IronPDF keine temporären Dateien schreiben kann. Setzen Sie Installation.CustomDeploymentDirectory = "/tmp", um Schreibzugriff sicherzustellen. Wenn Sie die Run-from-Package-Bereitstellung verwenden, stellen Sie sicher, dass die App einen separaten beschreibbaren Pfad hat, da /home/site/wwwroot in diesem Modus nur lesbar ist.
Timeout-Ausnahmen treten auf, wenn das Rendern komplexer Dokumente das Funktionstimeout von Azure überschreitet. Erhöhen Sie das Renderer-Timeout, fügen Sie eine Renderverzögerung for JavaScript-lastige Seiten hinzu oder lagern Sie große Aufgaben in eine dauerhafte Aufgabenwarteschlange aus.
Probleme bei der Schriftwiedergabe äußern sich in fehlenden oder fehlerhaften Schriftarten. Schriftarten können mithilfe der Base64-Codierung eingebettet, websichere Schriftarten, die Azure nativ unterstützt, verwendet oder eine Containerbereitstellung für die vollständige Kontrolle über die Schriftarten gewählt werden.
Speicherausnahmen entstehen aufgrund des hohen Speicherbedarfs bei der PDF-Generierung. Häufige Probleme sind Speichermangel bei großen oder gleichzeitigen Anfragen.
Zu den bewährten Verfahren gehören:
PdfDocument-Objekte sofort mit using-AnweisungenSemaphoreSlim, wie im Produktionsdienstbeispiel gezeigtEine solide Bereitstellungsstrategie gewährleistet, dass Ihr PDF-Generator stabil, nachvollziehbar und einfach zu aktualisieren bleibt. Die folgenden Vorgehensweisen gelten unabhängig davon, ob Sie Azure App-Dienst oder Azure Functions als Zielplattform verwenden.
/tmp für Linux-Container) beim Start der AnwendungIronPdf.Linux für containerbasierte Bereitstellungen; Verwenden Sie das Standard-IronPdf-Paket für Windows App-DienstApplication Insights integriert sich direkt mit Azure Functions und App-Dienst. Verwenden Sie TelemetryClient, um benutzerdefinierte Metriken pro PDF-Erzeugungsereignis zu verfolgen:
using Microsoft.ApplicationInsights;
var telemetryClient = new TelemetryClient();
telemetryClient.TrackMetric("PdfGenerationTimeMs", generationTime.TotalMilliseconds);
telemetryClient.TrackMetric("PdfPageCount", pdfPageCount);
telemetryClient.TrackMetric("PdfFileSizeBytes", fileSizeBytes);Imports Microsoft.ApplicationInsights
Dim telemetryClient As New TelemetryClient()
telemetryClient.TrackMetric("PdfGenerationTimeMs", generationTime.TotalMilliseconds)
telemetryClient.TrackMetric("PdfPageCount", pdfPageCount)
telemetryClient.TrackMetric("PdfFileSizeBytes", fileSizeBytes)Richten Sie im Azure-Portal metrikbasierte Warnungen ein, um benachrichtigt zu werden, wenn die Generierungszeiten einen akzeptablen Schwellenwert überschreiten oder die Fehlerraten sprunghaft ansteigen.
Sie haben nun ein vollständiges Bild für die Erstellung eines produktionsreifen Azure PDF-Generators: von der Auswahl der richtigen Azure-Ebene und der Installation des richtigen NuGet Pakets über die Konfiguration des Renderers für Cloud-Umgebungen bis hin zum Hinzufügen von Sicherheit, Überwachung und Ressourcenbegrenzung.
Die Kombination aus der Cloud-Infrastruktur von Azure und der Chrome-basierten Rendering-Engine von IronPDF schafft eine PDF-Plattform, die mit Ihren Bedürfnissen skaliert. Egal, ob Sie nur wenige Dokumente oder Tausende pro Stunde verarbeiten, der Generator bietet eine gleichbleibende Leistung bei vorhersehbaren Kosten.
Machen Sie sich zunächst mit der Funktionsübersicht von IronPDF vertraut , um sich einen Überblick über die verfügbaren Funktionen zu verschaffen, und lesen Sie anschließend die Dokumentation , um Details zur API zu erfahren. Wenn Sie bereit für den Einsatz sind, aktivieren Sie eine kostenlose Testlizenz für umfassende Tests ohne Gebühren pro Dokument. Prüfen Sie die Lizenzoptionen , um den Plan auszuwählen, der zu Ihrem Produktionsworkload passt.
Für zusätzliche Dokumentverarbeitungsoptionen, erkunden Sie den IronPDF NuGet-Installationsleitfaden und die vollständige Iron Software Produkt-Suite.
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.
