Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. Azure HTML do PDF
KORZYSTANIE Z IRONPDF

Jak przekonwertować HTML na PDF z użyciem Azure i IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

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

Dlaczego warto nauczyć się konwersji HTML do PDF?

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.

!{--01001100010010010100001001010010010000010101001001011001010111110100011101000101010101000101111101010011010101000100000101010010010101000100010101000100010111110101011101001001010100010010000101111101010000010100100100111101000100010101010100001101010100010111110101010001010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Dlaczego konwersja HTML do PDF stanowi wyzwanie w 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:

  • Ograniczony dostęp do GDI+: Wywołania Windows Graphics są blokowane na niższych poziomach.
  • Ograniczenia dotyczące renderowania czcionek: Czcionki niestandardowe i czcionki SVG podlegają ograniczeniom.
  • Ograniczenia pamięci: Konwersja HTML do PDF wymaga znacznych zasobów.
  • Izolacja procesów: Uruchamianie silników przeglądarek wymaga specjalnych uprawnień.

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.

Która opcja wdrożenia platformy Azure najlepiej sprawdza się w przypadku generowania 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.

Dlaczego IronPDF wyróżnia się w zakresie konwersji HTML do PDF w Azure?

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.

Które funkcje silnika renderującego Chrome mają największe znaczenie?

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 Chrome bez interfejsu graficznego w środowisku o ograniczonym dostępie w 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ą.

Jak skonfigurować środowisko Microsoft Azure do konwersji HTML na PDF?

Przejdźmy przez proces konfiguracji aplikacji Azure Function zoptymalizowanej pod kątem konwersji HTML do PDF przy użyciu IronPDF.

Jakie warunki muszę spełnić przed rozpoczęciem pracy?

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.

Jak utworzyć aplikację Azure Function?

  1. Przejdź do portalu Azure i kliknij "Utwórz zasób"
  2. Wyszukaj "Function App" i kliknij "Utwórz"

  3. Skonfiguruj podstawowe ustawienia:

    1. Wybierz opcję hostingu: Wybierz opcję, która odpowiada Twoim potrzebom
    2. Subskrypcja: Wybierz swoją subskrypcję platformy Azure
    3. Grupa zasobów: Utwórz nową lub wybierz istniejącą
    4. Nazwa aplikacji funkcyjnej: Wybierz unikalną nazwę
    5. Opublikuj: Wybierz "Container"
    6. Region: Wybierz preferowaną lokalizację

  4. Skonfiguruj plan hostingowy:

    1. Kliknij "Utwórz nowy" w sekcji Plan usługi Azure App Service
    2. Poziom cenowy: Wybierz co najmniej B1 (Podstawowy) lub wyższy
  5. Pamiętaj: plany Free, Shared i Consumption nie obsługują renderowania plików PDF
  6. Przejrzyj i utwórz swoją aplikację Function App

Jak zainstalować IronPDF w moim projekcie?

Najpierw utwórz nowy projekt Azure Functions w Visual Studio (lub załaduj istniejący) i dodaj pakiet IronPDF:

Install-Package IronPdf  #For Windows Deployment
Install-Package IronPdf  #For Windows Deployment
SHELL 
Install-Package IronPdf.Linux  #For Docker Container deployment (recommended)
Install-Package IronPdf.Linux  #For Docker Container deployment (recommended)
SHELL

Szczegółowe instrukcje instalacji, w tym konfigurację pakietów NuGet i uwagi dotyczące poszczególnych platform, można znaleźć w przewodniku instalacji IronPDF.

Jakie ustawienia konfiguracyjne są niezbędne dla platformy Azure?

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;
    }
}
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 Class
$vbLabelText   $csharpLabel

Jak konwertować ciągi znaków HTML do formatu PDF?

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

Jak przeprowadzić podstawową konwersję ciągu znaków HTML?

[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;
    }
}
[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 ConvertHtmlToPdfFunction
    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 Class
$vbLabelText   $csharpLabel

Pobiera podany ciąg HTML i renderuje go do wysokiej jakości dokumentu PDF, wraz z niestandardowymi opcjami renderowania, które skonfigurowaliśmy przy użyciu klasy RenderingOptions.

Jak wygląda plik PDF?

PDF viewer displaying a simple invoice (#12345) with one line item for 10 hours of professional services totaling $1,000

Jak przekonwertować adresy URL na pliki PDF?

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; }
}
[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(logger As ILogger(Of ConvertUrlToPdfFunction))
        _logger = logger
    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 As HttpResponseData = 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
$vbLabelText   $csharpLabel

Jak wygląda wynik konwersji adresu URL?

Widok podzielonego ekranu strony głównej Apple, na którym po lewej stronie wyświetlane są produkty z rodziny iPhone 16, a po prawej Apple Watch Series 10 wraz z promocjami dotyczącymi wymiany starego urządzenia i karty Apple Card

Jak radzić sobie ze złożoną zawartością HTML za pomocą JavaScript?

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.

Jak pracować z treściami zawierającymi dużo kodu JavaScript?

W tym przykładzie weźmiemy plik HTML z treścią JavaScript i przekonwertujemy go do formatu PDF.

Analytics dashboard displaying company KPIs including $45,200 total revenue, monthly sales trends from January to June, weekly website traffic patterns, and top 4 products performance table

[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;
    }
}
[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
$vbLabelText   $csharpLabel

Jak wygląda treść JavaScript w pliku PDF?

Company Analytics Dashboard PDF displaying key business metrics including $45,200 total revenue, monthly sales trends, website traffic patterns, and top-performing products table

Jak postępować z wykresami i wizualizacjami danych?

Teraz przekonwertujmy plik HTML zawierający wykresy:

Bar chart displaying monthly sales data from January to June, showing an overall upward trend with values ranging from $1,200 to $2,400, with June having the highest sales

[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;
        }
    }
[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
$vbLabelText   $csharpLabel

Jak wygląda wizualizacja wykresów w pliku PDF?

PDF viewer displaying a Monthly Sales Report with a blue bar chart showing sales data from January to June, with values ranging from approximately $1,200 to $2,400

IronPDF zachowuje oryginalną interaktywność JavaScript w końcowym pliku PDF.

Jak dodać nagłówki i stopki HTML?

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.

Jak utworzyć dynamiczne nagłówki i stopki?

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

            </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;
    }
}
[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>

            </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;
    }
}
Imports System
Imports System.Net
Imports System.Threading.Tasks
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http

<Function("ConvertWithHeaderFooter")>
Public Class ConvertWithHeaderFooterFunction
    Private ReadOnly _logger As ILogger

    Public Sub New(loggerFactory As ILoggerFactory)
        _logger = loggerFactory.CreateLogger(Of ConvertWithHeaderFooterFunction)()
    End Sub

    Public Async Function ConvertWithHeaderFooter(
        <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData,
        executionContext As FunctionContext) As Task(Of HttpResponseData)

        Try
            Dim mainContent As String = "
                <html>
                <body>
                    <h1>Annual Report 2024</h1>
                    <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit...</p>

                </body>
                </html>"
            Dim renderer As 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 With {
                .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 With {
                .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
            }
            Dim pdf = renderer.RenderHtmlAsPdf(mainContent)
            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, "Header/Footer conversion error")
            Throw
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

W jaki sposób nagłówki poprawiają jakość plików PDF?

Wizualne porównanie pokazujące różnicę między plikami PDF z nagłówkami (po lewej) a plikami bez nagłówków (po prawej), na przykładzie Raportu rocznego 2024

Jak zastosować niestandardowe nagłówki dla różnych zakresów stron?

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";
}
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 Class
$vbLabelText   $csharpLabel

Spowoduje to zastosowanie nagłówków do określonych zakresów stron pliku PDF.

Jakie są typowe zastosowania konwersji HTML do PDF w Azure?

Wszechstronność IronPDF sprawia, że nadaje się on do wielu zastosowań:

  • Generowanie faktur: Konwersja szablonów HTML z danymi dynamicznymi.
  • Generowanie raportów: przekształcanie wizualizacji w pliki PDF, które można udostępniać.
  • Tworzenie certyfikatów: Generuj spersonalizowane certyfikaty.
  • Eksport dokumentacji: Konwersja dokumentów online do plików PDF offline.
  • Archiwizacja wiadomości e-mail: zapisuj wiadomości e-mail w formacie HTML z zachowaniem formatowania.
  • Generowanie umów: Tworzenie dokumentów na podstawie szablonów HTML.
  • Materiały marketingowe: Konwersja projektów stron internetowych do plików PDF gotowych do druku.

Jak radzić sobie z typowymi problemami związanymi z platformą Azure?

Nawet przy prawidłowej konfiguracji mogą pojawić się problemy specyficzne dla platformy Azure. Oto typowe problemy i rozwiązania:

Dlaczego moje czcionki nie wyświetlają się poprawnie?

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>";
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>"
$vbLabelText   $csharpLabel

W przypadku utrzymujących się problemów z czcionkami zapoznaj się z przewodnikiem IronPDF dotyczącym rozwiązywania problemów z czcionkami.

Co powoduje błędy konfiguracji "Uruchom z pliku pakietu"?

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.

Jak radzić sobie z problemami związanymi z pamięcią i limitami czasu?

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
{
    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
}
$vbLabelText   $csharpLabel

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.

Jak zoptymalizować wydajność konwersji HTML do PDF?

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:

Kiedy należy stosować opóźnienia renderowania w przypadku treści dynamicznych?

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 JavaScript
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // Simple pages
renderer.RenderingOptions.WaitFor.RenderDelay = 2000; // Complex JavaScript
renderer.RenderingOptions.WaitFor.RenderDelay = 500 ' Simple pages
renderer.RenderingOptions.WaitFor.RenderDelay = 2000 ' Complex JavaScript
$vbLabelText   $csharpLabel

Jak efektywnie zarządzać pamięcią?

W 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;
    }
}
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 Using
$vbLabelText   $csharpLabel

Jakie strategie buforowania powinienem zastosować?

Buforuj 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;
}
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 Function
$vbLabelText   $csharpLabel

Ile kosztuje konwersja HTML do PDF w Azure?

Konwersja plików HTML do formatu PDF w platformie Azure wiąże się z dwoma składnikami kosztów:

Jakie są koszty hostingu w Azure?

  • Poziom podstawowy (B1): Poziom startowy dla renderowania plików PDF, odpowiedni dla niewielkich obciążeń
  • Poziom Standard (S1): Lepsza wydajność przy regularnym generowaniu plików PDF
  • Poziom Premium (P1V2): Zalecany do operacji na plikach PDF o dużej objętości lub złożonych

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.

Jakie są opcje licencyjne IronPDF?

IronPDF oferuje elastyczne opcje licencji wieczystych, od pojedynczego programisty po zespoły o nieograniczonej wielkości, a wszystkie poziomy obejmują wsparcie e-mail oraz 30-dniową gwarancję zwrotu pieniędzy

Licencjonowanie IronPDF

IronPDF oferuje kilka opcji licencyjnych:

  • Licencja Trial: Bezpłatna 30-dniowa licencja próbna do testowania
  • Lite License: jeden programista, jeden projekt
  • Plus License: Małe zespoły realizujące wiele projektów
  • Professional License: większe zespoły z prawami do redystrybucji
  • Unlimited License: wdrożenie w całej firmie

Odwiedź stronę licencyjną IronPDF, aby zapoznać się ze szczegółowymi cenami i porównaniem funkcji.

Jak mogę zoptymalizować koszty?

  1. Wprowadź buforowanie: Ogranicz generowanie zbędnych plików PDF
  2. Przetwarzanie wsadowe: przetwarzanie wielu plików PDF w ramach jednego wykonania funkcji
  3. Wykorzystaj przetwarzanie oparte na kolejkach: rozłóż obciążenie w czasie, aby uniknąć konieczności skalowania

O jakich kwestiach związanych z bezpieczeństwem należy pamiętać?

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 funkcji Azure Functions:

Jakie są kluczowe wskazówki dotyczące udanej konwersji HTML do PDF?

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:

  • Aby zapewnić niezawodne renderowanie plików PDF, należy korzystać z warstwy Azure B1 lub wyższej.
  • Wdroż jako kontener, aby uzyskać optymalną kompatybilność.
  • Skonfiguruj ustawienia IronPDF specjalnie dla środowiska Azure.
  • Wykorzystaj nagłówki i stopki HTML do tworzenia profesjonalnych dokumentów.
  • Obsługuj treści JavaScript z odpowiednimi opóźnieniami renderowania.
  • Wdrożenie buforowania i optymalizacji dla obciążeń produkcyjnych.

IronPDF oferuje więcej niż tylko prostą konwersję HTML do PDF. W tym artykule 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.

Gotowy, aby rozpocząć konwersję HTML do PDF w swoich aplikacjach Azure?

Rozpocznij używanie IronPDF w swoim projekcie już dziś dzięki darmowej wersji próbnej.

Pierwszy krok:
green arrow pointer

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.

Często Zadawane Pytania

Jaki jest cel konwersji HTML na PDF przy uzyciu Azure?

Konwersja HTML na PDF przy uzyciu Azure pozwala deweloperom niezawodnie generowac dokumenty w chmurze, co jest niezbedne dla aplikacji wymagajacych generowania i zarzadzania dokumentami.

Jak IronPDF ulepsza proces konwersji HTML na PDF na Azure?

IronPDF ulepsza proces konwersji, dostarczajac solidne funkcje zapewniajace wysokiej jakosci generowanie PDF, wlaczajac wsparcie dla zlozonych ukladow i stylow, co jest kluczowe dla profesjonalnego tworzenia dokumentow.

Czy mozna zautomatyzowac generowanie PDF przy uzyciu IronPDF na Azure?

Tak, IronPDF mozna zintegrowac z Azure, aby zautomatyzowac generowanie PDF, umozliwiajac bezproblemowe przeplywy dokumentow i redukujac reczna interwencje w srodowiskach chmurowych.

Jakie sa glownymi korzysciami korzystania z IronPDF na Azure dla deweloperow?

Glownymi korzysciami sa skalowalnosc, wysoka wydajnosc i zdolnosc do obslugi dynamicznej zawartosci HTML, co ulatwia deweloperom zarzadzanie duzymi zadaniami przetwarzania dokumentow.

Czy IronPDF moze radzic sobie ze zlozonymi ukladami HTML podczas procesu konwersji?

IronPDF jest zaprojektowany do obslugi zlozonych ukladow HTML, zapewniajac, ze wszystkie elementy sa dokladnie reprezentowane w wyjsciu PDF, co jest istotne dla zachowania integralnosci dokumentu.

Jakie sa wymagania wstepne do wdrozenia IronPDF na Azure?

Aby wdrozyc IronPDF na Azure, potrzebujesz aktywnego konta Azure, zrozumienia uslug Azure i dostepu do bibliotek IronPDF, aby zintegrowac z twoja aplikacja.

Jak IronPDF zapewnia bezpieczenstwo w generowaniu PDF z chmury?

IronPDF zapewnia bezpieczenstwo, oferujac szyfrowane polaczenia i bezpieczne praktyki obslugi danych, co jest kluczowe dla ochrony wrazliwych informacji podczas generowania PDF na Azure.

Czy mozliwe jest dostosowanie wyjscia PDF przy uzyciu IronPDF na Azure?

Tak, IronPDF oferuje rozlegle opcje dostosowywania wyjscia PDF, pozwalajac deweloperom dopasowywac wyglad i funkcjonalnosc dokumentow do konkretnych wymagan.

Czy IronPDF obsluguje konwersje dynamicznych stron na PDF na Azure?

IronPDF obsluguje konwersje dynamicznych stron webowych, wychwytujac dane w czasie rzeczywistym i zmiany zawartosci, co jest szczegolnie przydatne dla aplikacji, ktore musza generowac aktualne dokumenty.

Czy IronPDF jest zgodny z .NET 10 w konwersji HTML na PDF na Azure?

Tak — IronPDF jest w pelni zgodny z .NET 10, zapewniajac, ze wszystkie funkcje HTML-to-PDF dzialaja bezproblemowo na Azure i obsluguje .NET 10 obok .NET 9, 8, 7, 6, Core, Standard i Framework platform.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

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

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie