Playwright Proxy-Einrichtung

Playwright ermöglicht die Proxy-Einrichtung für Python- und Node.js-Skripte hauptsächlich über die Optionen browserType.launch() oder browser.newContext(), wodurch die Angabe von Proxy-Server-Adresse, Port und Authentifizierungsdaten möglich ist. Diese Konfiguration leitet alle nachfolgenden Netzwerkanfragen der gestarteten Browser-Instanz oder des Kontexts über den angegebenen Proxy.

Playwright Proxy-Konfigurationsübersicht

Playwright unterstützt Proxy-Konfigurationen auf zwei Hauptebenen:

1. Browser-Start-Ebene (Browser Launch Level): Anwenden eines Proxys auf die gesamte Browser-Instanz. Alle in diesem Browser erstellten Kontexte und Seiten verwenden den angegebenen Proxy. Dies ist geeignet, wenn alle Automatisierungsaufgaben denselben Proxy erfordern.
2. Browser-Kontext-Ebene (Browser Context Level): Anwenden eines Proxys auf einen bestimmten Browser-Kontext. Dies ermöglicht es verschiedenen Kontexten innerhalb derselben Browser-Instanz, unterschiedliche Proxys zu verwenden, oder einigen Kontexten, keinen Proxy zu verwenden, was für die Verwaltung vielfältiger Scraping- oder Testszenarien vorteilhaft ist.

Das Proxy-Konfigurationsobjekt oder -Wörterbuch von Playwright enthält typischerweise die server-Adresse (z.B. http://proxy.example.com:8080, socks5://localhost:9050) und optional username und password für authentifizierte Proxys.

Unterstützte Proxy-Typen

Playwright unterstützt Standard-Proxy-Protokolle:

• HTTP-Proxys: Angegeben mit http://- oder https://-Schemata.
• SOCKS-Proxys: Angegeben mit socks5://- oder socks4://-Schemata.

Wenn das Schema weggelassen wird (z.B. proxy.example.com:8080), verwendet Playwright standardmäßig einen HTTP-Proxy. Die explizite Angabe des Schemas wird zur Klarheit und zur Sicherstellung des korrekten Protokolls empfohlen.

Python Playwright Proxy-Einrichtung

In Python wird die Proxy-Konfiguration als Wörterbuch an das proxy-Argument von browser_type.launch() oder browser.new_context() übergeben.

Grundlegende HTTP/HTTPS Proxy-Einrichtung

Zur Verwendung eines nicht authentifizierten HTTP- oder HTTPS-Proxys:

from playwright.sync_api import sync_playwright

# For browser-wide proxy
with sync_playwright() as p:
    browser = p.chromium.launch(proxy={"server": "http://your.proxy.server:8080"})
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

# For context-specific proxy
with sync_playwright() as p:
    browser = p.chromium.launch()
    context = browser.new_context(proxy={"server": "http://another.proxy.server:8080"})
    page = context.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    context.close()
    browser.close()

Authentifizierte HTTP/HTTPS Proxy-Einrichtung

Für Proxys, die eine Authentifizierung erfordern, fügen Sie die Schlüssel username und password in das Proxy-Wörterbuch ein:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://user.proxy.server:8080",
            "username": "proxy_user",
            "password": "proxy_password"
        }
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

SOCKS Proxy-Einrichtung

Geben Sie das SOCKS-Protokoll in der server-Zeichenkette an:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={"server": "socks5://your.socks.proxy:9050"}
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

SOCKS-Proxys unterstützen auch die Authentifizierung durch Hinzufügen von username und password zum Wörterbuch.

Umgehen des Proxys für bestimmte Domains

Der bypass-Schlüssel im Proxy-Wörterbuch ermöglicht die Angabe einer kommagetrennten Liste von Hosts oder Domains, die den Proxy nicht verwenden sollen. Wildcards (*) werden unterstützt.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://your.proxy.server:8080",
            "bypass": "*.local, .example.com, 192.168.1.1"
        }
    )
    page = browser.new_page()
    page.goto("http://example.com") # Will bypass proxy if example.com is in bypass list
    page.goto("https://google.com") # Will use proxy
    browser.close()

Node.js Playwright Proxy-Einrichtung

In Node.js wird die Proxy-Konfiguration als Objekt an die proxy-Eigenschaft von browserType.launch() oder browser.newContext() übergeben.

Grundlegende HTTP/HTTPS Proxy-Einrichtung

Zur Verwendung eines nicht authentifizierten HTTP- oder HTTPS-Proxys:

const { chromium } = require('playwright');

(async () => {
  // For browser-wide proxy
  const browser = await chromium.launch({
    proxy: {
      server: 'http://your.proxy.server:8080'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();

  // For context-specific proxy
  const browser2 = await chromium.launch();
  const context = await browser2.newContext({
    proxy: {
      server: 'http://another.proxy.server:8080'
    }
  });
  const page2 = await context.newPage();
  await page2.goto('https://httpbin.org/ip');
  console.log(await page2.content());
  await context.close();
  await browser2.close();
})();

Authentifizierte HTTP/HTTPS Proxy-Einrichtung

Für Proxys, die eine Authentifizierung erfordern, fügen Sie die Eigenschaften username und password in das Proxy-Objekt ein:

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://user.proxy.server:8080',
      username: 'proxy_user',
      password: 'proxy_password'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();
})();

SOCKS Proxy-Einrichtung

Geben Sie das SOCKS-Protokoll in der server-Zeichenkette an:

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'socks5://your.socks.proxy:9050'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();
})();

SOCKS-Proxys unterstützen auch die Authentifizierung durch Hinzufügen von username und password zum Objekt.

Umgehen des Proxys für bestimmte Domains

Die bypass-Eigenschaft im Proxy-Objekt ermöglicht die Angabe einer kommagetrennten Liste von Hosts oder Domains, die den Proxy nicht verwenden sollen. Wildcards (*) werden unterstützt.

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://your.proxy.server:8080',
      bypass: '*.local, .example.com, 192.168.1.1'
    }
  });
  const page = await browser.newPage();
  await page.goto('http://example.com'); // Will bypass proxy if example.com is in bypass list
  await page.goto('https://google.com'); // Will use proxy
  await browser.close();
})();

Playwright Proxy-Konfigurationsvergleich

Erweiterte Proxy-Überlegungen

Proxying spezifischer Anfragen mit page.route()

Für eine sehr detaillierte Kontrolle kann page.route() Netzwerkanfragen abfangen und basierend auf spezifischen Kriterien an verschiedene Proxys weiterleiten. Diese Methode bietet mehr Flexibilität als globale oder kontextbezogene Proxy-Einstellungen, erfordert jedoch eine manuelle Anfragenbehandlung.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()

    def handle_route(route):
        if "example.com" in route.request.url:
            route.fulfill(status=200, body="Blocked by route handler.")
        else:
            # Forward other requests through a specific proxy
            # This requires manual HTTP client setup or could be complex for direct proxying
            # For simple use cases, global/context proxy is preferred.
            # For complex proxy routing, consider using an external proxy manager.
            route.continue_({"url": route.request.url}) # Example: continue without modification

    page.route("**/*", handle_route)
    page.goto("https://www.google.com") # Will be routed
    page.goto("https://www.example.com") # Will be fulfilled
    browser.close()

page.route() wird im Allgemeinen zum Mocken, Modifizieren von Anfragen oder Blockieren verwendet, anstatt dynamisch zu verschiedenen Proxys umzuleiten, es sei denn, es ist in eine benutzerdefinierte Proxy-Verarbeitungslogik integriert.

Überprüfung der Proxy-Funktionalität

Nach der Konfiguration eines Proxys überprüfen Sie dessen Funktion, indem Sie zu einem Dienst zur Überprüfung der IP-Adresse navigieren, wie z.B. https://httpbin.org/ip oder https://whatismyipaddress.com/. Die angezeigte IP-Adresse sollte dem Proxy-Server und nicht dem lokalen Computer entsprechen.

Umgang mit Proxy-Fehlern und Timeouts

Proxys können zusätzliche Fehlerquellen einführen. Implementieren Sie eine robuste Fehlerbehandlung für Netzwerkanfragen bei der Verwendung von Proxys. Dies umfasst:

• Wiederholungen (Retries): Erneutes Versuchen der Anfrage, wenn eine Proxy-Verbindung fehlschlägt oder ein Timeout auftritt.
• Timeouts: Konfigurieren geeigneter Netzwerk-Timeouts für Playwright-Operationen.
• Proxy-Rotation: Bei groß angelegten Operationen wechseln Sie durch einen Pool von Proxys, um Ratenbegrenzungen, IP-Sperren oder Ausfälle einzelner Proxys zu mindern. Dies beinhaltet typischerweise die Verwaltung einer Liste von Proxys und die dynamische Aktualisierung der proxy-Konfiguration für neue Kontexte oder Wiederholungen.

Sicherheitsüberlegungen

Bei der Verwendung authentifizierter Proxys vermeiden Sie es, Anmeldeinformationen direkt im Quellcode fest zu codieren. Verwenden Sie stattdessen Umgebungsvariablen oder ein sicheres Konfigurationsverwaltungssystem, um username und password abzurufen. Dies verhindert die Offenlegung von Anmeldeinformationen und vereinfacht die Verwaltung von Anmeldeinformationen in verschiedenen Umgebungen.