Criando um gerador de PDF do Azure com IronPDF (Guia .NET 10)

# NuGet Package Manager (Windows / Serviço de aplicativo)
Install-Package IronPdf

# .NET CLI (cross-platform)
dotnet add package IronPdf

# Linux / container deployments
Install-Package IronPdf.Linux

# .NET CLI alternative
dotnet add package IronPdf.Linux

using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;

// Configure IronPDF once at startup
License.LicenseKey = Environment.GetEnvironmentVariable("IronPdfLicenseKey") ?? string.Empty;
Installation.LinuxAndDockerDependenciesAutoConfig = true;
Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
Installation.CustomDeploymentDirectory = "/tmp";

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .Build();

host.Run();

// Azure Function class
public class PdfGeneratorFunction
{
    private readonly ILogger _logger;

    public PdfGeneratorFunction(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<PdfGeneratorFunction>();
    }

    [Function("GeneratePdf")]
    public async Task<HttpResponseData> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "generate-pdf")] HttpRequestData req)
    {
        string htmlContent = await req.ReadAsStringAsync() ?? string.Empty;
        var response = req.CreateResponse(HttpStatusCode.OK);

        if (string.IsNullOrWhiteSpace(htmlContent))
        {
            response.StatusCode = HttpStatusCode.BadRequest;
            await response.WriteStringAsync("HTML content is required.");
            return response;
        }

        try
        {
            var renderer = new ChromePdfRenderer
            {
                RenderingOptions = new ChromePdfRenderOptions
                {
                    MarginTop = 10,
                    MarginBottom = 10,
                    MarginLeft = 10,
                    MarginRight = 10,
                    EnableJavaScript = true
                }
            };

            using var pdf = renderer.RenderHtmlAsPdf(htmlContent);
            response.Headers.Add("Content-Type", "application/pdf");
            await response.WriteBytesAsync(pdf.BinaryData);
            _logger.LogInformation("Generated PDF with {PageCount} pages.", pdf.PageCount);
            return response;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating PDF.");
            response.StatusCode = HttpStatusCode.InternalServerError;
            await response.WriteStringAsync($"PDF generation failed: {ex.Message}");
            return response;
        }
    }
}

Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports Microsoft.Extensions.Logging
Imports System.Net

' Configure IronPDF once at startup
License.LicenseKey = If(Environment.GetEnvironmentVariable("IronPdfLicenseKey"), String.Empty)
Installation.LinuxAndDockerDependenciesAutoConfig = True
Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
Installation.CustomDeploymentDirectory = "/tmp"

Dim host = New HostBuilder() _
    .ConfigureFunctionsWorkerDefaults() _
    .Build()

host.Run()

' Azure Function class
Public Class PdfGeneratorFunction
    Private ReadOnly _logger As ILogger

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

    <Function("GeneratePdf")>
    Public Async Function Run(
        <HttpTrigger(AuthorizationLevel.Function, "post", Route:="generate-pdf")> req As HttpRequestData) As Task(Of HttpResponseData)

        Dim htmlContent As String = Await req.ReadAsStringAsync() OrElse String.Empty
        Dim response = req.CreateResponse(HttpStatusCode.OK)

        If String.IsNullOrWhiteSpace(htmlContent) Then
            response.StatusCode = HttpStatusCode.BadRequest
            Await response.WriteStringAsync("HTML content is required.")
            Return response
        End If

        Try
            Dim renderer = New ChromePdfRenderer With {
                .RenderingOptions = New ChromePdfRenderOptions With {
                    .MarginTop = 10,
                    .MarginBottom = 10,
                    .MarginLeft = 10,
                    .MarginRight = 10,
                    .EnableJavaScript = True
                }
            }

            Using pdf = renderer.RenderHtmlAsPdf(htmlContent)
                response.Headers.Add("Content-Type", "application/pdf")
                Await response.WriteBytesAsync(pdf.BinaryData)
                _logger.LogInformation("Generated PDF with {PageCount} pages.", pdf.PageCount)
                Return response
            End Using
        Catch ex As Exception
            _logger.LogError(ex, "Error generating PDF.")
            response.StatusCode = HttpStatusCode.InternalServerError
            Await response.WriteStringAsync($"PDF generation failed: {ex.Message}")
            Return response
        End Try
    End Function
End Class

using IronPdf;
using IronPdf.Editing;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;
using System.Text.Json;

public class PdfApiFunction
{
    private static readonly ChromePdfRenderer Renderer = new ChromePdfRenderer
    {
        RenderingOptions = new ChromePdfRenderOptions
        {
            PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
            PrintHtmlBackgrounds = true,
            CreatePdfFormsFromHtml = true,
            CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
        }
    };

    [Function("ConvertUrlToPdf")]
    public async Task<HttpResponseData> ConvertUrl(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        var body = await req.ReadAsStringAsync() ?? "{}";
        var request = JsonSerializer.Deserialize<ConvertUrlRequest>(body);

        if (string.IsNullOrEmpty(request?.Url))
        {
            var bad = req.CreateResponse(HttpStatusCode.BadRequest);
            await bad.WriteStringAsync("URL is required.");
            return bad;
        }

        using var pdf = Renderer.RenderUrlAsPdf(request.Url);

        if (request.AddWatermark)
        {
            pdf.ApplyWatermark(
                "<h2>CONFIDENTIAL</h2>",
                30,
                VerticalAlignment.Middle,
                HorizontalAlignment.Center);
        }

        if (request.ProtectWithPassword && !string.IsNullOrEmpty(request.Password))
        {
            pdf.SecuritySettings.UserPassword = request.Password;
            pdf.SecuritySettings.AllowUserCopyPasteContent = false;
        }

        var response = req.CreateResponse(HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "application/pdf");
        await response.WriteBytesAsync(pdf.BinaryData);
        return response;
    }
}

public class ConvertUrlRequest
{
    public string Url { get; set; } = string.Empty;
    public bool AddWatermark { get; set; }
    public bool ProtectWithPassword { get; set; }
    public string Password { get; set; } = string.Empty;
}

Imports IronPdf
Imports IronPdf.Editing
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Imports System.Net
Imports System.Text.Json

Public Class PdfApiFunction
    Private Shared ReadOnly Renderer As New ChromePdfRenderer With {
        .RenderingOptions = New ChromePdfRenderOptions With {
            .PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
            .PrintHtmlBackgrounds = True,
            .CreatePdfFormsFromHtml = True,
            .CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
        }
    }

    <Function("ConvertUrlToPdf")>
    Public Async Function ConvertUrl(
        <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData) As Task(Of HttpResponseData)

        Dim body As String = Await req.ReadAsStringAsync() ?? "{}"
        Dim request As ConvertUrlRequest = JsonSerializer.Deserialize(Of ConvertUrlRequest)(body)

        If String.IsNullOrEmpty(request?.Url) Then
            Dim bad As HttpResponseData = req.CreateResponse(HttpStatusCode.BadRequest)
            Await bad.WriteStringAsync("URL is required.")
            Return bad
        End If

        Using pdf = Renderer.RenderUrlAsPdf(request.Url)
            If request.AddWatermark Then
                pdf.ApplyWatermark(
                    "<h2>CONFIDENTIAL</h2>",
                    30,
                    VerticalAlignment.Middle,
                    HorizontalAlignment.Center)
            End If

            If request.ProtectWithPassword AndAlso Not String.IsNullOrEmpty(request.Password) Then
                pdf.SecuritySettings.UserPassword = request.Password
                pdf.SecuritySettings.AllowUserCopyPasteContent = False
            End If

            Dim response As HttpResponseData = req.CreateResponse(HttpStatusCode.OK)
            response.Headers.Add("Content-Type", "application/pdf")
            Await response.WriteBytesAsync(pdf.BinaryData)
            Return response
        End Using
    End Function
End Class

Public Class ConvertUrlRequest
    Public Property Url As String = String.Empty
    Public Property AddWatermark As Boolean
    Public Property ProtectWithPassword As Boolean
    Public Property Password As String = String.Empty
End Class

using IronPdf;
using Microsoft.Extensions.Logging;

public static class PdfProductionService
{
    // Limit concurrent PDF operations to avoid memory exhaustion
    private static readonly SemaphoreSlim Throttle = new SemaphoreSlim(5);

    public static async Task<byte[]> GeneratePdfAsync(string html, ILogger log)
    {
        await Throttle.WaitAsync();
        try
        {
            using var renderer = new ChromePdfRenderer
            {
                RenderingOptions = new ChromePdfRenderOptions
                {
                    Timeout = 60,
                    UseMarginsOnHeaderAndFooter = UseMargins.Nãone
                }
            };

            renderer.RenderingOptions.WaitFor.RenderDelay(1000);
            using var pdf = renderer.RenderHtmlAsPdf(html);

            log.LogInformation(
                "PDF generated: {Pages} pages, {Bytes} bytes",
                pdf.PageCount,
                pdf.BinaryData.Length);

            return pdf.BinaryData;
        }
        finally
        {
            Throttle.Release();
        }
    }
}

Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System.Threading

Public Module PdfProductionService
    ' Limit concurrent PDF operations to avoid memory exhaustion
    Private ReadOnly Throttle As New SemaphoreSlim(5)

    Public Async Function GeneratePdfAsync(html As String, log As ILogger) As Task(Of Byte())
        Await Throttle.WaitAsync()
        Try
            Using renderer As New ChromePdfRenderer()
                renderer.RenderingOptions = New ChromePdfRenderOptions() With {
                    .Timeout = 60,
                    .UseMarginsOnHeaderAndFooter = UseMargins.None
                }

                renderer.RenderingOptions.WaitFor.RenderDelay(1000)
                Using pdf = renderer.RenderHtmlAsPdf(html)
                    log.LogInformation("PDF generated: {Pages} pages, {Bytes} bytes", pdf.PageCount, pdf.BinaryData.Length)
                    Return pdf.BinaryData
                End Using
            End Using
        Finally
            Throttle.Release()
        End Try
    End Function
End Module

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.Extensibility;

// Track custom metrics using Application Insights
var telemetry = new TelemetryClient(TelemetryConfiguration.CreateDefault());

var sw = System.Diagnostics.Stopwatch.StartNew();
var pdfBytes = await PdfProductionService.GeneratePdfAsync(html, logger);
sw.Stop();

telemetry.TrackMetric("PdfGenerationTimeMs", sw.Elapsed.TotalMilliseconds);
telemetry.TrackMetric("PdfFileSizeBytes", pdfBytes.Length);

Imports Microsoft.ApplicationInsights
Imports Microsoft.ApplicationInsights.Extensibility
Imports System.Diagnostics

' Track custom metrics using Application Insights
Dim telemetry As New TelemetryClient(TelemetryConfiguration.CreateDefault())

Dim sw As Stopwatch = Stopwatch.StartNew()
Dim pdfBytes = Await PdfProductionService.GeneratePdfAsync(html, logger)
sw.Stop()

telemetry.TrackMetric("PdfGenerationTimeMs", sw.Elapsed.TotalMilliseconds)
telemetry.TrackMetric("PdfFileSizeBytes", pdfBytes.Length)

using IronPdf;

// Load or generate the PDF
using var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Secure Report</h1>");

// Apply password protection
pdf.SecuritySettings.UserPassword = "view-password";
pdf.SecuritySettings.OwnerPassword = "admin-password";

// Restrict permissions
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;

pdf.SaveAs("azure-secure-report.pdf");

Imports IronPdf

' Load or generate the PDF
Using pdf = New ChromePdfRenderer().RenderHtmlAsPdf("<h1>Secure Report</h1>")

    ' Apply password protection
    pdf.SecuritySettings.UserPassword = "view-password"
    pdf.SecuritySettings.OwnerPassword = "admin-password"

    ' Restrict permissions
    pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights
    pdf.SecuritySettings.AllowUserCopyPasteContent = False
    pdf.SecuritySettings.AllowUserAnnotations = False

    pdf.SaveAs("azure-secure-report.pdf")
End Using

using IronPdf;

using var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Report content goes here.</p>");

// Add dynamic header with page numbers
var header = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:right;font-size:10px'>Page {page} of {total-pages}</div>",
    Height = 15
};
pdf.AddHTMLHeaders(header);

// Apply a draft watermark when needed
pdf.ApplyWatermark(
    "<h1 style='color:gray;opacity:0.3'>DRAFT</h1>",
    45,
    IronPdf.Editing.VerticalAlignment.Middle,
    IronPdf.Editing.HorizontalAlignment.Center);

pdf.SaveAs("report-with-header.pdf");

Imports IronPdf

Using pdf = New ChromePdfRenderer().RenderHtmlAsPdf("<h1>Monthly Report</h1><p>Report content goes here.</p>")
    ' Add dynamic header with page numbers
    Dim header As New HtmlHeaderFooter With {
        .HtmlFragment = "<div style='text-align:right;font-size:10px'>Page {page} of {total-pages}</div>",
        .Height = 15
    }
    pdf.AddHTMLHeaders(header)

    ' Apply a draft watermark when needed
    pdf.ApplyWatermark(
        "<h1 style='color:gray;opacity:0.3'>DRAFT</h1>",
        45,
        IronPdf.Editing.VerticalAlignment.Middle,
        IronPdf.Editing.HorizontalAlignment.Center)

    pdf.SaveAs("report-with-header.pdf")
End Using

using Microsoft.ApplicationInsights;

var telemetryClient = new TelemetryClient();
telemetryClient.TrackMetric("PdfGenerationTimeMs", generationTime.TotalMilliseconds);
telemetryClient.TrackMetric("PdfPageCount", pdfPageCount);
telemetryClient.TrackMetric("PdfFileSizeBytes", fileSizeBytes);

Imports Microsoft.ApplicationInsights

Dim telemetryClient As New TelemetryClient()
telemetryClient.TrackMetric("PdfGenerationTimeMs", generationTime.TotalMilliseconds)
telemetryClient.TrackMetric("PdfPageCount", pdfPageCount)
telemetryClient.TrackMetric("PdfFileSizeBytes", fileSizeBytes)