Wie Konfigurieren Sie Proxy-Server für die PDF-Darstellung in C

Minimaler Arbeitsablauf (3 Schritte)

1. Installieren Sie IronPDF über NuGet: Install-Package IronPdf
2. Übergeben Sie den Proxys-String als dritten Parameter an RenderHtmlAsPdf()
3. Format: http(s)://host:port oder http(s)://user:pass@host:port für authentifizierte Proxies

Wie übergeben Sie einen Proxy an RenderHtmlAsPdf?

Der Proxy-Parameter ist ein optionaler string bei vier Methodensignaturen:

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

Wenn dieser Parameter null ist (der Standard), verbindet sich IronPDFs Chromium-Engine direkt mit externen Ressourcen — Stylesheets, Bilder, Schriftarten und JavaScript-Dateien, die in Ihrem HTML referenziert werden. Wenn Sie einen Proxy-String angeben, werden alle HTTP/HTTPS-Anfragen der Rendering-Engine über diesen Proxy geleitet.

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"
)

Der Proxys-String unterstützt sowohl http:// als auch https://-Schema. Verwenden Sie https://, wenn der Proxy selbst TLS-Verschlüsselung für die Verbindung zwischen Ihrer Anwendung und dem Proxy-Server erfordert. Das Schema bezieht sich hier auf die Proxys-Verbindung, nicht auf die endgültige Ressource — ein http://-Proxy kann trotzdem https://-Ressourcen über CONNECT-Tunneling holen.

Die statischen Methodevarianten akzeptieren denselben Proxys-Parameter, was für einmalige Rendervorgänge in Konsolenanwendungen oder Unit-Tests nützlich ist:

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

Wichtig: Es gibt keine ProxyAddress-Eigenschaft bei ChromePdfRenderOptions. Suchen Sie nicht danach dort. Der Proxy ist strikt ein Methodeparameter bei RenderHtmlAsPdf und StaticRenderHtmlAsPdf Überladungen.

Wie authentifizieren Sie sich mit einem Unternehmens-Proxy?

Die meisten Unternehmensproxies erfordern Anmeldeinformationen. Sie betten diese direkt in die Proxy-URL ein, indem Sie das http(s)://username:password@host:port-Format verwenden:

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")

URL-spezielle Zeichen in Passwörtern kodieren. Wenn Ihr Passwort @, #, :, / oder andere reservierte URI-Zeichen enthält, müssen sie prozentkodiert werden. Häufige Codierungen:

Verwenden Sie Uri.EscapeDataString(), um das Passwort programmgesteuert zu kodieren:

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"

Verwechseln Sie nicht die Proxys-Authentifizierung mit der Webauthentifizierung. Die ChromeHttpLoginCredentials.NetworkUsername und NetworkPassword-Eigenschaften authentifizieren sich gegen die Webseite, die gerendert wird (NTLM/Negotiate mit einer Website), nicht gegen einen Proxy-Server. Für die Proxys-Auth gehen die Anmeldeinformationen in den Proxy-URL-String, wie oben gezeigt.

Wie rendern Sie URLs hinter einem Proxy?

RenderUrlAsPdf() akzeptiert keinen Proxy-Parameter. Dies ist eine beabsichtigte API-Designentscheidung — RenderUrlAsPdf navigiert Chromium zu einer URL, und die Proxy-Konfiguration für diese Navigation wird anders als beim Laden von Ressourcen während der HTML-Rendering behandelt.

Das empfohlene Workaround: Holen Sie das HTML selbst ab, indem Sie HttpClient mit einem WebProxy konfigurieren und dann den HTML-String an RenderHtmlAsPdf() mit dem Proxy-Parameter übergeben (damit referenzierte Assets — Bilder, CSS, Schriftarten — ebenfalls über den Proxy geleitet werden).

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

Der baseUrlOrPath-Parameter ist auf die ursprüngliche Ziel-URL eingestellt, sodass relative Pfade im abgerufenen HTML (<img src="/images/logo.png">, <link href="/css/styles.css">) korrekt aufgelöst werden. Der proxy-Parameter stellt sicher, dass diese Asset-Anfragen während der Rendering über den Proxy geleitet werden.

Dieses Muster funktioniert auch mit Seiten hinter Authentifizierung — Konfigurieren Sie den HttpClient mit den entsprechenden Cookies oder Headern vor der Abfrage und übergeben Sie dann das authentifizierte HTML an IronPDF. Die HTTP-Anfrage-Header-Anleitung behandelt die Header-Konfiguration für authentifizierte Anfragen.

Wenn die Seite JavaScript für die Darstellung benötigt (SPAs, React-Dashboards, Angular-Apps), enthält das abgeholte HTML nur die initiale Hülle — die Client-seitige Darstellung wird während der HttpClient-Abfrage nicht ausgeführt. Für diese Fälle haben Sie zwei Optionen: Stellen Sie Systemweite HTTPS_PROXY Umgebungsvariablen ein (im nächsten Abschnitt behandelt), sodass RenderUrlAsPdf() auf OS-Ebene durch den Proxy geleitet wird, oder verwenden Sie einen kopflosen Browser, um das vollständig gerenderte HTML abzurufen, bevor Sie es an RenderHtmlAsPdf() übergeben.

Wie konfigurieren Sie einen Proxy in Docker-Containern?

In containerisierten Umgebungen bevorzugen Sie möglicherweise die Systemweite Proxy-Konfiguration über Methodeparameter. IronPDFs Chromium-Engine respektiert die Standard-HTTP_PROXY- und HTTPS_PROXY-Umgebungsvariablen, die Linux-Container für das Routing ausgehenden Datenverkehrs verwenden.

Setzen Sie diese in Ihrer 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"]

Mit diesen Umgebungsvariablen können Sie RenderHtmlAsPdf() ohne den Proxy-Parameter aufrufen — Chromium übernimmt die Systemweite Konfiguration automatisch:

// 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 ist wichtig für interne Ressourcen. Ohne dies würden Anfragen an interne Dienste (wie ein lokaler CSS-Server oder ein Image-CDN innerhalb Ihres Kubernetes-Clusters) unnötigerweise durch den Proxy geleitet. Trennen Sie die Hostnamen und Domains, die den Proxy umgehen sollen, durch Kommas.

Wenn Sie sowohl Systemweite Proxy für allgemeinen Datenverkehr als auch einen anderen Proxy für spezielle Rendervorgänge benötigen, hat der Methodeparameter Vorrang vor der Umgebungsvariablen. Dies gibt Ihnen je nach Bedarf eine per-Render-Steuerung.

Für Kubernetes-Einsätze Proxy-Konfiguration über ConfigMaps oder Umgebungsvariablen in der Pod-Spezifikation einfügen, anstatt sie in der Dockerfile fest einzubetten. Dies ermöglicht es dem gleichen Containerbild, in verschiedenen Umgebungen mit unterschiedlichen Proxy-Konfigurationen zu funktionieren:

# 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"

Wenn sowohl die Umgebungsvariable als auch der Methodeparameter vorhanden sind, hat der Methodeparameter Vorrang. Dies gibt Ihnen ein geschichtetes Konfigurationsmodell: Setzen Sie den Standardproxy auf Infrastrukturebene und überschreiben Sie ihn bei spezifischen Anfragen pro Render, wenn ein anderer Weg erforderlich ist.

Wie handhaben Sie einen Proxy in CI/CD-Pipelines?

CI/CD-Ausführungen in Unternehmensnetzwerken sitzen häufig hinter Proxies. Übergeben Sie die Proxy-URL als Build-Variable oder Geheimnis — niemals Anmeldeinformationen im Quellcode festkodieren.

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 (Deklarative Pipeline):

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

In allen drei Fällen liest Chromium die Umgebungsvariablen automatisch. Wenn Sie explizite Kontrolle bevorzugen, lesen Sie die Proxy-URL aus der Umgebung und übergeben Sie sie als Methodeparameter:

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)

Wie beheben Sie Proxy-Probleme?

Timeout-Fehler: Unternehmensproxies fügen Latenz hinzu. Erhöhen Sie den Render-Timeout vom 60-Sekunden-Standard:

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120; // seconds

renderer.RenderingOptions.Timeout = 120 ' seconds

Dies ist die ChromePdfRenderOptions.Timeout-Eigenschaft — sie steuert, wie lange Chromium auf das Laden der Seite und das Abrufen von Ressourcen insgesamt wartet. Wenn Ihr Proxy 5–10 Sekunden Latenz pro Anfrage hinzufügt und die Seite über 20 externe Ressourcen lädt, könnten 60 Sekunden nicht ausreichen.

SSL-Abfang (MITM-Proxies): Viele Unternehmensproxies entschlüsseln und verschlüsseln den HTTPS-Datenverkehr mithilfe eines unternehmensinternen Root-CA-Zertifikats. Chromium lehnt diese Verbindungen ab, da es der Unternehmensinterne CA standardmäßig nicht vertraut. Zwei Lösungen:

1. Installieren Sie das Unternehmensinterne CA-Zertifikat im vertrauenswürdigen Root-Speicher des Containers oder Hosts. Unter Linux: Kopieren Sie .crt nach /usr/local/share/ca-certificates/ und führen Sie update-ca-certificates aus.
2. Nur in der Entwicklung können Sie die Zertifikatvalidierung deaktivieren — aber machen Sie das niemals in der Produktion. Der sicherere Ansatz ist immer das richtige Zertifikat zu installieren.

NTLM-Authentifizierung: Das Inline-Format user:pass@host unterstützt Basis- und Digest-Proxy-Authentifizierung. NTLM (häufig in Windows-zentrierten Unternehmen) wird über den Proxy-URL-String nicht unterstützt. Der Workaround besteht darin, einen lokalen NTLM-zu-Basic-Weiterleitungs-Proxy wie CNTLM auf dem Host oder als Sidecar-Container auszuführen. Konfigurieren Sie CNTLM mit Ihren NTLM-Anmeldeinformationen und zeigen Sie IronPDF auf http://localhost:3128 (dem Standard-Port von CNTLM).

Leeres PDF oder fehlende Assets: Wenn das PDF gerendert wird, aber Bilder/CSS fehlen, referenziert Ihr HTML Ressourcen, die der Proxy blockiert oder die einen anderen Proxy-Pfad erfordern. Überprüfen Sie, ob der baseUrlOrPath-Parameter korrekt über den Proxys aufgelöst wird und prüfen Sie die Zugriffsprotokolle des Proxys auf 403 oder 407-Antworten.

Proxy-Umgehung für lokale Assets: Wenn Ihr HTML eine Mischung aus lokalen Assets (gebündelte Bilder, Inline-CSS) und entfernten Ressourcen (CDN-Schriftarten, externe Skripte) referenziert, muss der Proxys nur die entfernten Anfragen bearbeiten. Setzen Sie baseUrlOrPath auf ein lokales Verzeichnis für Dateisystem-Assets und lassen Sie den Proxy nur die Netzwerkanfragen verarbeiten. Dies vermeidet, dass lokale Dateiabrufe unnötigerweise durch den Proxy geleitet werden.

Konnektivität diagnostizieren: Um zu überprüfen, ob Ihr Proxy-String korrekt ist, bevor Sie ihn mit IronPDF verwenden, testen Sie ihn zuerst mit einer einfachen HttpClient-Anfrage:

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

Wenn dies gelingt, aber IronPDF dennoch fehlschlägt, liegt das Problem wahrscheinlich an SSL-Abfang oder einem Protokollmismatch zwischen Ihrem Proxy und Chromium's CONNECT-Tunneling. Prüfen Sie, ob der Proxy HTTP CONNECT für HTTPS-Ressourcen unterstützt — einige Proxies erfordern eine explizite Konfiguration, um das Tunneling zu ermöglichen.

Nächste Schritte

Die Proxy-Unterstützung in IronPDF ist ein Methodenparameter bei RenderHtmlAsPdf() — übergeben Sie den Proxy-String, und die Chromium-Engine leitet den gesamten HTTP-Datenverkehr darüber. Für RenderUrlAsPdf()-Szenarien rufen Sie das HTML zuerst mit HttpClient und einem WebProxy ab. Für Container und CI/CD geben systemweite HTTPS_PROXY-Umgebungsvariablen Ihnen infrastrukturelle Kontrolle ohne Codeänderungen.

Erforschen Sie die Logins und Authentifizierungsanleitung für die Webseiten-Authentifizierung (anders als die Proxy-Auth), die HTTP-Anfrage-Header-Anleitung für benutzerdefinierte Header und die Rendering-Optionen-Referenz für Timeout und Performance-Optimierung.

Sehen Sie sich Lizenzierungsoptionen ab $749 an. Die ChromePdfRenderer API-Referenz dokumentiert jede Methodeüberladung und die ChromePdfRenderOptions-Referenz behandelt alle konfigurierbaren Eigenschaften.