Skip to content
Advanced / 5 min read

Fortgeschrittenes Web Scraping mit Dataimpulse Residential Proxies und Puppeteer unter Windows

Erfahren Sie, wie Sie Dataimpulse rotierende Residential-Proxies mit Puppeteer unter Windows für umfangreiches, fortgeschrittenes Web Scraping integrieren. Dieser Leitfaden behandelt Einrichtung, Authentifizierung, Proxy-Rotation und Umgang mit Parallelität.

Windows HTTP(S) Web Scraping

Überblick

Puppeteer ist eine leistungsstarke Node.js-Bibliothek zur Steuerung von Headless Chrome. In Kombination mit den rotierenden Residential-Proxies von Dataimpulse können Sie große Websites scrapen, ohne blockiert zu werden. Dieses Tutorial zeigt Ihnen, wie Sie Puppeteer unter Windows einrichten, um Dataimpulse Residential-Proxies zu verwenden, Authentifizierung zu handhaben und eine effiziente Rotation für hochvolumiges Scraping zu implementieren.

Voraussetzungen

  • Windows 10 oder neuer.
  • Node.js 14+ installiert (Download von der offiziellen Node.js-Website).
  • Ein Dataimpulse-Konto mit Residential-Proxy-Anmeldedaten (Benutzername, Passwort, Endpunkt).
  • Grundkenntnisse in JavaScript und async/await.

Schritt 1: Node.js und Puppeteer installieren

Wenn Sie dies noch nicht getan haben, installieren Sie Node.js von der offiziellen Website. Erstellen Sie dann einen neuen Projektordner und installieren Sie Puppeteer.

mkdir dataimpulse-puppeteer
cd dataimpulse-puppeteer
npm init -y
npm install puppeteer

Schritt 2: Dataimpulse-Proxy-Anmeldedaten erhalten

Melden Sie sich bei Ihrem Dataimpulse-Dashboard an und navigieren Sie zum Bereich für Residential-Proxies. Sie finden:

  • Endpunkt: einen Host und Port, z. B. proxy.dataimpulse.com:12321 (prüfen Sie Ihr Dashboard für die genauen Details).
  • Benutzername: Ihren Dataimpulse-Benutzernamen.
  • Passwort: Ihr Dataimpulse-Passwort.

Dataimpulse verwendet ein rotierendes Gateway, sodass jede Anfrage über diesen Endpunkt eine andere IP aus dem Pool verwendet (es sei denn, Sie verwenden Ports für Sticky Sessions). Für dieses Tutorial verwenden wir den rotierenden Endpunkt.

Schritt 3: Puppeteer mit Proxy-Authentifizierung konfigurieren

Puppeteer kann einen Proxy verwenden, indem beim Starten des Browsers das Argument --proxy-server übergeben wird. Die Authentifizierung wird über page.authenticate() abgewickelt. Erstellen Sie eine Datei scrape.js:

const puppeteer = require('puppeteer');

const PROXY_HOST = 'YOUR_ENDPOINT_HOST'; // Ersetzen Sie dies durch Ihren Dataimpulse-Proxy-Host
const PROXY_PORT = 'YOUR_ENDPOINT_PORT'; // Ersetzen Sie dies durch Ihren Dataimpulse-Proxy-Port
const PROXY_USER = 'your_username';
const PROXY_PASS = 'your_password';

(async () => {
  const browser = await puppeteer.launch({
    headless: true,
    args: [`--proxy-server=http://${PROXY_HOST}:${PROXY_PORT}`],
  });

  const page = await browser.newPage();
  await page.authenticate({ username: PROXY_USER, password: PROXY_PASS });

  await page.goto('https://httpbin.org/ip', { waitUntil: 'networkidle0' });
  const content = await page.content();
  console.log(content); // Sollte die Proxy-IP anzeigen

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

Führen Sie das Skript mit node scrape.js aus. Sie sollten eine IP-Adresse sehen, die nicht Ihre eigene ist, was bestätigt, dass der Proxy funktioniert.

Schritt 4: Logik für rotierende Proxies implementieren

Da der Endpunkt von Dataimpulse IPs automatisch rotiert, können Sie mehrere Anfragen über dieselbe Browserinstanz stellen, und jede verwendet eine andere IP. Für eine bessere Kontrolle und zur Vermeidung von Erkennung können Sie den Browser jedoch schließen und neu öffnen oder Inkognito-Kontexte verwenden. Hier ist ein Beispiel, das mehrere Seiten mit Rotation scrapt:

const puppeteer = require('puppeteer');

const PROXY_HOST = 'YOUR_ENDPOINT_HOST';
const PROXY_PORT = 'YOUR_ENDPOINT_PORT';
const PROXY_USER = 'your_username';
const PROXY_PASS = 'your_password';

async function scrapeWithRotation(urls) {
  const browser = await puppeteer.launch({
    headless: true,
    args: [`--proxy-server=http://${PROXY_HOST}:${PROXY_PORT}`],
  });

  const results = [];
  for (const url of urls) {
    const page = await browser.newPage();
    await page.authenticate({ username: PROXY_USER, password: PROXY_PASS });
    try {
      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
      const title = await page.title();
      results.push({ url, title });
    } catch (error) {
      console.error(`Error scraping ${url}:`, error.message);
    } finally {
      await page.close();
    }
  }

  await browser.close();
  return results;
}

const urls = [
  'https://example.com',
  'https://example.org',
  'https://example.net',
];

scrapeWithRotation(urls).then(console.log);

Jede neue Seite verwendet eine rotierende IP aus dem Pool von Dataimpulse.

Schritt 5: Umgang mit Parallelität und Fehlerbehandlung

Für hochvolumiges Scraping müssen Sie Parallelität und Fehler elegant handhaben. Verwenden Sie puppeteer-cluster, um mehrere Seiten parallel zu verwalten und dabei Speichergrenzen zu respektieren.

npm install puppeteer-cluster

const { Cluster } = require('puppeteer-cluster');

const PROXY_HOST = 'YOUR_ENDPOINT_HOST';
const PROXY_PORT = 'YOUR_ENDPOINT_PORT';
const PROXY_USER = 'your_username';
const PROXY_PASS = 'your_password';

(async () => {
  const cluster = await Cluster.launch({
    concurrency: Cluster.CONCURRENCY_PAGE,
    maxConcurrency: 5, // Anpassen basierend auf Ihren Ressourcen
    puppeteerOptions: {
      headless: true,
      args: [`--proxy-server=http://${PROXY_HOST}:${PROXY_PORT}`],
    },
  });

  cluster.on('taskerror', (err, data) => {
    console.error(`Error scraping ${data}:`, err.message);
  });

  await cluster.task(async ({ page, data: url }) => {
    await page.authenticate({ username: PROXY_USER, password: PROXY_PASS });
    await page.goto(url, { waitUntil: 'domcontentloaded' });
    const title = await page.title();
    console.log(`Scraped ${url} - Title: ${title}`);
  });

  const urls = [
    'https://example.com',
    'https://example.org',
    'https://example.net',
    // Weitere URLs hinzufügen
  ];

  for (const url of urls) {
    cluster.queue(url);
  }

  await cluster.idle();
  await cluster.close();
})();

Dieses Setup ermöglicht es Ihnen, mehrere Seiten gleichzeitig zu scrapen und dabei die rotierenden Proxies von Dataimpulse zu nutzen.

Schritt 6: Testen und Validieren

Führen Sie Ihr Skript aus und überprüfen Sie, dass:

  • Die IP-Adresse sich zwischen Anfragen ändert (prüfen Sie mit https://httpbin.org/ip).
  • Keine Proxy-Authentifizierungsfehler auftreten.
  • Die Zielseiten korrekt geladen werden.

Sie können auch die für jede Anfrage verwendete IP protokollieren, um sicherzustellen, dass die Rotation funktioniert.

Fehlerbehebung

  • 407 Proxy Authentication Required: Überprüfen Sie Ihren Benutzernamen und Ihr Passwort. Stellen Sie sicher, dass Sie die richtige Authentifizierungsmethode verwenden (page.authenticate()).
  • Verbindungszeitüberschreitungen: Erhöhen Sie die Option timeout in page.goto(). Stellen Sie außerdem sicher, dass Ihr Proxy-Endpunkt und Port korrekt sind.
  • Browserstart schlägt mit Proxy-Fehler fehl: Stellen Sie sicher, dass das Argument --proxy-server das richtige Format verwendet: http://host:port (ohne Anmeldedaten in der URL).
  • Rotation funktioniert nicht: Der rotierende Endpunkt von Dataimpulse sollte für jede neue Verbindung eine neue IP bereitstellen. Wenn Sie Sticky Sessions benötigen, verwenden Sie den dedizierten Sticky-Port, der in Ihrem Dashboard angegeben ist.

Zusammenfassung

Sie haben gelernt, wie Sie Dataimpulse Residential-Proxies mit Puppeteer unter Windows für fortgeschrittenes Web Scraping integrieren. Durch die Nutzung der Proxy-Authentifizierung von Puppeteer und des rotierenden IP-Pools von Dataimpulse können Sie skalierbare Scraper erstellen, die IP-Blocks vermeiden. Denken Sie daran, Fehler zu behandeln, Parallelität zu verwalten und die Nutzungsbedingungen der Website zu respektieren.