Proxy-Konfiguration in Puppeteer: Authentifizierung, Rotation und Umgehungstechniken

Proxys sind für die Puppeteer-Automatisierung unverzichtbar. Sie verbergen Ihre IP-Adresse, umgehen geografische Beschränkungen und helfen dabei, Sperren zu vermeiden. Das erfahren Sie über die Nutzung von Proxys in Puppeteer:

1. Proxys einrichten: Fügen Sie Proxys zu Ihrem Browser hinzu und authentifizieren Sie sie unkompliziert.
2. Proxys rotieren: Verteilen Sie Anfragen auf mehrere IP-Adressen, um eine Erkennung zu vermeiden.
3. Fehler behandeln: Wiederholen Sie Anfragen, verwalten Sie Sperren und wechseln Sie Proxys bei Bedarf.
4. Geschwindigkeit optimieren: Blockieren Sie unnötige Ressourcen und rotieren Sie User Agents für schnelleres und unauffälligeres Scraping.

Schneller Vergleich der Proxy-Typen

Puppeteer-Proxy-Integration mit Bright Data – vollständiges Tutorial 2024

Grundlegende Proxy-Einrichtung

Die Einrichtung eines Proxys ist ein wichtiger Schritt, um Ihre Puppeteer-Automatisierung zu optimieren. So können Sie starten.

Einen Proxy-Server hinzufügen

Sie können einen Proxy-Server beim Browserstart in Puppeteer wie folgt konfigurieren:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://157.230.255.230:8118']
});
const page = await browser.newPage();

Es ist außerdem wichtig, Fehler bei der Navigation über einen Proxy zu behandeln:

try {
    await page.goto('https://books.toscrape.com/', {
        timeout: 70000,
        waitUntil: 'networkidle2'
    });
} catch (err) {
    console.log(err);
}

Als Nächstes sollten Sie Ihre Verbindung durch die Einrichtung einer Proxy-Authentifizierung absichern.

Schritte zur Proxy-Authentifizierung

Wenn Ihr Proxy eine Authentifizierung erfordert, können Sie die folgende Methode verwenden:

await page.authenticate({
    username: 'your_proxy_username',
    password: 'your_proxy_password'
});

Hier ist ein schneller Vergleich verschiedener Authentifizierungsmethoden:

Sobald Sie Ihren Proxy und die Authentifizierung eingerichtet haben, ist es Zeit für einen Test.

Proxy-Einstellungen testen

Stellen Sie mit den folgenden Schritten sicher, dass Ihr Proxy funktioniert:

• Testen Sie die Verbindung mit einer Beispiel-URL.
• Bestätigen Sie, dass die IP-Adresse des Proxys verwendet wird.
• Überwachen Sie die Leistung der Einrichtung.

Hier ist ein Beispielskript zum Testen Ihres Proxys:

async function testProxy() {
    const browser = await puppeteer.launch({
        args: ['--proxy-server=http://157.230.255.230:8118']
    });
    const page = await browser.newPage();
    try {
        await page.goto('https://books.toscrape.com/', {
            timeout: 70000,
            waitUntil: 'networkidle2'
        });
        const content = await page.content();
        console.log('Proxy connection successful');
    } catch (err) {
        console.log('Proxy connection failed:', err);
    }
    await browser.close();
}

Durch Tests stellen Sie sicher, dass Ihre Proxy-Konfiguration für den Einsatz in Ihren Automatisierungsaufgaben bereit ist.

Methoden zur Proxy-Rotation

Die Verwaltung der Proxy-Rotation ist entscheidend, um IP-Sperren zu verhindern und Rate Limits beim Scraping oder bei der Online-Automatisierung von Aufgaben zu vermeiden.

Eine Proxy-Liste erstellen

Erstellen Sie zunächst eine Liste von Proxys, die effizient rotiert werden können. Hier ist ein Beispiel dafür, wie Sie einen Proxy-Pool einrichten und verwenden:

const proxyList = [
    {
        host: '157.230.255.230',
        port: '8118',
        username: 'user1',
        password: 'pass1'
    },
    // Add more proxy configurations
];

function getRandomProxy() {
    return proxyList[Math.floor(Math.random() * proxyList.length)];
}

Bei der Einrichtung Ihrer Proxy-Liste ist es wichtig, die verschiedenen Proxy-Typen und ihre Kompromisse zu verstehen:

Jeder Typ hat seine Stärken und Schwächen. Wählen Sie daher anhand Ihrer konkreten Anforderungen, etwa Geschwindigkeit, Zuverlässigkeit oder Budget.

Proxys zwischen Anfragen wechseln

Um Proxys automatisch zu rotieren, können Sie die folgende Einrichtung verwenden:

const ProxyChain = require('proxy-chain');

const server = new ProxyChain.Server({
    port: 8080,
    prepareRequestFunction: ({ request }) => {
        const proxy = getRandomProxy();
        return {
            upstreamProxyUrl: `http://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`
        };
    }
});

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://localhost:8080']
});

Dieser Ansatz stellt sicher, dass jede Anfrage über einen anderen Proxy geleitet wird, ohne den Browser neu starten zu müssen. Das macht den Prozess effizienter.

Richtlinien für die Proxy-Rotation

Hier sind einige zentrale Maßnahmen zur Verbesserung Ihrer Proxy-Rotationsstrategie:

1. Timing-Strategie

Fügen Sie zufällige Verzögerungen zwischen Anfragen ein, um natürliches Surfverhalten zu simulieren:

function getRotationDelay() {
    // Random delay between 2-5 seconds
    return Math.floor(Math.random() * 3000) + 2000;
}

async function rotateProxy() {
    await new Promise(resolve => setTimeout(resolve, getRotationDelay()));
    const proxy = getRandomProxy();
    // Apply new proxy configuration
}

2. Fehlerbehandlung

Wenn ein Proxy ausfällt, behandeln Sie den Fehler sauber, indem Sie zu einem neuen Proxy wechseln und die Anfrage wiederholen:

async function handleProxyError(error, page) {
    console.log(`Proxy error: ${error.message}`);
    await rotateProxy();
    return page.reload({ waitUntil: 'networkidle2' });
}

3. Sitzungsverwaltung

Verwenden Sie für Aufgaben, die eine konsistente Sitzung erfordern, denselben Proxy für zusammenhängende Anfragen:

const sessionMap = new Map();

function getProxyForSession(sessionId) {
    if (!sessionMap.has(sessionId)) {
        sessionMap.set(sessionId, getRandomProxy());
    }
    return sessionMap.get(sessionId);
}

Mit diesen Strategien können Sie Proxys effizient verwalten und sich auf fortgeschrittenere Herausforderungen wie Sperren, CAPTCHAs und andere Hindernisse vorbereiten.

sbb-itb-23997f1

Erweiterte Proxy-Techniken

Residential- vs. Datacenter-Proxys

Die Auswahl des richtigen Proxys ist bei der Arbeit mit Puppeteer-Automatisierung entscheidend. Dieser Vergleich hilft Ihnen bei der Entscheidung:

Residential-Proxys sind eine gute Wahl für Aufgaben, die hohe Anonymität erfordern, da sie echter Nutzeraktivität stark ähneln [1].

Sperren und CAPTCHAs behandeln

Um Website-Sperren und CAPTCHA-Herausforderungen zu bewältigen, nutzen Sie Proxy-Rotation und Wiederholungsmechanismen. Hier ist ein Beispiel dafür, wie Sie diese Probleme verwalten können:

const proxyManager = {
    rotationDelay: 2000,
    async handleBlock(page) {
        await page.waitForTimeout(this.rotationDelay);
        const newProxy = await this.getNextProxy();
        await page.authenticate(newProxy);
        return page.reload({ waitUntil: 'networkidle0' });
    },
    async detectBlock(response) {
        return response.status() === 403 || response.status() === 429;
    }
};

Wenn eine Sperre erkannt wird, kann ein erneuter Versuch mit einem neuen Proxy dafür sorgen, dass Ihre Automatisierung reibungslos weiterläuft:

page.on('response', async (response) => {
    if (await proxyManager.detectBlock(response)) {
        await proxyManager.handleBlock(page);
    }
});

Diese Strategien helfen dabei, die Kontinuität Ihres Workflows auch bei auftretenden Herausforderungen aufrechtzuerhalten.

Proxy-Fehler verwalten

Für eine effektive Behandlung von Proxy-Fehlern sind Anpassungen von Timeouts, Validierungsprüfungen und Backup-Proxys erforderlich. Zum Beispiel:

async function handleProxyError(error, page) {
    if (error.message.includes('net::ERR_PROXY_CONNECTION_FAILED')) {
        const newProxy = await getBackupProxy();
        await page.authenticate(newProxy);
        await page.setExtraHTTPHeaders({
            'User-Agent': generateRandomUserAgent()
        });
        return page.reload({ waitUntil: 'networkidle2' });
    }
}

Befolgen Sie diese Richtlinien für ein besseres Fehlermanagement:

• Legen Sie Verbindungs-Timeouts fest, um lange Wartezeiten zu vermeiden.
• Überwachen Sie die Proxy-Leistung kontinuierlich.
• Halten Sie einen Pool von Backup-Proxys bereit.

Auch die korrekte Konfiguration Ihres Browsers trägt zu einer reibungslosen Leistung bei:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://proxy-server:port'],
    timeout: 60000,
    waitUntil: 'networkidle0'
});

Validieren Sie Ihre Proxys abschließend immer, um sicherzustellen, dass sie funktionieren:

async function validateProxy(proxyConfig) {
    try {
        const response = await fetch('https://api.ipify.org?format=json', {
            proxy: `http://${proxyConfig.host}:${proxyConfig.port}`
        });
        return response.ok;
    } catch (error) {
        console.error(`Proxy validation failed: ${error.message}`);
        return false;
    }
}

Tipps zur Proxy-Performance

Möchten Sie Puppeteer optimal nutzen? Mit diesen Tipps können Sie Ihre Proxy-Einrichtung gezielt verbessern und die Gesamtleistung steigern.

Geschwindigkeitstests und Optimierung

Reduzieren Sie Ladezeiten, indem Sie unnötige Anfragen wie Bilder, Schriftarten und Stylesheets blockieren:

await page.setRequestInterception(true);
page.on('request', (req) => {
    if (req.resourceType() === 'stylesheet' || req.resourceType() === 'font' || req.resourceType() === 'image') {
        req.abort();
    } else {
        req.continue();
    }
});

Kombinieren Sie page.goto mit page.waitForSelector für eine schnellere Navigation:

await page.goto(url, {
    timeout: 30000,
    waitUntil: 'domcontentloaded'
});
await page.waitForSelector('.main-content');

„Bei der Optimierung von Puppeteer sollten Sie bedenken, dass es nur begrenzte Möglichkeiten gibt, die Start- und Beendigungsleistung von Puppeteer selbst zu beschleunigen. Die größten Verbesserungen werden höchstwahrscheinlich dadurch erzielt, dass Ihre Zielseiten schneller gerendert werden.“ – Jon Yongfook, Gründer von Bannerbear [3]

Proxy-Lastverteilung

Verteilen Sie den Traffic mit Puppeteer Cluster auf mehrere Proxys:

const proxyCluster = {
    async distributeLoad(urls, proxyList) {
        const cluster = await Cluster.launch({
            concurrency: Cluster.CONCURRENCY_CONTEXT,
            maxConcurrency: 5
        });

        await cluster.task(async ({ page, data: url }) => {
            const proxy = proxyList.getNext();
            await page.authenticate(proxy);
            await page.goto(url);
        });
    }
};

Dieser Ansatz verteilt den Traffic ausgewogen auf Proxys und ergänzt die zuvor genannten Rotationsmethoden, um eine Überlastung einzelner Proxys zu vermeiden.

Häufige Probleme und Lösungen

Hier sind einige häufige Herausforderungen und wie Sie sie effektiv behandeln:

• Netzwerklatenz Verwenden Sie den folgenden Code, um Timeouts zu verwalten und unnötige Verzögerungen zu vermeiden:

  const performRequest = async (page, url) => {
      try {
          await page.goto(url, {
              timeout: 30000,
              waitUntil: 'networkidle2'
          });
      } catch (error) {
          if (error.name === 'TimeoutError') {
              await page.evaluate(() => window.stop());
              return handleTimeout();
          }
          throw error;
      }
  };
  

• Rate Limiting Erkennen Sie Rate Limits und reagieren Sie mit diesem Codeausschnitt darauf:

  const checkRateLimit = async (response) => {
      if (response.status() === 429 || response.headers()['retry-after']) {
          await handleRateLimit(response.headers()['retry-after']);
      }
  };
  

• Authentifizierungsfehler Behandeln Sie Fehler bei der Proxy-Authentifizierung, indem Sie es mit neuen Zugangsdaten erneut versuchen:

  const handleAuthError = async (response, page, proxy) => {
      if (response.status() === 407) {
          await retryWithNewCredentials(page, proxy);
          return true;
      }
      return false;
  };
  

„Durch die Optimierung Ihres Puppeteer-Skripts können Sie einen reibungslosen und effizienten Betrieb mit präzisen und konsistenten Ergebnissen sicherstellen.“ – ScrapeOps [2]

Behalten Sie Antwortzeiten und Erfolgsraten im Blick, damit Ihre Proxys effizient und unerkannt bleiben.

Fazit

Wichtige Konfigurationsmethoden

Die Einrichtung von Puppeteer mit Proxys umfasst einige wichtige Schritte. Verwenden Sie für private Proxys die Funktion authenticate, um Zugangsdaten bereitzustellen:

await page.authenticate({
    username: 'proxyUser',
    password: 'proxyPass'
});

Damit die Seite vollständig geladen wird, verwenden Sie die Option waitUntil (z. B. 'networkidle2') und setzen Sie ein Timeout (z. B. 30 Sekunden):

await page.goto(url, {
    waitUntil: 'networkidle2',
    timeout: 30000
});

Diese Konfigurationen bilden die Grundlage für eine zuverlässige Proxy-Einrichtung.

Best Practices

Befolgen Sie diese Strategien, um sichere und effiziente Proxy-Abläufe aufrechtzuerhalten:

Verbindungsmanagement

• Passen Sie Timeouts an die Proxy-Geschwindigkeit an.
• Behandeln Sie Authentifizierungsfehler effektiv.
• Überwachen Sie Leistungskennzahlen, um Engpässe zu identifizieren.

Sicherheitsoptimierung

• Rotieren Sie User Agents zusammen mit Proxys, um eine Erkennung zu vermeiden.
• Fügen Sie für zusätzlichen Schutz eine VPN-Ebene hinzu.
• Fangen Sie unnötige Anfragen ab und filtern Sie sie, um Bandbreite zu sparen.

Hier ist eine schnelle Zusammenfassung wichtiger Aspekte bei der Proxy-Implementierung: