Como Configurar Servidores Proxy para Renderização de PDF em C

Fluxo de Trabalho Mínimo (3 Passos)

1. Instale o IronPDF via NuGet: Install-Package IronPdf
2. Passe a string do proxy como terceiro parâmetro para RenderHtmlAsPdf()
3. Formato: http(s)://host:port ou http(s)://user:pass@host:port para proxies autenticados

Como Você Passa um Proxy para RenderHtmlAsPdf?

O parâmetro Proxy é um string opcional em quatro assinaturas de método:

// Instance methods
PdfDocument RenderHtmlAsPdf(string Html, string BaseUrlOrPath, string Proxy = null)
PdfDocument RenderHtmlAsPdf(string Html, Uri BaseUrl = null, string Proxy = null)

// Static methods
PdfDocument StaticRenderHtmlAsPdf(string Html, ChromePdfRenderOptions Options = null, string Proxy = null)
PdfDocument StaticRenderHtmlAsPdf(string Html, string BaseUrlOrPath, ChromePdfRenderOptions Options = null, string Proxy = null)

// Instance methods
PdfDocument RenderHtmlAsPdf(string Html, string BaseUrlOrPath, string Proxy = null)
PdfDocument RenderHtmlAsPdf(string Html, Uri BaseUrl = null, string Proxy = null)

// Static methods
PdfDocument StaticRenderHtmlAsPdf(string Html, ChromePdfRenderOptions Options = null, string Proxy = null)
PdfDocument StaticRenderHtmlAsPdf(string Html, string BaseUrlOrPath, ChromePdfRenderOptions Options = null, string Proxy = null)

' Instance methods
Function RenderHtmlAsPdf(Html As String, BaseUrlOrPath As String, Optional Proxy As String = Nothing) As PdfDocument
End Function

Function RenderHtmlAsPdf(Html As String, Optional BaseUrl As Uri = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

' Static methods
Shared Function StaticRenderHtmlAsPdf(Html As String, Optional Options As ChromePdfRenderOptions = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

Shared Function StaticRenderHtmlAsPdf(Html As String, BaseUrlOrPath As String, Optional Options As ChromePdfRenderOptions = Nothing, Optional Proxy As String = Nothing) As PdfDocument
End Function

Quando este parâmetro é null (o padrão), o motor Chromium do IronPDF se conecta diretamente a recursos externos — folhas de estilo, imagens, fontes e arquivos JavaScript referenciados em seu HTML. Quando você fornece uma string de proxy, todas as solicitações HTTP/HTTPS do motor de renderização são roteadas através desse proxy.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Direct connection (default — no proxy)
var pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>");

// Through an unauthenticated proxy
var pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath: null,
    proxy: "http://squid.internal:3128"
);

// Using the Uri overload
var pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl: new Uri("https://assets.example.com/"),
    proxy: "https://proxy.corp.local:8443"
);

using IronPdf;

var renderer = new ChromePdfRenderer();

// Direct connection (default — no proxy)
var pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>");

// Through an unauthenticated proxy
var pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath: null,
    proxy: "http://squid.internal:3128"
);

// Using the Uri overload
var pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl: new Uri("https://assets.example.com/"),
    proxy: "https://proxy.corp.local:8443"
);

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Direct connection (default — no proxy)
Dim pdfDirect = renderer.RenderHtmlAsPdf("<h1>Direct</h1>")

' Through an unauthenticated proxy
Dim pdfProxied = renderer.RenderHtmlAsPdf(
    "<h1>Proxied</h1>",
    baseUrlOrPath:=Nothing,
    proxy:="http://squid.internal:3128"
)

' Using the Uri overload
Dim pdfUri = renderer.RenderHtmlAsPdf(
    "<h1>Proxied via Uri overload</h1>",
    baseUrl:=New Uri("https://assets.example.com/"),
    proxy:="https://proxy.corp.local:8443"
)

A string de proxy suporta esquemas http:// e https://. Use https:// quando o próprio proxy requer criptografia TLS para a conexão entre seu aplicativo e o servidor proxy. O esquema aqui se refere à conexão do proxy, não ao recurso final — um proxy http:// ainda pode buscar recursos https:// via tunelamento CONNECT.

As variantes de método estático aceitam o mesmo parâmetro de proxy, o que é útil para renderizações pontuais em aplicativos de console ou testes unitários:

// Static render with proxy — no renderer instance needed
var pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options: null,
    proxy: "http://proxy.corp.local:8080"
);

// Static render with proxy — no renderer instance needed
var pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options: null,
    proxy: "http://proxy.corp.local:8080"
);

' Static render with proxy — no renderer instance needed
Dim pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(
    "<h1>Static render through proxy</h1>",
    options:=Nothing,
    proxy:="http://proxy.corp.local:8080"
)

Importante: Não há propriedade ProxyAddress em ChromePdfRenderOptions. Não procure por isso lá. O proxy é estritamente um parâmetro de método em sobrecargas RenderHtmlAsPdf e StaticRenderHtmlAsPdf.

Como Você Autentica com um Proxy Corporativo?

A maioria dos proxies empresariais requer credenciais. Você os incorpora diretamente na URL do proxy usando o formato http(s)://username:password@host:port:

using IronPdf;

var renderer = new ChromePdfRenderer();

string proxyWithAuth = "http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080";

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: @"C:\templates\assets\",
    proxy: proxyWithAuth
);
pdf.SaveAs("report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

string proxyWithAuth = "http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080";

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: @"C:\templates\assets\",
    proxy: proxyWithAuth
);
pdf.SaveAs("report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim proxyWithAuth As String = "http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080"

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
    htmlContent,
    baseUrlOrPath: "C:\templates\assets\",
    proxy:=proxyWithAuth
)
pdf.SaveAs("report.pdf")

Codifique caracteres especiais em senhas na URL. Se sua senha contiver @, #, :, / ou outros caracteres reservados da URI, eles devem ser codificados em porcentagem. Codificações comuns:

Use Uri.EscapeDataString() para codificar a senha programaticamente:

string rawPassword = "P@ssw0rd!";
string encoded = Uri.EscapeDataString(rawPassword); // "P%40ssw0rd%21"
string proxy = $"http://svc-account:{encoded}@proxy.corp.local:8080";

string rawPassword = "P@ssw0rd!";
string encoded = Uri.EscapeDataString(rawPassword); // "P%40ssw0rd%21"
string proxy = $"http://svc-account:{encoded}@proxy.corp.local:8080";

Imports System

Dim rawPassword As String = "P@ssw0rd!"
Dim encoded As String = Uri.EscapeDataString(rawPassword) ' "P%40ssw0rd%21"
Dim proxy As String = $"http://svc-account:{encoded}@proxy.corp.local:8080"

Não confunda autenticação de proxy com autenticação de página web. As propriedades ChromeHttpLoginCredentials.NetworkUsername e NetworkPassword autenticam na página web sendo renderizada (NTLM/Negotiate com um site), não contra um servidor proxy. Para autenticação de proxy, as credenciais entram na string da URL do proxy como mostrado acima.

Como Você Renderiza URLs Atrás de um Proxy?

RenderUrlAsPdf() não aceita um parâmetro de proxy. Esta é uma escolha deliberada de design da API — RenderUrlAsPdf navega o Chromium para uma URL, e a configuração de proxy para essa navegação é tratada de forma diferente do carregamento de recursos durante a renderização HTML.

A solução recomendada: busque o HTML você mesmo usando HttpClient configurado com um WebProxy, depois passe a string HTML para RenderHtmlAsPdf() com o parâmetro de proxy (para que os ativos referenciados — imagens, CSS, fontes — também sejam roteados pelo proxy).

using IronPdf;
using System.Net;
using System.Net.Http;

// Step 1: Configure HttpClient with the corporate proxy
var proxy = new WebProxy("http://proxy.corp.local:8080")
{
    Credentials = new NetworkCredential("svc-account", "P@ssw0rd!")
};

var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var httpClient = new HttpClient(handler);

// Step 2: Fetch the HTML from the target URL
string targetUrl = "https://dashboard.internal.corp/quarterly-report";
string html = await httpClient.GetStringAsync(targetUrl);

// Step 3: Render the fetched HTML, with the proxy for asset loading
var renderer = new ChromePdfRenderer();

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    html,
    baseUrlOrPath: targetUrl,  // Resolves relative asset paths against the original URL
    proxy: "http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080"
);
pdf.SaveAs("quarterly-report.pdf");

using IronPdf;
using System.Net;
using System.Net.Http;

// Step 1: Configure HttpClient with the corporate proxy
var proxy = new WebProxy("http://proxy.corp.local:8080")
{
    Credentials = new NetworkCredential("svc-account", "P@ssw0rd!")
};

var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var httpClient = new HttpClient(handler);

// Step 2: Fetch the HTML from the target URL
string targetUrl = "https://dashboard.internal.corp/quarterly-report";
string html = await httpClient.GetStringAsync(targetUrl);

// Step 3: Render the fetched HTML, with the proxy for asset loading
var renderer = new ChromePdfRenderer();

PdfDocument pdf = renderer.RenderHtmlAsPdf(
    html,
    baseUrlOrPath: targetUrl,  // Resolves relative asset paths against the original URL
    proxy: "http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080"
);
pdf.SaveAs("quarterly-report.pdf");

Imports IronPdf
Imports System.Net
Imports System.Net.Http

' Step 1: Configure HttpClient with the corporate proxy
Dim proxy As New WebProxy("http://proxy.corp.local:8080") With {
    .Credentials = New NetworkCredential("svc-account", "P@ssw0rd!")
}

Dim handler As New HttpClientHandler With {.Proxy = proxy, .UseProxy = True}
Using httpClient As New HttpClient(handler)
    ' Step 2: Fetch the HTML from the target URL
    Dim targetUrl As String = "https://dashboard.internal.corp/quarterly-report"
    Dim html As String = Await httpClient.GetStringAsync(targetUrl)

    ' Step 3: Render the fetched HTML, with the proxy for asset loading
    Dim renderer As New ChromePdfRenderer()

    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
        html,
        baseUrlOrPath:=targetUrl,  ' Resolves relative asset paths against the original URL
        proxy:="http://svc-account:P%40ssw0rd%21@proxy.corp.local:8080"
    )
    pdf.SaveAs("quarterly-report.pdf")
End Using

O parâmetro baseUrlOrPath é definido para a URL alvo original para que os caminhos relativos no HTML obtido (<img src="/images/logo.png">, <link href="/css/styles.css">) sejam resolvidos corretamente. O parâmetro proxy garante que essas solicitações de ativos passem pelo proxy durante a renderização.

Este padrão também funciona com páginas por trás de autenticação — configure o HttpClient com os cookies ou cabeçalhos apropriados antes de buscar, depois passe o HTML autenticado ao IronPDF. O como fazer cabeçalhos de solicitação HTTP cobre a configuração de cabeçalhos para solicitações autenticadas.

Se a página depende de JavaScript para renderização (SPAs, painéis React, aplicativos Angular), o HTML obtido conterá apenas a estrutura inicial — a renderização do lado do cliente não será executada durante a busca HttpClient. Para esses casos, você tem duas opções: defina variáveis de ambiente HTTPS_PROXY no nível do sistema (cobertas na seção seguinte) para que RenderUrlAsPdf() roteie através do proxy ao nível do SO, ou use um navegador sem cabeça para buscar o HTML totalmente renderizado antes de passá-lo para RenderHtmlAsPdf().

Como Você Configura Proxy em Contêineres Docker?

Em ambientes conteinerizados, você pode preferir a configuração de proxy ao nível do sistema em vez de parâmetros por método. O motor Chromium do IronPDF respeita as variáveis de ambiente padrão HTTP_PROXY e HTTPS_PROXY que contêineres Linux usam para roteamento de tráfego de saída.

Defina estas em seu Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:8.0

# System-level proxy for all outbound HTTP/HTTPS traffic
ENV HTTP_PROXY=http://proxy.corp.local:8080
ENV HTTPS_PROXY=http://proxy.corp.local:8080
ENV NO_PROXY=localhost,127.0.0.1,.internal.corp

# Install IronPDF dependencies (fonts, etc.)
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    fonts-liberation \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Com estas variáveis de ambiente definidas, você pode chamar RenderHtmlAsPdf() sem o parâmetro de proxy — Chromium detecta automaticamente a configuração ao nível do sistema:

// No proxy parameter needed — Chromium uses HTTP_PROXY env var
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// No proxy parameter needed — Chromium uses HTTP_PROXY env var
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

' No proxy parameter needed — Chromium uses HTTP_PROXY env var
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

NO_PROXY é importante para recursos internos. Sem ele, solicitações para serviços internos (como um servidor CSS local ou CDN de imagens executando dentro de seu cluster Kubernetes) seriam desnecessariamente roteadas pelo proxy. Separe com vírgulas os nomes de host e domínios que devem ignorar o proxy.

Se você precisar de proxy ao nível do sistema para tráfego em geral e um proxy diferente para renderizações específicas, o parâmetro de método tem precedência sobre a variável de ambiente. Isso dá a você controle por renderização quando necessário.

Para implantações no Kubernetes, injete a configuração de proxy via ConfigMaps ou variáveis de ambiente na especificação do pod, em vez de codificá-las no Dockerfile. Isso faz com que a mesma imagem de contêiner funcione em vários ambientes com diferentes configurações de proxy:

# Kubernetes pod spec
spec:
  containers:
    - name: pdf-generator
      image: myregistry/pdf-service:latest
      env:
        - name: HTTP_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: http-proxy
        - name: HTTPS_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: https-proxy
        - name: NO_PROXY
          value: "localhost,127.0.0.1,.internal.corp"

# Kubernetes pod spec
spec:
  containers:
    - name: pdf-generator
      image: myregistry/pdf-service:latest
      env:
        - name: HTTP_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: http-proxy
        - name: HTTPS_PROXY
          valueFrom:
            configMapKeyRef:
              name: proxy-config
              key: https-proxy
        - name: NO_PROXY
          value: "localhost,127.0.0.1,.internal.corp"

Quando ambos, a variável de ambiente e o parâmetro de método estão presentes, o parâmetro de método tem precedência. Isso oferece um modelo de configuração em camadas: defina o proxy padrão ao nível da infraestrutura, e substitua-o por renderização quando solicitações específicas precisarem de uma rota diferente.

Como Você Lida com Proxy em Pipelines CI/CD?

CI/CD runners em redes corporativas frequentemente estão atrás de proxies. Passe a URL do proxy como uma variável de build ou segredo — nunca codifique credenciais no controle de versão.

GitHub Actions:

jobs:
  generate-pdf:
    runs-on: ubuntu-latest
    env:
      HTTP_PROXY: ${{ secrets.CORP_PROXY_URL }}
      HTTPS_PROXY: ${{ secrets.CORP_PROXY_URL }}
    steps:
      - uses: actions/checkout@v4
      - run: dotnet build
      - run: dotnet test

jobs:
  generate-pdf:
    runs-on: ubuntu-latest
    env:
      HTTP_PROXY: ${{ secrets.CORP_PROXY_URL }}
      HTTPS_PROXY: ${{ secrets.CORP_PROXY_URL }}
    steps:
      - uses: actions/checkout@v4
      - run: dotnet build
      - run: dotnet test

Azure DevOps:

variables:
  - group: proxy-settings  # Contains PROXY_URL secret

steps:
  - script: |
      export HTTP_PROXY=$(PROXY_URL)
      export HTTPS_PROXY=$(PROXY_URL)
      dotnet run --project PdfGenerator
    displayName: 'Generate PDFs behind proxy'

variables:
  - group: proxy-settings  # Contains PROXY_URL secret

steps:
  - script: |
      export HTTP_PROXY=$(PROXY_URL)
      export HTTPS_PROXY=$(PROXY_URL)
      dotnet run --project PdfGenerator
    displayName: 'Generate PDFs behind proxy'

Jenkins (Pipeline Declarativo):

environment {
    HTTP_PROXY  = credentials('corp-proxy-url')
    HTTPS_PROXY = credentials('corp-proxy-url')
}

Em todos os três casos, Chromium lê as variáveis de ambiente automaticamente. Se você preferir controle explícito, leia a URL do proxy do ambiente e passe-a como o parâmetro de método:

string? proxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
var pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath: null, proxy: proxy);

string? proxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
var pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath: null, proxy: proxy);

Option Strict On



Dim proxy As String = Environment.GetEnvironmentVariable("HTTPS_PROXY")
Dim pdf = renderer.RenderHtmlAsPdf(html, baseUrlOrPath:=Nothing, proxy:=proxy)

Como Você Soluciona Problemas de Proxy?

Erros de tempo limite: Proxies corporativos aumentam a latência. Aumente o tempo limite de renderização do padrão de 60 segundos:

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120 ' seconds

Esta é a propriedade ChromePdfRenderOptions.Timeout — ela controla quanto tempo Chromium aguarda para carregar a página e buscar recursos combinados. Se seu proxy adicionar de 5 a 10 segundos de latência por solicitação e a página carregar mais de 20 recursos externos, 60 segundos podem não ser suficientes.

Interceptação de SSL (proxies MITM): Muitos proxies corporativos descriptografam e criptografam novamente o tráfego HTTPS usando um certificado CA raiz corporativo. Chromium rejeita essas conexões porque não confia por padrão na CA corporativa. Duas soluções:

1. Instale o certificado CA corporativo na loja raiz confiável do contêiner ou do host. No Linux: copie o .crt para /usr/local/share/ca-certificates/ e execute update-ca-certificates.
2. Apenas em desenvolvimento, você pode desabilitar a validação de certificados — mas nunca faça isso em produção. A abordagem mais segura é sempre instalar o certificado adequado.

Autenticação NTLM: O formato inline user:pass@host suporta autenticação de proxy Básica e Digest. NTLM (comum em empresas centradas no Windows) não é suportado pela string URL do proxy. A solução alternativa é executar um proxy NTLM-to-Basic local, como o CNTLM no host ou como um contêiner auxiliar. Configure o CNTLM com suas credenciais NTLM, depois aponte o IronPDF para http://localhost:3128 (porta padrão do CNTLM).

PDF em branco ou ativos ausentes: Se o PDF renderizar mas imagens/CSS estiverem ausentes, seu HTML referencia recursos que o proxy bloqueia ou que requerem um caminho de proxy diferente. Verifique se o parâmetro baseUrlOrPath resolve corretamente através do proxy e cheque os logs de acesso do proxy para respostas 403 ou 407.

Desvio de proxy para ativos locais: Se seu HTML referencia uma mistura de ativos locais (imagens incluídas, CSS inline) e recursos remotos (fontes CDN, scripts externos), o proxy só precisa lidar com as solicitações remotas. Defina baseUrlOrPath para um diretório local para ativos do sistema de arquivos, e deixe o proxy lidar apenas com as solicitações de rede. Isso evita o roteamento desnecessário de leituras de arquivos locais através do proxy.

Diagnóstico de conectividade: Para verificar se sua string de proxy está correta antes de usá-la com o IronPDF, teste com uma simples solicitação HttpClient primeiro:

var proxy = new WebProxy("http://proxy.corp.local:8080");
var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var client = new HttpClient(handler);

var response = await client.GetAsync("https://httpbin.org/ip");
Console.WriteLine(await response.Content.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

var proxy = new WebProxy("http://proxy.corp.local:8080");
var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var client = new HttpClient(handler);

var response = await client.GetAsync("https://httpbin.org/ip");
Console.WriteLine(await response.Content.ReadAsStringAsync());
// Should return the proxy's external IP, not your machine's IP

Imports System
Imports System.Net
Imports System.Net.Http

Dim proxy As New WebProxy("http://proxy.corp.local:8080")
Dim handler As New HttpClientHandler With {.Proxy = proxy, .UseProxy = True}
Using client As New HttpClient(handler)
    Dim response = Await client.GetAsync("https://httpbin.org/ip")
    Console.WriteLine(Await response.Content.ReadAsStringAsync())
    ' Should return the proxy's external IP, not your machine's IP
End Using

Se isso tiver sucesso, mas o IronPDF ainda falhar, o problema provavelmente é a interceptação de SSL ou um desajuste de protocolo entre seu proxy e o tunelamento CONNECT do Chromium. Verifique se o proxy suporta HTTP CONNECT para recursos HTTPS — alguns proxies requerem configuração explícita para permitir tunelamento.

Próximos passos

O suporte a proxy no IronPDF é um parâmetro de método em RenderHtmlAsPdf() — passe a string do proxy e o motor Chromium roteará todo o tráfego HTTP por ele. Para cenários RenderUrlAsPdf(), obtenha o HTML com HttpClient e um WebProxy primeiro. Para contêineres e CI/CD, as variáveis de ambiente HTTPS_PROXY ao nível do sistema oferecem controle ao nível da infraestrutura sem alterações de código.

Explore o tutorial de logins e autenticação para autenticação de páginas web (distinta da autenticação de proxy), o guia de cabeçalhos de solicitação HTTP para cabeçalhos personalizados e a referência de opções de renderização para ajustes de tempo limite e desempenho.

Veja opções de licenciamento a partir de $749. A referência de API ChromePdfRenderer documenta todas as sobrecargas de método e a referência ChromePdfRenderOptions cobre todas as propriedades configuráveis.