如何用 C# 将 HTML 转换为 PDF（开发人员指南）

using IronPDF;

// Create the Chrome renderer
var renderer = new ChromePdfRenderer();

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the PDF
pdf.SaveAs("output.pdf");

Imports IronPDF

' Create the Chrome renderer
Dim renderer As New ChromePdfRenderer()

' Convert HTML string to PDF
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>")

' Save the PDF
pdf.SaveAs("output.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Convert HTML content with local image and CSS references
string html = @"
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>";

// Set base path for resolving relative URLs in HTML to PDF conversion
var pdf = renderer.RenderHtmlAsPdf(html, @"C:\MyProject\Assets\");
pdf.SaveAs("report.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Convert HTML content with local image and CSS references
Dim html As String = "
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>"

' Set base path for resolving relative URLs in HTML to PDF conversion
Dim pdf = renderer.RenderHtmlAsPdf(html, "C:\MyProject\Assets\")
pdf.SaveAs("report.pdf")

using IronPDF;
using IronPdf.Rendering;

// Initialize HTML to PDF converter
var renderer = new ChromePdfRenderer();

// Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Screen media type shows the entire web page as displayed on screen

Imports IronPDF
Imports IronPdf.Rendering

' Initialize HTML to PDF converter
Dim renderer As New ChromePdfRenderer()

' Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Screen media type shows the entire web page as displayed on screen

using IronPDF;

// Configure JavaScript rendering for dynamic HTML content to PDF
var renderer = new ChromePdfRenderer();

// Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = true;

// WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // milliseconds

Imports IronPDF

' Configure JavaScript rendering for dynamic HTML content to PDF
Dim renderer As New ChromePdfRenderer()

' Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = True

' WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500 ' milliseconds

using IronPDF;

// Create renderer for JavaScript-heavy HTML
var renderer = new ChromePdfRenderer();

// Convert d3.js visualization web page to PDF
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf");

Imports IronPDF

' Create renderer for JavaScript-heavy HTML
Dim renderer As New ChromePdfRenderer()

' Convert d3.js visualization web page to PDF
Dim pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006")

' Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf")

// Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

```vbnet
' Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
```

using IronPDF;

// Initialize ChromePdfRenderer for HTML file conversion
var renderer = new ChromePdfRenderer();

// Convert HTML file to PDF documents
// Preserves all relative paths and linked resources in HTML
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf");

// All CSS, JavaScript, and images load correctly in the generated PDF

Imports IronPDF

' Initialize ChromePdfRenderer for HTML file conversion
Dim renderer As New ChromePdfRenderer()

' Convert HTML file to PDF documents
' Preserves all relative paths and linked resources in HTML
Dim pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html")

' Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf")

' All CSS, JavaScript, and images load correctly in the generated PDF

PM > Install-Package IronPdf.Extensions.Razor

using IronPDF;

var renderer = new ChromePdfRenderer();

// Render a Razor Page directly to PDF
PdfDocument pdf = renderer.RenderRazorToPdf(this);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Render a Razor Page directly to PDF
Dim pdf As PdfDocument = renderer.RenderRazorToPdf(Me)

Response.Headers.Add("Content-Disposition", "inline")
Return New FileContentResult(pdf.BinaryData, "application/pdf")

PM > Install-Package IronPdf.Extensions.Mvc.Core

using IronPdf.Extensions.Mvc.Core;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

Imports IronPdf.Extensions.Mvc.Core

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()

' Register the Razor view renderer for IronPDF
builder.Services.AddSingleton(Of IHttpContextAccessor, HttpContextAccessor)()
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()

using IronPDF;
using IronPdf.Extensions.Mvc.Core;

var renderer = new ChromePdfRenderer();

// Render an MVC View with model data to PDF
PdfDocument pdf = renderer.RenderRazorViewToPdf(
    _viewRenderService, "Views/Home/Report.cshtml", reportModel);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

Imports IronPDF
Imports IronPdf.Extensions.Mvc.Core

Dim renderer As New ChromePdfRenderer()

' Render an MVC View with model data to PDF
Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Report.cshtml", reportModel)

Response.Headers.Add("Content-Disposition", "inline")
Return New FileContentResult(pdf.BinaryData, "application/pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword"
}

' Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123"

' Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/quarterly-report")
pdf.SaveAs("quarterly-report.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter — not a render option
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.corp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Proxy is the third parameter — not a render option
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath:=Nothing,
    proxy:="http://proxy.corp.local:8080"
)
pdf.SaveAs("proxied-report.pdf")

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

' Simple HTML templating with String.Format
Dim htmlTemplate As String = String.Format("<h1>Hello {0}!</h1>", "World")

' Results in HTML content: <h1>Hello World!</h1>

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

' Define reusable HTML template for PDF files
Dim htmlTemplate As String = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>"

' Customer names for batch PDF conversion processing
Dim names As String() = {"John", "James", "Jenny"}

' Create personalized PDF documents for each customer
Dim renderer As New ChromePdfRenderer()

For Each name In names
    ' Replace placeholder with actual data in HTML string
    Dim htmlInstance As String = htmlTemplate.Replace("[[NAME]]", name)

    ' Generate personalized PDF document from HTML content
    Dim pdf = renderer.RenderHtmlAsPdf(htmlInstance)

    ' Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf")
Next

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Package Handlebars.NET

using HandlebarsDotNet;
using IronPDF;

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Compile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

Imports HandlebarsDotNet
Imports IronPDF

' Define Handlebars template with placeholders for HTML content
Dim source As String = 
    "<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>"

' Compile template for reuse in PDF conversion
Dim template = Handlebars.Compile(source)

' Create data object (can be database records) for HTML to PDF directly
Dim data = New With { 
    .title = "Monthly Report", 
    .body = "Sales increased by 15% this month." 
}

' Merge template with data to create HTML content
Dim htmlResult = template(data)

' Convert templated HTML to PDF using the PDF converter
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlResult)

pdf.SaveAs("monthly-report.pdf")

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

using IronPDF;
using System.Threading.Tasks;

// Async method for non-blocking PDF generation from HTML content
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();

    // Async HTML to PDF conversion preserves thread pool
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    // Return PDF files as byte array for web responses
    return pdf.BinaryData;
}

// Concurrent batch PDF generation for multiple HTML strings
public async Task GenerateMultiplePdfsAsync(List<string> html模板)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = html模板.Select(html => 
        renderer.RenderHtmlAsPdfAsync(html)
    );

    // Await all PDF conversions simultaneously
    var pdfs = await Task.WhenAll(tasks);

    // Save generated PDF files from HTML content
    for (int i = 0; i < pdfs.Length; i++)
    {
        pdfs[i].SaveAs($"document-{i}.pdf");
    }
}

Imports IronPDF
Imports System.Threading.Tasks

' Async method for non-blocking PDF generation from HTML content
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()

    ' Async HTML to PDF conversion preserves thread pool
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

    ' Return PDF files as byte array for web responses
    Return pdf.BinaryData
End Function

' Concurrent batch PDF generation for multiple HTML strings
Public Async Function GenerateMultiplePdfsAsync(html模板 As List(Of String)) As Task
    Dim renderer As New ChromePdfRenderer()

    ' Create parallel conversion tasks to generate PDF documents
    Dim tasks = html模板.Select(Function(html) renderer.RenderHtmlAsPdfAsync(html))

    ' Await all PDF conversions simultaneously
    Dim pdfs = Await Task.WhenAll(tasks)

    ' Save generated PDF files from HTML content
    For i As Integer = 0 To pdfs.Length - 1
        pdfs(i).SaveAs($"document-{i}.pdf")
    Next
End Function

using IronPDF;
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Convert HTML to PDF with security
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>")

' Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123"     ' Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456"   ' Password to modify PDF files

' Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint

' Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256
pdf.SaveAs("secure-document.pdf")

using IronPDF;
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval",
    SignerName = "Authorized Signer"  // New property in v2025.8.8 for enhanced signature details
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

Imports IronPDF
Imports IronPdf.Signing

Dim renderer As New ChromePdfRenderer()

' Generate PDF from HTML page
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>")

' Create digital signature with certificate for PDF files
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "legal@company.com",
    .SigningLocation = "New York, NY",
    .SigningReason = "Contract Approval",
    .SignerName = "Authorized Signer"  ' New property in v2025.8.8 for enhanced signature details
}

' Apply signature to PDF documents
pdf.Sign(signature)
pdf.SaveAs("signed-contract.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

Imports IronPDF

Dim renderer = New ChromePdfRenderer()

' Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

Dim htmlForm As String = "
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>"

Dim pdf = renderer.RenderHtmlAsPdf(htmlForm)
pdf.SaveAs("onboarding-form.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.JavaScript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

Imports IronPDF

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True

' Replace the body with only the target element
renderer.RenderingOptions.JavaScript = "
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
"

' Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000)

Dim pdf = renderer.RenderHtmlAsPdf(fullPageHtml)
pdf.SaveAs("invoice-summary.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports");
pdf.SaveAs("authenticated-report.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Configure network authentication
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword",
    .AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
}

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports")
pdf.SaveAs("authenticated-report.pdf")

using IronPDF;

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Add session cookies
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123token"
renderer.RenderingOptions.CustomCookies("authToken") = "bearer-xyz"

' Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard")
pdf.SaveAs("dashboard.pdf")

using IronPDF;

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependencies自动配置 = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

Imports IronPDF

' Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
' Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>")
pdf.SaveAs("azure-report.pdf")

using Amazon.Lambda.Core;
using IronPDF;

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependencies自动配置 = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

Imports Amazon.Lambda.Core
Imports IronPDF

Public Class PdfFunction
    Public Function FunctionHandler(input As String, context As ILambdaContext) As String
        ' Lambda's only writable directory
        Dim tmpPath As String = "/tmp/"

        IronPdf.Installation.TempFolderPath = tmpPath
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
        ' Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependencies自动配置 = True

        context.Logger.LogLine("Rendering PDF...")

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(input)

        ' Save to /tmp before uploading to S3 or returning
        Dim outputPath As String = $"{tmpPath}output.pdf"
        pdf.SaveAs(outputPath)

        Return outputPath
    End Function
End Class

using IronPDF;

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependencies自动配置 = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

Imports IronPDF

' Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = False
' No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>")
pdf.SaveAs("output.pdf")