Configuration de proxies dans Puppeteer : authentification, rotation et techniques de contournement

Les proxys sont essentiels à l’automatisation avec Puppeteer. Ils masquent votre adresse IP, contournent les restrictions géographiques et aident à éviter les blocages. Voici ce que vous apprendrez sur l’utilisation des proxys dans Puppeteer :

1. Configurer des proxys : ajoutez des proxys à votre navigateur et authentifiez-les facilement.
2. Faire tourner les proxys : répartissez les requêtes sur plusieurs adresses IP pour éviter la détection.
3. Gérer les erreurs : réessayez les requêtes, gérez les blocages et changez de proxy si nécessaire.
4. Optimiser la vitesse : bloquez les ressources inutiles et alternez les agents utilisateurs pour un scraping plus rapide et discret.

Comparaison rapide des types de proxys

Intégration de proxy Puppeteer avec Bright Data - Tutoriel complet 2024

Configuration de proxy de base

Configurer un proxy est une étape clé pour optimiser votre automatisation Puppeteer. Voici comment démarrer.

Ajouter un serveur proxy

Vous pouvez configurer un serveur proxy au lancement du navigateur dans Puppeteer comme suit :

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

Il est également important de gérer les erreurs lors de la navigation avec un proxy :

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

Ensuite, vous devrez sécuriser votre connexion en configurant l’authentification du proxy.

Étapes d’authentification du proxy

Si votre proxy requiert une authentification, vous pouvez utiliser la méthode suivante :

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

Voici une comparaison rapide des différentes méthodes d’authentification :

Une fois votre proxy et son authentification configurés, il est temps de les tester.

Tester les paramètres du proxy

Assurez-vous que votre proxy fonctionne en suivant ces étapes :

• Testez la connexion avec une URL d’exemple.
• Confirmez que l’adresse IP du proxy est utilisée.
• Surveillez les performances de la configuration.

Voici un script d’exemple pour tester votre proxy :

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();
}

Les tests garantissent que votre configuration proxy est prête à être utilisée dans vos tâches d’automatisation.

Méthodes de rotation des proxys

Gérer la rotation des proxys est essentiel pour éviter les bannissements d’IP et les limitations de débit lors du scraping ou de l’automatisation de tâches en ligne.

Créer une liste de proxys

Pour commencer, créez une liste de proxys pouvant être alternés efficacement. Voici un exemple de configuration et d’utilisation d’un pool de proxys :

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)];
}

Lors de la configuration de votre liste de proxys, il est important de comprendre les différents types de proxys et leurs compromis :

Chaque type présente ses forces et ses faiblesses ; choisissez donc selon vos besoins spécifiques, comme la vitesse, la fiabilité ou le budget.

Changer de proxy entre les requêtes

Pour alterner automatiquement les proxys, vous pouvez utiliser la configuration suivante :

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']
});

Cette approche garantit que chaque requête est acheminée via un proxy différent sans redémarrer le navigateur, ce qui rend le processus plus efficace.

Bonnes pratiques de rotation des proxys

Voici quelques pratiques clés pour améliorer votre stratégie de rotation des proxys :

1. Stratégie de temporisation

Introduisez des délais aléatoires entre les requêtes afin de simuler un comportement de navigation naturel :

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. Gestion des erreurs

Si un proxy échoue, gérez l’erreur correctement en passant à un nouveau proxy et en relançant la requête :

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

3. Gestion des sessions

Pour les tâches qui exigent une cohérence de session, utilisez le même proxy pour les requêtes associées :

const sessionMap = new Map();

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

Grâce à ces stratégies, vous pouvez gérer efficacement les proxys et vous préparer à des défis plus avancés, comme la gestion des blocages, des CAPTCHAs et d’autres obstacles.

sbb-itb-23997f1

Techniques avancées de proxy

Proxys résidentiels ou Datacenter

Choisir le bon proxy est essentiel lorsque vous travaillez avec l’automatisation Puppeteer. Voici une comparaison pour vous aider à décider :

Les proxys résidentiels sont un choix solide pour les tâches exigeant un anonymat élevé, car ils ressemblent étroitement à l’activité d’utilisateurs réels [1].

Gérer les blocages et les CAPTCHAs

Pour traiter les blocages de sites web et les défis CAPTCHA, utilisez des mécanismes de rotation des proxys et de nouvelle tentative. Voici un exemple de gestion de ces problèmes :

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;
    }
};

Lorsqu’un blocage est détecté, une nouvelle tentative avec un nouveau proxy peut permettre à votre automatisation de fonctionner sans interruption :

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

Ces stratégies aident à maintenir la continuité des workflows, même face à des difficultés.

Gérer les erreurs de proxy

La gestion efficace des erreurs de proxy exige des ajustements de délai d’expiration, des vérifications de validation et des proxys de secours. Par exemple :

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' });
    }
}

Suivez ces recommandations pour mieux gérer les erreurs :

• Définissez des délais de connexion pour éviter les attentes prolongées.
• Surveillez en continu les performances des proxys.
• Gardez un pool de proxys de secours prêt à l’emploi.

La configuration correcte de votre navigateur joue également un rôle dans des performances fluides :

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

Enfin, validez toujours vos proxys pour vous assurer qu’ils fonctionnent :

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;
    }
}

Conseils pour les performances des proxys

Vous souhaitez tirer le meilleur parti de Puppeteer ? Ces conseils peuvent vous aider à affiner votre configuration proxy et à améliorer les performances globales.

Tests de vitesse et optimisation

Réduisez les temps de chargement en bloquant les requêtes inutiles comme les images, les polices et les feuilles de style :

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

Associez page.goto à page.waitForSelector pour une navigation plus rapide :

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

« Lors de l’optimisation de Puppeteer, n’oubliez pas qu’il n’existe qu’un nombre limité de moyens d’accélérer les performances de démarrage et d’arrêt de Puppeteer lui-même. Les gains les plus importants viendront probablement d’un rendu plus rapide de vos pages cibles. »
– Jon Yongfook, fondateur de Bannerbear [3]

Répartition de la charge des proxys

Répartissez le trafic entre plusieurs proxys à l’aide de Puppeteer Cluster :

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);
        });
    }
};

Cette approche équilibre le trafic entre les proxys et complète les méthodes de rotation précédentes afin d’éviter de surcharger un seul proxy.

Problèmes fréquents et solutions

Voici quelques difficultés courantes et la manière de les gérer efficacement :

• Latence réseau Utilisez le code suivant pour gérer les délais d’expiration et éviter les retards inutiles :

  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;
      }
  };
  

• Limitation de débit Détectez les limites de débit et réagissez-y avec cet extrait :

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

• Échecs d’authentification Gérez les erreurs d’authentification du proxy en réessayant avec de nouveaux identifiants :

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

« En optimisant votre script Puppeteer, vous pouvez assurer un fonctionnement fluide et efficace avec des résultats précis et cohérents. »
– ScrapeOps [2]

Surveillez les temps de réponse et les taux de réussite afin de garantir que vos proxys restent efficaces et indétectés.

Conclusion

Méthodes de configuration clés

La configuration de Puppeteer avec des proxys implique quelques étapes importantes. Pour les proxys privés, utilisez la fonction authenticate afin de fournir les identifiants :

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

Pour vous assurer que la page se charge entièrement, utilisez l’option waitUntil (par exemple, 'networkidle2') et définissez un délai d’expiration (par exemple, 30 secondes) :

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

Ces configurations constituent la base d’une configuration proxy fiable.

Bonnes pratiques

Pour maintenir des opérations proxy sûres et efficaces, suivez ces stratégies :

Gestion des connexions

• Ajustez les délais d’expiration en fonction de la vitesse du proxy.
• Gérez efficacement les erreurs d’authentification.
• Surveillez les indicateurs de performance afin d’identifier les goulots d’étranglement.

Optimisation de la sécurité

• Alternez les agents utilisateurs avec les proxys pour éviter la détection.
• Ajoutez une couche VPN pour une protection supplémentaire.
• Interceptez et filtrez les requêtes inutiles pour économiser la bande passante.

Voici un résumé rapide des principaux éléments à prendre en compte pour l’implémentation de proxys :