메시지 아이콘
푸터 콘텐츠로 바로가기
  1. IronPDF
  2. IronPDF 블로그
  3. IronPDF 사용하기
  4. Azure HTML to PDF
IRONPDF 사용하기

Azure와 IronPDF를 사용하여 HTML을 PDF로 변환하는 방법

커티스 차우
커티스 차우
업데이트됨:

Azure Functions에서 HTML을 PDF로 변환하려면 IronPDF의 Chrome 렌더링 엔진과 적절한 Azure 구성 (B1 티어 이상)이 필요합니다. 이를 통해 단순 문자열에서 JavaScript가 많은 페이지에 이르기까지 모든 HTML 콘텐츠를 픽셀 완벽한 PDF로 변환할 수 있으며 Azure의 샌드박스 제한 및 GDI+ 제약을 처리할 수 있습니다.

HTML에서 PDF로의 변환을 배울 가치가 있는 이유는 무엇입니까?

클라우드 환경에서 HTML 콘텐츠를 PDF 문서로 변환하는 것은 놀랍도록 도전적일 수 있습니다. 만약에 당신이 PDF 생성기를 Azure Functions에 배포하려고 시도해본 적이 있다면, GDI+ 또는 샌드박스 제한에 대한 의문의 오류에 부딪쳤을 가능성이 큽니다. 좋은 소식은? IronPDF와 적절한 설정을 통해 모든 HTML 콘텐츠를 픽셀 완벽한 PDF 파일로 변환할 수 있습니다.

이 튜토리얼은 IronPDF를 사용하여 Azure Functions에서 프로덕션 준비가 된 HTML에서 PDF로의 변환기를 배포하는 방법을 보여줍니다. 간단한 HTML 문자열에서 JavaScript가 많은 웹 페이지에 이르기까지 모든 것을 처리하는 방법을 배우면서 Azure의 고유한 환경 제한을 탐색할 수 있습니다. 단순한 인보이스부터 복잡한 보고서를 생성하든, 끝까지 IronPDF와 Azure를 사용하여 HTML에서 PDF로의 변환을 마스터할 것입니다.

지금 바로 IronPDF으로 시작하세요.
green arrow pointer

왜 Azure에서 HTML에서 PDF로의 변환이 도전적인가요?

PDF 변환에 뛰어들기 전에, 이 작업이 Azure에서 개발자에게 도전되는 이유를 이해해봅시다. Azure의 서버리스 및 앱 서비스는 PDF 라이브러리가 의존하는 작업을 제한하는 보안 샌드박스 내에서 실행됩니다:

  • 제한된 GDI+ 접근: 낮은 티어에서는 Windows 그래픽 호출이 차단됩니다.
  • 글꼴 렌더링 제한: 사용자 정의 글꼴 및 SVG 글꼴은 제한을 받습니다.
  • 메모리 제약: HTML에서 PDF로의 변환은 상당한 자원을 요구합니다.
  • 프로세스 격리: 브라우저 엔진 실행에는 특별한 권한이 필요합니다.

이런 제한은 Azure의 소비 요금제와 무료/공유 티어에서 가장 엄격합니다. 따라서 성공적인 HTML에서 PDF로의 변환은 최소한 Azure의 Basic B1 티어 또는 프리미엄 구독이 필요합니다. 필요한 권한 및 리소스를 제공하여 IronPDF의 Chrome 렌더링 엔진이 올바르게 작동하도록 합니다. IronPDF의 Azure 배포 가이드에서 Azure 호스팅 등급과 PDF 렌더링 성능에 대한 자세한 정보를 확인하십시오.

어떤 Azure 배포 옵션이 PDF 생성에 가장 적합합니까?

세 가지 배포 옵션이 있습니다 (Windows, Linux 또는 컨테이너). Azure Function App Container를 권장하지만, 모든 옵션이 잘 작동합니다.

오늘은 최소 구성을 통해 격리된 환경을 제공하고 IronPDF의 렌더링 엔진과의 호환성을 개선할 수 있는 컨테이너 접근법에 대해 알아보겠습니다. Azure Government Cloud 또는 Azure China와 같은 특수 환경에는 동일한 원칙이 적용되지만 배포 엔드포인트를 적절히 조정하십시오.

IronPDF가 Azure에서 HTML을 PDF로 변환하는 데 뛰어난 이유는 무엇입니까?

IronPDF는 Azure에서 HTML을 PDF로 변환하는 능력 덕분에 Chrome 렌더링 엔진으로 두각을 나타냅니다. 이것은 단순한 HTML 파서가 아니라 Google Chrome의 기술과 동일하여 현대적인 브라우저에서 PDF 문서가 정확히 동일하게 표시되도록 보장합니다.

Chrome 렌더링 엔진의 기능 중 무엇이 가장 중요합니까?

Chrome 엔진은 HTML을 PDF로 변환하는 데 중요한 이점을 제공합니다:

이는 Bootstrap 스타일, JavaScript 프레임워크 또는 복잡한 시각화가 포함된 최신 웹 페이지를 호환성 문제 없이 PDF로 변환할 수 있다는 것을 의미합니다. IronPDF는 Azure의 제한된 환경에서 무인 Chrome 인스턴스를 실행할 수 있습니다. IronPDF의 Chrome 렌더링 기능 및 픽셀 완벽한 PDF 렌더링에 대해 자세히 알아보십시오.

HTML을 PDF로 변환하기 위해 Microsoft Azure 환경을 어떻게 설정합니까?

IronPDF를 사용한 HTML에서 PDF로 변환을 최적화한 Azure Function App 설정 방법을 살펴보겠습니다.

시작하기 전에 어떤 준비사항이 필요합니까?

시작하기 전에 다음을 확인하십시오:

Azure Functions에서 PDF를 생성하는 구체적인 설정 방법은 IronPDF의 Azure Functions 튜토리얼을 참조하십시오.

Azure Function App을 어떻게 만듭니까?

  1. Azure Portal로 이동하여 '리소스 생성'을 클릭합니다.
  2. 'Function App'을 검색하고 '생성'을 클릭합니다.

  3. 기본 사항을 구성합니다:

    1. 호스팅 옵션 선택: 필요에 맞는 옵션 선택
    2. 구독: Azure 구독 선택
    3. 리소스 그룹: 새로 생성하거나 기존 선택
    4. Function App 이름: 고유한 이름 선택
    5. 배포: '컨테이너' 선택
    6. 지역: 선호하는 지역 선택

  4. 호스팅 계획을 구성합니다:

    1. Azure App Service Plan에서 '새로 만들기' 클릭
    2. 가격 등급: 최소 B1(기본) 이상 선택
  5. 무료, 공유, 소비 계획은 PDF 렌더링에 작동하지 않음을 기억하십시오.
  6. Function App을 검토하고 생성하세요.

프로젝트에 IronPDF를 어떻게 설치하나요?

먼저 Visual Studio에서 새 Azure Functions 프로젝트를 생성하거나 기존 프로젝트를 로드하고 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

상세 설치 지침, NuGet 패키지 구성 및 플랫폼별 고려사항에 대해, IronPDF 설치 가이드를 방문하십시오.

Azure를 위한 필수 구성 설정은 무엇입니까?

최적의 HTML에서 PDF로 변환을 위해 Function App .cs 파일을 구성하십시오.

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

HTML 문자열을 PDF로 변환하는 방법은?

HTML 문자열을 PDF로 직접 변환하는 가장 일반적인 시나리오로 시작합니다. 이 접근 방식은 청구서, 보고서 또는 확인 이메일과 같은 동적으로 생성된 콘텐츠에 잘 작동합니다.

기본 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

이 HTML 문자열을 받아 고품질의 PDF 문서로 렌더링하며, 해당 문서에는 RenderingOptions 클래스에 의해 구성된 맞춤형 렌더링 옵션이 포함됩니다.

PDF 출력은 어떻게 보이나요?

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

URL을 PDF로 어떻게 변환하나요?

기존 웹페이지나 복잡한 애플리케이션에 대해 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

URL 변환 출력은 어떻게 보이나요?

Apple의 웹사이트 홈페이지 스플릿 스크린 뷰로 왼쪽에는 iPhone 16 제품군이, 오른쪽에는 교환 및 Apple Card 프로모션이 포함된 Apple Watch Series 10이 표시됨

JavaScript로 복잡한 HTML 콘텐츠를 어떻게 처리하나요?

현대 웹 애플리케이션은 콘텐츠 렌더링을 위해 JavaScript에 크게 의존합니다. 차트, 동적 폼, 단일 페이지 애플리케이션이든, IronPDF의 렌더링 엔진이 모두 처리합니다.

JavaScript가 많은 콘텐츠를 어떻게 작업하나요?

이 예에서는 JavaScript 콘텐츠가 포함된 HTML 파일을 가져와 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

JavaScript 콘텐츠가 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

차트와 데이터 시각화는 어떻게 처리하나요?

이제 차트가 포함된 HTML 파일을 변환해 보겠습니다:

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

차트 시각화가 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는 최종 PDF 출력에서 원래 JavaScript 상호작용을 유지합니다.

HTML 헤더와 푸터를 어떻게 추가하나요?

전문적인 PDF는 모든 페이지에 걸쳐 일관된 헤더와 푸터가 필요합니다. IronPDF는 고급 헤더 및 푸터 옵션을 위한 HTML 기반 템플릿으로 이를 간단하게 만듭니다.

동적 헤더와 푸터를 어떻게 만드나요?

[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

헤더는 PDF 출력에 어떻게 기여하나요?

Annual Report 2024의 예를 사용하여 머리글이 있는 PDF(왼쪽)와 없는 PDF(오른쪽) 간의 차이를 시각적으로 비교

다른 페이지 범위에 사용자 정의 헤더는 어떻게 적용하나요?

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

이는 지정된 PDF 페이지 범위에 헤더를 적용합니다.

Azure에서 일반적인 HTML을 PDF로 변환하는 사용 사례는 무엇인가요?

IronPDF의 다재다능함은 많은 사용 사례에 적합합니다:

  • 인보이스 생성: 동적 데이터로 HTML 템플릿 변환.
  • 보고서 생성: 시각화를 공유 가능한 PDF로 변환.
  • 인증서 생성: 개인화된 인증서 생성.
  • 문서 내보내기: 온라인 문서를 오프라인 PDF로 변환.
  • 이메일 보관: HTML 이메일을 서식 그대로 저장.
  • 계약서 생성: HTML 템플릿에서 문서 생성.
  • 마케팅 자료: 웹 디자인을 인쇄 준비된 PDF로 변환.

Azure 특정 문제를 어떻게 처리하나요?

적절한 구성이 있어도 Azure 특정 문제에 직면할 수 있습니다. 여기 일반적인 문제와 해결책이 있습니다:

왜 내 글꼴이 올바르게 렌더링되지 않나요?

문제: 사용자 정의 글꼴이 올바르게 표시되지 않거나 시스템 글꼴로 대체됩니다.

해결책: Azure의 공유 호스팅 계층은 사용자 정의 글꼴에 필요한 GDI+ 접근을 제한합니다. 적어도 B1 계층을 사용하고 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

지속적인 글꼴 문제에 대해서는 IronPDF의 글꼴 문제 해결 가이드를 참조하십시오.

"Run from Package file" 구성 오류의 원인은 무엇인가요?

문제: "Run from package file" 설정이 활성화된 경우 IronPDF는 종속성을 로드하지 못합니다.

해결책: 이 옵션은 IronPDF가 필요한 파일을 추출하지 못하게 하는 읽기 전용 환경을 생성합니다. 이 옵션을 게시 설정에서 비활성화하거나 이 시나리오를 더 잘 처리하는 IronPdf.Slim 패키지를 사용하십시오.

메모리 및 시간 초과 문제를 어떻게 처리합니까?

문제: 대용량 HTML 문서가 시간 초과 또는 메모리 예외를 발생시킵니다.

해결책: 적절한 시간 초과 및 메모리 설정을 구성합니다:

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

Azure Functions의 시간 초과 구성에 대해서는 Microsoft의 시간 초과 문서를 참조하십시오. 대용량 문서 처리에 대한 솔루션은 Stack Overflow의 Azure Functions 태그에서도 공유됩니다.

Azure에서 특정 HTML-to-PDF 변환 문제 해결 시나리오에 대해서는 IronPDF의 Azure 문제 해결 문서를 방문하십시오.

HTML을 PDF로 변환할 때 성능을 어떻게 최적화합니까?

HTML을 PDF로 변환하는 것은 콘텐츠 복잡성에 따라 리소스를 많이 사용할 수 있습니다. 다음은 Azure Functions에 대한 주요 최적화 전략입니다:

동적 콘텐츠에 대한 렌더링 지연은 언제 사용해야 합니까?

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

메모리를 효율적으로 관리하는 방법은 무엇입니까?

대량 시나리오의 경우 리소스를 적절히 처리합니다:

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

어떤 캐싱 전략을 사용해야 합니까?

자주 변하지 않는 콘텐츠에 대해 생성된 PDF를 캐시합니다:

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

Azure에서 HTML을 PDF로 변환하는 비용은 얼마입니까?

Azure에서 HTML을 PDF로 변환하는 것은 두 가지 비용 구성 요소를 포함합니다:

Azure 호스팅 비용은 얼마입니까?

  • 기본 (B1) 티어: PDF 렌더링에 시작 티어로 경량 작업 부하에 적합합니다
  • 표준 (S1) 티어: 일반적인 PDF 생성에 대한 더 나은 성능
  • 프리미엄 (P1V2) 티어: 대량 또는 복잡한 PDF 작업에 권장됩니다

요금은 지역에 따라 다르며 시간이 지남에 따라 변경됩니다. 필요에 가장 적합한 티어 선택을 위한 IronPDF 가이드를 참조하십시오.

IronPDF 라이선싱 옵션은 무엇입니까?

IronPDF는 단일 개발자부터 무제한 팀 규모까지 유연한 영구 라이선스 옵션을 제공하며, 모든 티어에 이메일 지원과 30일 환불 보장이 포함됨

IronPDF 라이선싱

IronPDF는 여러 라이선싱 옵션을 제공합니다:

  • 체험판 라이선스: 테스트를 위한 30일 무료 체험판
  • Lite 라이선스: 단일 개발자, 단일 프로젝트
  • Plus 라이선스: 여러 프로젝트를 가진 작은 팀
  • Professional 라이선스: 재배포 권한이 있는 큰 팀
  • 무제한 라이선스: 전사적 배포

자세한 가격 책정 및 기능 비교는 IronPDF의 라이선싱 페이지를 방문하십시오.

비용을 최적화하는 방법은 무엇입니까?

  1. 캐싱 구현: 중복된 PDF 생성을 줄입니다
  2. 배치 처리: 단일 기능 실행에서 여러 PDF를 처리합니다
  3. 큐 기반 처리 사용: 확장 요구를 피하기 위해 부하를 시간에 따라 분산합니다

유념해야 할 보안 고려 사항은 무엇입니까?

우리는 HTML을 PDF로 변환하는 것에 중점을 두었지만, 민감한 PDF 파일을 처리할 때 보안이 중요합니다. 원치 않는 손상으로부터 PDF 내용을 안전하게 유지하려면 Azure Functions를 보안하는 방법에 대해 자세히 알아보십시오:

성공적인 HTML to PDF 변환을 위한 핵심 요점은 무엇입니까?

Azure에서 HTML을 PDF로 변환하는 것은 복잡할 필요가 없습니다. IronPDF의 Chrome 렌더링 엔진 및 적절한 Azure 구성을 통해, 모든 HTML 콘텐츠를 전문적인 PDF로 변환할 수 있습니다.

Azure에서 성공적인 HTML to PDF 변환을 위한 핵심 요점:

  • 신뢰할 수 있는 PDF 렌더링을 위해 Azure B1 이상 티어를 사용하십시오.
  • 최적의 호환성을 위해 컨테이너로 배포하십시오.
  • Azure 환경에 맞춰 IronPDF 설정을 구성하십시오.
  • 전문 문서를 위해 HTML 헤더와 푸터를 활용하십시오.
  • JavaScript 콘텐츠를 적절한 렌더링 지연과 함께 처리합니다.
  • 프로덕션 작업 부하에 대해 캐싱 및 최적화를 구현하십시오.

IronPDF는 간단한 HTML-to-PDF 변환 이상을 제공합니다. 이 기사에서는 고급 PDF 조작 및 PDF 이미지 지원에 대한 기능을 설명했습니다. IronPDF는 당신이 개발 중인 완전히 모든 애플리케이션에 쉽게 통합되며, Console Apps 및 .NET Core 애플리케이션을 포함합니다.

Azure 애플리케이션에서 HTML을 PDF로 변환할 준비가 되셨습니까?

!{--010011000100100101000010010100100100000101010010010110010101111101010011010101000100000101010010101000101111101010001010010010010010100000101001100010111110100001001001001100010011110100001101001011--}

IronPDF 무료 체험판을 사용하여 강력한 기능에 액세스하고 오늘 Azure 애플리케이션에서 HTML을 PDF로 변환하기 시작하세요!

프로덕션 배포를 위해 IronPDF의 라이선스 옵션을 탐색하여 자신에게 적합한 계획을 찾으세요. 포괄적인 문서, 반응이 빠른 지원, 지속적인 업데이트와 함께, IronPDF는 Azure Functions 및 그 밖의 영역에서 신뢰할 수 있는 HTML to PDF 변환을 위한 모든 것을 제공합니다.

자주 묻는 질문

Azure를 사용하여 HTML을 PDF로 변환하는 목적은 무엇입니까?

Azure를 사용하여 HTML을 PDF로 변환하면 개발자가 클라우드 기반 문서를 신뢰성 있게 생성할 수 있으며, 문서 생성 및 관리가 필요한 애플리케이션에 필수적입니다.

IronPDF는 Azure에서 HTML을 PDF로 변환하는 과정을 어떻게 향상시킵니까?

IronPDF는 복잡한 레이아웃 및 스타일 지원을 포함하여 고품질 PDF 생성을 보장하는 강력한 기능을 제공하여 변환 프로세스를 향상시킵니다. 이는 전문적인 문서 생성에 필수적입니다.

IronPDF를 사용하여 Azure에서 PDF 생성을 자동화할 수 있습니까?

예, IronPDF는 Azure와 통합되어 PDF 생성을 자동화할 수 있으며, 이는 클라우드 환경에서 수동 개입을 줄이고 문서 워크플로를 원활하게 만들어줍니다.

개발자가 Azure에서 IronPDF를 사용하는 주요 이점은 무엇입니까?

주요 이점은 확장성, 고성능, 동적 HTML 콘텐츠를 처리할 수 있는 기능으로, 개발자가 대량의 문서 처리 작업을 관리하기 쉽게 해줍니다.

IronPDF는 변환 과정에서 복잡한 HTML 레이아웃을 처리할 수 있습니까?

IronPDF는 모든 요소가 PDF 출력에 정확히 표현되도록 복잡한 HTML 레이아웃을 처리하도록 설계되었습니다. 이는 문서의 무결성을 유지하는 데 필수적입니다.

Azure에 IronPDF를 배포하기 위한 필수 조건은 무엇입니까?

Azure에 IronPDF를 배포하려면 활성화된 Azure 계정, Azure 서비스에 대한 이해, 애플리케이션과의 통합을 위한 IronPDF 라이브러리에 대한 액세스가 필요합니다.

IronPDF는 클라우드 기반 PDF 생성에서 어떻게 보안을 보장합니까?

IronPDF는 암호화된 연결과 보안 데이터 처리 방식으로 보안을 보장하며, 이는 Azure에서 PDF 생성 중 민감한 정보를 보호하는 데 필수적입니다.

Azure에서 IronPDF를 사용할 때 PDF 출력을 사용자 정의할 수 있습니까?

예, IronPDF는 PDF 출력에 대한 광범위한 사용자 정의 옵션을 제공하여 개발자가 문서의 외관과 기능을 특정 요구 사항에 맞게 조정할 수 있습니다.

IronPDF는 Azure에서 동적 웹 페이지를 PDF로 변환하는 것을 지원합니까?

IronPDF는 실시간 데이터 및 콘텐츠 변경 사항을 캡처하여 특히 최신 문서를 생성해야 하는 애플리케이션에 유용한 동적 웹 페이지 변환을 지원합니다.

IronPDF는 Azure에서 HTML을 PDF로 변환할 때 .NET 10과 호환됩니까?

예 — IronPDF는 .NET 10과 완전히 호환되어 Azure에서 모든 HTML-to-PDF 기능이 원활하게 작동하며, .NET 9, 8, 7, 6, Core, Standard 및 Framework 플랫폼도 지원합니다.

커티스 차우
커티스 차우
  지금 바로 엔지니어링 팀과 채팅하세요
기술 문서 작성자

커티스 차우는 칼턴 대학교에서 컴퓨터 과학 학사 학위를 취득했으며, Node.js, TypeScript, JavaScript, React를 전문으로 하는 프론트엔드 개발자입니다. 직관적이고 미적으로 뛰어난 사용자 인터페이스를 만드는 데 열정을 가진 그는 최신 프레임워크를 활용하고, 잘 구성되고 시각적으로 매력적인 매뉴얼을 제작하는 것을 즐깁니다.

커티스는 개발 분야 외에도 사물 인터넷(IoT)에 깊은 관심을 가지고 있으며, 하드웨어와 소프트웨어를 통합하는 혁신적인 방법을 연구합니다. 여가 시간에는 게임을 즐기거나 디스코드 봇을 만들면서 기술에 대한 애정과 창의성을 결합합니다.

관련 기사

30일 무료 체험 → 모든 기능 이용 가능. 제한 없음. 카드 정보 필요 없음. 무료 체험 시작하기

아이언 서포트 팀

저희는 주 5일, 24시간 온라인으로 운영합니다.
채팅
이메일
전화해