So verwenden Sie einen Proxy in Puppeteer

Puppeteer ist eine der beliebtesten Node.js-Bibliotheken und ein leistungsstarkes Tool für automatisierte Aufgaben wie Web-Scraping, Tests, SEO-Recherchen oder Preisüberwachung über Chrome- oder Chromium-Browser. Wenn Sie schon einmal mit automatisierten Workflows in großem Maßstab gearbeitet haben, kennen Sie das Problem bereits: Websites begrenzen die Zugriffsrate, drosseln Ihre Verbindung, blockieren Anfragen sofort oder setzen Ihre IP-Adresse sogar komplett auf die Sperrliste.

Diese Komplikationen kosten Sie nicht nur wertvolle Zeit und Geld, sondern können auch die Vertrauensbewertung Ihrer persönlichen Adresse erheblich beeinträchtigen und damit wiederum alle zukünftigen Online-Aktivitäten negativ beeinflussen. Glücklicherweise gibt es eine Methode, mit der sich diese Probleme mühelos lösen lassen und die es gleichzeitig ermöglicht, geografische Beschränkungen zu umgehen sowie automatisierte Anfragen zu verteilen, um eine höhere Erfolgsquote und eine bessere Verbindungsgeschwindigkeit zu erzielen. Ich spreche natürlich von Proxys.

In diesem Artikel werden wir genau klären, warum Sie Proxys benötigen und welche Art für Ihre Aufgabe erforderlich ist. Außerdem werden wir die grundlegende Konfiguration, die Authentifizierung und die Bedeutung der Protokolle erläutern. Darüber hinaus werde ich Ihnen einen hervorragenden Anbieter empfehlen, der sich in meinen eigenen Automatisierungspipelines besonders gut bewährt hat.

Was ist ein Puppeteer-Proxy und wozu benötigen Sie einen?

Ein Puppeteer-Proxy fungiert als Vermittler zwischen Ihrem automatisierten Skript und der Website, auf die Sie abzielen. Indem Ihre Anfragen über den dedizierten Server des Anbieters geleitet werden, verbirgt der Proxy Ihre tatsächliche IP-Adresse, sodass die Zielwebsite die IP-Adresse des Proxys sieht und nicht Ihre eigene.

Dennoch ist die IP-Maskierung nur die Spitze des Eisbergs. Hier finden Sie eine vollständige Liste der Vorteile, die ein Proxy für Ihren Puppeteer-Workflow bietet:

• IP-Sperren, Ratenbegrenzung und Drosselung vermeiden: Websites schränken häufig den Zugriff von IP-Adressen ein, die eine große Anzahl aufeinanderfolgender Anfragen stellen. Wenn Ihre Verbindung nicht gänzlich blockiert wird, kann sie erheblich verlangsamt oder mit CAPTCHAs überflutet werden. Ein gut konfigurierter Pool rotierender Proxys löst dieses Problem – selbst wenn eine Ihrer IP-Adressen gesperrt wird, springt eine andere ein, um einen unterbrechungsfreien Arbeitsablauf zu gewährleisten.
• Umgehung geografischer Beschränkungen: Ein großer Teil der Internetinhalte ist durch geografische Beschränkungen verborgen oder wird je nach Standort, von dem die Anfrage stammt, anderweitig angepasst. Mit Residential-Proxys können Sie mit höchster Präzision (bestimmte Bundesländer, Städte oder Postleitzahlen) eine Adresse von überall auf der Welt beziehen und so im Internet surfen, als befänden Sie sich physisch in dieser Region.
• Verbesserung der Erfolgsquote von Anfragen: Die Verteilung von Anfragen auf einen Proxy-Pool reduziert Verbindungsfehler und Timeouts drastisch, insbesondere bei intensiven Scraping-Aufgaben.

Dies erweist sich als äußerst nützlich, wenn nicht sogar entscheidend, bei:

• Web-Scraping in großem Maßstab
• Anzeigenüberprüfung
• SEO-Überwachung
• Qualitätssicherung und Tests
• Lokalisierung

Kurz gesagt: Wenn Sie Puppeteer für mehr als nur einen einfachen einmaligen Test einsetzen, sind Proxys unverzichtbar – ein qualitativ hochwertiges Proxy-Netzwerk ist oft der Unterschied zwischen einem fehleranfälligen Skript und einer zuverlässigen Datenpipeline.

Puppeteer: VPN oder Proxy – Welche Option ist die richtige?

Wenn es um Umgehungswerkzeuge geht, stellt sich unweigerlich die Frage: Was ist besser, ein Proxy oder ein VPN? Beide haben ihre Stärken und Schwächen und liefern bei korrekter Anwendung und im passenden Anwendungsfall hervorragende Ergebnisse. Da wir uns in diesem Artikel speziell auf die Puppeteer-Automatisierung konzentrieren, wollen wir untersuchen, welches Werkzeug besser zu Puppeteer-Workflows passt.

Aus Sicht des Nutzers sind VPNs und Proxys recht ähnlich – beide verbergen Ihre IP-Adresse, indem sie Ihnen eine neue zuweisen. Doch damit enden die Gemeinsamkeiten auch schon. Ein VPN leitet den gesamten Datenverkehr von Ihrem Gerät über einen verschlüsselten Tunnel weiter, um Sie mit dem Server des Anbieters zu verbinden. Von dort aus können Sie nach Belieben im gesamten Internet surfen.

Proxys hingegen verbergen Ihre IP-Adresse jeweils nur vor einer einzigen Website oder Anwendung (derjenigen, mit der Sie eine Verbindung herstellen), während die Verschlüsselung vom gewählten Protokoll bestimmt wird – HTTP bietet keine Verschlüsselung, HTTPS wird für eine grundlegende Verschlüsselung verwendet und SOCKS5 für maximale Verschlüsselung.

Warum ist das von Bedeutung?

Diese beiden Hauptunterschiede zeichnen die Umgehungstools in der Praxis am deutlichsten aus. Dank ihrer Verschlüsselung eignet sich ein VPN hervorragend für den Schutz der Privatsphäre und die Anonymität im Internet, während Proxys aufgrund ihres geringeren Overheads hohe Geschwindigkeiten gewährleisten und gleichzeitig enorme Mengen an Nutzerdatenverkehr verarbeiten können. Da ein VPN Ihren gesamten Datenverkehr umleitet, kann es Ihnen zudem jeweils nur eine IP-Adresse zur Verfügung stellen, während Proxys so viele gleichzeitige Verbindungen bieten, wie Sie wünschen.

Hier finden Sie eine Vergleichstabelle zur besseren Veranschaulichung:

Obwohl VPNs potenziell in Ihr Puppeteer-Skript integriert werden können, ist das Ergebnis dieses Vorhabens alles andere als ideal. Mit anderen Worten: VPNs eignen sich besser für das individuelle Surfen, während Proxys speziell für Automatisierung, Web-Scraping, Tests und die Datenerfassung in großem Maßstab konzipiert sind.

So verwenden Sie einen Proxy in Puppeteer: Grundlegende Einrichtung mit Floppydata

Kommen wir nun zum Abschnitt des Artikels über die Proxy-Konfiguration und die Integration in Puppeteer. Zur Unterstützung bei der Einrichtung und der Demonstration des Proxys werde ich Floppydata verwenden.

Floppydata ist bereits seit einiger Zeit mein bevorzugter Proxy-Anbieter. Der Dienst gewährleistet eine konstante Verfügbarkeit von 99,99 % und hohe Vertrauenswerte und bietet somit eine unterbrechungsfreie Verbindung für jede automatisierte Pipeline. Neben der hervorragenden Leistung bietet Floppydata einen der besten Preise auf dem Markt – nur 1 $/GB für rotierende IP-Adressen und 5 $/IP für ISP-Proxys. Damit eignet sich der Dienst ideal für Nutzer, die groß angelegte oder datenintensive Vorgänge ausführen und dabei auf ihr Budget achten müssen.

Der erste Schritt zur Integration von Proxys in Ihr Puppeteer-Skript besteht darin, einen Proxy zu erwerben. Mit Floppydata ist dies mit nur wenigen Klicks erledigt.

Nach der Anmeldung gelangen Sie zum Dashboard von Floppydata. Wählen Sie zunächst einen geeigneten Tarif aus und fahren Sie mit der Zahlung fort. Für automatisierte Workflows empfehle ich den Tarif „Rotating Proxy“, der drei Arten von IP-Adressen (Privathaushalte, Mobilfunk und Rechenzentren) umfasst, zwischen denen Sie nach Belieben wechseln können.

Die nächsten Schritte könnten nicht einfacher sein – selbst wenn Sie sich mit Proxy-Diensten nicht besonders gut auskennen, sorgt die übersichtliche Benutzeroberfläche von Floppydata dafür, dass Sie sich nicht verirren.

Navigieren Sie in der linken Seitenleiste zur Registerkarte „Get proxy credentials“ (Proxy-Anmeldedaten abrufen). Dort erhalten Sie einen Benutzernamen und ein zugehöriges Passwort für Ihr Konto; für die Zwecke dieser Demonstration erstellen wir jedoch ein spezielles Profil für Puppeteer – dadurch wird ein neuer Proxy mit bereits integrierter Authentifizierung generiert. Wie Sie sehen können, können Sie beliebig viele separate Unterbenutzer anlegen, was die weitere Verwaltung erheblich vereinfacht.

Wählen Sie anschließend einfach die gewünschten Parameter aus den angezeigten Dropdown-Listen aus. Während Sie die Angaben eingeben, werden diese gleichzeitig in die Proxy-Zeichenkette eingebettet. Sobald Sie mit den Parametern zufrieden sind, können Sie einfach einen Codeausschnitt oder die Proxy-Zeichenkette kopieren.

In dieser Demo konzentrieren wir uns darauf, wie die Grundeinrichtung mit einer Proxy-Zeichenkette funktioniert. Hier finden Sie einen Codeausschnitt für eine Proxy-Integration:

Puppeteer-Proxy mit Authentifizierung – Methode „page.authenticate“

Installation:

npm install puppeteer

Grundlegende Einrichtung:

const puppeteer = require('puppeteer');

(async () => {
    const PROXY_USER = 'user123-type-residential-country-US-session-pup01';
    const PROXY_PASS = 'your_password';
    const PROXY_SERVER = 'geo.g-w.info:10080';

    const browser = await puppeteer.launch({
        args: [`--proxy-server=${PROXY_SERVER}`]
    });

    const page = await browser.newPage();

    // Authenticate
    await page.authenticate({
        username: PROXY_USER,
        password: PROXY_PASS
    });

    // Navigate
    await page.goto('https://httpbin.org/ip');

    const content = await page.content();
    console.log(content);

    await browser.close();
})();

Sobald der Code eingerichtet ist, kopieren Sie einfach Ihre Proxy-Anmeldedaten aus dem Floppydata-Dashboard und fügen Sie sie an den entsprechenden Stellen ein – Ihren Benutzernamen (die gesamte Zeichenfolge, die wir im obigen GIF kopiert haben) in das Feld „ PROXY_USER “ und Ihr Passwort in das Feld „ PROXY_PASS “. PROXY_SERVER folgt einem einfachen hostname:port Format, wobei der Hostname „geo.g-w.info“ lautet und die Portbereiche durch das gewählte Protokoll definiert sind – 10080 für HTTP, 10443 für HTTPS und 10800 für SOCKS5.

Diese Methode umfasst auch die native Authentifizierung und unterstützt sowohl HTTP als auch HTTPS – geben Sie Ihren Benutzernamen und Ihr Passwort unter page.authenticate ein, um Ihren Proxy sofort mit der Authentifizierung zu integrieren; es sind keine zusätzlichen Einstellungen und keine neuen Seiten erforderlich.

Proxy-Ketten-Authentifizierung

Eine weitere Methode der Proxy-Authentifizierung, die hauptsächlich für benutzerdefinierte Fehlermeldungen, benutzerdefinierte Antworten und die Erfassung von Verkehrsstatistiken verwendet wird – oder wenn Sie Anmeldedaten direkt in die Proxy-URL einbetten müssen –, ist das npm-Paket „ proxy-chain “. Der entscheidende Bestandteil dieser Methode ist „ anonymizeProxy(proxy) “, das einen lokalen Proxy-Server startet.

Installieren:

npm install proxy-chain

Einrichtung:

const puppeteer = require('puppeteer');
const proxyChain = require('proxy-chain');

const PROXY_SERVER = 'geo.g-w.info:10080';
const PROXY_USER = 'user123-type-residential-country-US-session-pup01';
const PROXY_PASS = 'your_password';

(async () => {
    const proxy = `http://${PROXY_USER}:${PROXY_PASS}@${PROXY_SERVER}`;

    const anonymizedProxy = await proxyChain.anonymizeProxy(proxy);

    const browser = await puppeteer.launch({
        args: [`--proxy-server=${anonymizedProxy}`],
    });

    const page = await browser.newPage();
    await page.goto('https://httpbin.org/ip');
    await page.screenshot({ path: 'example2.png' });

    await browser.close();
    await proxyChain.closeAnonymizedProxy(anonymizedProxy, true);
})();

Für diese Methode benötigen Sie dieselben Anmeldedaten wie zuvor sowie Ihre Proxy-URL im folgenden Format: Protocol://Username:Password@Hostname:Port. Eine gebrauchsfertige Zeichenfolge finden Sie im Dashboard von Floppydata direkt unter der Proxy-Konfiguration – klicken Sie auf „Proxy-Zeichenfolgen“, dann auf „Als Liste“ und wählen Sie das gewünschte Format aus der Dropdown-Liste aus.

Einsatz von Proxys mit Puppeteer im großen Maßstab: Best Practices für die Integration von Puppeteer-Proxys

Sobald Ihre grundlegende Proxy-Konfiguration funktioniert, können Sie damit fortfahren, Ihre Pipeline für die Produktion zu erweitern. Hier reicht ein einzelner statischer Proxy nicht aus. Sehen wir uns daher an, wie Sie einen rotierenden Proxy-Pool in Puppeteer einrichten.

Zufällige Rotation

Installieren:

npm install puppeteer

Einrichtung:

const puppeteer = require('puppeteer');

const PROXY_PASS = 'your_password';
const PROXY_SERVER = 'geo.g-w.info:10080';
const PROXY_POOL = [
    'user123-type-residential-country-US-session-pup01',
    'user123-type-residential-country-US-session-pup02',
    'user123-type-residential-country-US-session-pup03',
    'user123-type-residential-country-US-session-pup04',
];
const getRandomProxy = () => PROXY_POOL[Math.floor(Math.random() * PROXY_POOL.length)];

const urls = [
    'https://httpbin.org/ip',
    'https://httpbin.org/ip',
    'https://httpbin.org/ip',
];

(async () => {
    for (const url of urls) {
        const PROXY_USER = getRandomProxy();

        const browser = await puppeteer.launch({
            args: [`--proxy-server=${PROXY_SERVER}`]
        });

        const page = await browser.newPage();

        await page.authenticate({
            username: PROXY_USER,
            password: PROXY_PASS
        });

        await page.goto(url);
        const content = await page.content();
        console.log(`Request via ${PROXY_USER}:`, content);

        await browser.close();
    }
})();

Wie Sie sehen können, besteht der Hauptunterschied darin, dass wir anstelle von „ PROXY_USER “ nun „ PROXY_POOL “ verwenden. Gleichzeitig fügen wir über „ Math.floor(Math.random() * PROXY_POOL.length) “ eine Logik für die zufällige Rotation hinzu.

Sequentielle Drehung

Installieren:

npm install puppeteer

Einrichtung:

const puppeteer = require('puppeteer');

const PROXY_PASS = 'your_password';
const PROXY_SERVER = 'geo.g-w.info:10080';
const PROXY_POOL = [
    'user123-type-residential-country-US-session-pup01',
    'user123-type-residential-country-US-session-pup02',
    'user123-type-residential-country-US-session-pup03',
    'user123-type-residential-country-US-session-pup04',
];

let proxyIndex = 0;
const getNextProxy = () => {
    const proxy = PROXY_POOL[proxyIndex % PROXY_POOL.length];
    proxyIndex++;
    return proxy;
};

const urls = [
    'https://httpbin.org/ip',
    'https://httpbin.org/ip',
    'https://httpbin.org/ip',
];

(async () => {
    for (const url of urls) {
        const PROXY_USER = getNextProxy();

        const browser = await puppeteer.launch({
            args: [`--proxy-server=${PROXY_SERVER}`]
        });

        const page = await browser.newPage();

        await page.authenticate({
            username: PROXY_USER,
            password: PROXY_PASS
        });

        await page.goto(url);
        const content = await page.content();
        console.log(`Request via ${PROXY_USER}:`, content);

        await browser.close();
    }
})();

Hier verwenden wir eine Funktion „ getNextProxy() “, die einen Zähler „ proxyIndex “ mit einem Modulo-Operator (%) nutzt, um den Pool der Reihe nach zu durchlaufen.

Puppeteer SOCKS-Proxy: Was Sie wissen müssen

das SOCKS-Protokoll (Socket Secure) sowie SOCKS5-Proxys Insbesondere arbeiten sie auf einer niedrigeren Netzwerkebene als HTTP/HTTPS-Proxys. Was sie von anderen Protokollen unterscheidet, ist die Fähigkeit, jede Art von Datenverkehr zu verarbeiten – vom normalen Surfen im Internet über E-Mails und Dateiübertragungen bis hin zu P2P-Verbindungen und Echtzeit-Datenströmen. Dies wird dadurch ermöglicht, dass das SOCKS-Protokoll Ihren Datenverkehr nicht wie HTTP-Proxys interpretiert oder filtert, sondern TCP- und UDP-Pakete einfach unverändert weiterleitet. Darüber hinaus bieten SOCKS5-Proxys das höchste Verschlüsselungsniveau, das die Proxy-Ebene selbst bereitstellen kann.

Im Zusammenhang mit Puppeteer bieten SOCKS5-Proxys einige deutliche Vorteile. Die Low-Level-Paketweiterleitung sorgt für weniger Fehler und eine geringere Latenz bei hoher Auslastung, was bei der Ausführung groß angelegter Scraping-Pipelines von großem Nutzen ist. Da Puppeteer über das normale Surfen im Internet hinaus eine Vielzahl von Aufgaben bewältigen kann – darunter die Verarbeitung von Medien, WebSocket-Verbindungen und Nicht-HTTP-Datenverkehr –, sind SOCKS5-Proxys die ideale Wahl, da sie mehrere Protokolle verarbeiten können und nicht allein auf den Webdatenverkehr beschränkt sind.

Allerdings gibt es einen Haken. Die Engine von Puppeteer, Chromium, unterstützt die SOCKS5-Proxy-Authentifizierung, die von den meisten kommerziellen Proxys – einschließlich Floppydata – verlangt wird, nicht von Haus aus. Der Versuch, die übliche Methode „ page.authenticate “ zu verwenden, führt höchstwahrscheinlich zu der Fehlermeldung „ ERR_NO_SUPPORTED_PROXIES “ oder dazu, dass der Browser auf eine direkte Verbindung zurückgreift, wodurch Ihre echte IP-Adresse offengelegt wird.

Dennoch lassen sich SOCKS5-IP-Adressen in Ihr Puppeteer-Skript integrieren und über die Methode „ proxy-chain “ authentifizieren. „ proxy-chain “ funktioniert hier, da es einen lokalen HTTP-Tunnel aufbaut, der die SOCKS5-Authentifizierung für Sie übernimmt; Chromium muss sich nie direkt damit befassen. Die Einrichtung sieht in diesem Fall etwas anders aus:

Installieren:

npm install proxy-chain

Einrichtung:

const puppeteer = require('puppeteer');
const proxyChain = require('proxy-chain');

const PROXY_USER = 'user123-type-residential-country-US-session-pup01';
const PROXY_PASS = 'your_password';
const PROXY_HOST = 'geo.g-w.info';
const PROXY_PORT = '10800';

(async () => {
    const proxy = `socks5://${PROXY_USER}:${PROXY_PASS}@${PROXY_HOST}:${PROXY_PORT}`;

    const anonymizedProxy = await proxyChain.anonymizeProxy(proxy);

    const browser = await puppeteer.launch({
        args: [`--proxy-server=${anonymizedProxy}`],
    });

    const page = await browser.newPage();
    await page.goto('https://httpbin.org/ip');
    const content = await page.content();
    console.log(content);

    await browser.close();
    await proxyChain.closeAnonymizedProxy(anonymizedProxy, true);
})();

Bitte beachten Sie, dass sich in diesem Fall PROXY_PORT für das SOCKS5-Protokoll in 10800 ändert und die Proxy-Adresse selbst mit socks5:// beginnt, nicht mit http://.

Fazit

Proxys sind ein wesentlicher Bestandteil jeder seriösen Puppeteer-Automatisierungsumgebung. In diesem Leitfaden haben wir die wichtigsten Gründe für deren Einsatz erläutert, sie mit VPNs verglichen und alle wesentlichen Integrationsmethoden durchgesprochen – von der Basisauthentifizierung über rotierende Pools bis hin zur SOCKS5-Konfiguration mit Proxy-Chain. Mit einem zuverlässigen Anbieter wie Floppydata und der richtigen Konfiguration für Ihren Anwendungsfall verfügen Sie über eine ausfallsichere, skalierbare Pipeline, die alle Anforderungen Ihres Workflows bewältigen kann.