Configuration du proxy dans Puppeteer : techniques d'authentification, de rotation et de contournement

Les procurations sont essentielles pour Marionnettiste automatisation. Ils masquent votre adresse IP, contournent les restrictions géographiques et vous aident à éviter les interdictions. Voici ce que vous apprendrez sur l'utilisation des proxys dans Marionnettiste:

1. Configurer des proxys:Ajoutez des proxys à votre navigateur et authentifiez-les facilement.
2. Rotation des proxys: Répartissez les requêtes sur plusieurs adresses IP pour éviter la détection.
3. Gérer les erreurs: Réessayez les demandes, gérez les blocs et changez de proxy si nécessaire.
4. Optimiser la vitesse:Bloquez les ressources inutiles et faites tourner les agents utilisateurs pour un scraping plus rapide et plus furtif.

Comparaison rapide des types de proxy

Type de proxy	Vitesse	l'anonymat	Prix	Idéal pour
Datacenter	Rapide	Faible	Abordable	Grattage à haut volume
Résidentiel	Modérée	Haute	Cher	Tâches sensibles ou géo-spécifiques
Mobile	Lent	Très élevé	Très cher	Vérification des annonces, CAPTCHA

Marionnettiste Intégration de proxy avec Données lumineuses - Tutoriel complet 2024

Configuration de base du proxy

La configuration d'un proxy est une étape clé pour optimiser l'automatisation de votre Puppeteer. Voici comment commencer.

Ajout d'un serveur proxy

Vous pouvez configurer un serveur proxy lors du lancement du navigateur dans Puppeteer comme ceci :

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 souhaiterez sécuriser votre connexion en configurant l’authentification proxy.

Étapes d'authentification du proxy

Si votre proxy nécessite 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 :

Méthode d'authentification	Meilleur cas d'utilisation	Complexité de la mise en œuvre
page.authenticate()	Authentification proxy standard	Faible
proxy-chain paquet	Routage avancé	Moyenne
Proxy-Authorization entête	Sites HTTP uniquement	Haute

Une fois que vous avez configuré votre proxy et votre authentification, il est temps de le tester.

Tester les paramètres du proxy

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

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

Voici un exemple de script 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

La gestion de la rotation des proxys est essentielle pour éviter les interdictions d'IP et éviter la limitation du débit lors du scraping ou de l'automatisation des tâches en ligne.

Création d'une liste de proxy

Pour commencer, créez une liste de proxys pouvant être utilisés en rotation 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 :

Type de proxy	Temps de réponse	Taux de réussite	Gamme de coûts
Datacenter	100-300ms	85 to 95 %	0.50 $ à 2 $/IP
Résidentiel	500-1000ms	90 to 98 %	2 $ à 8 $/IP
Mobile	800-1500ms	95 to 99 %	5 $ à 15 $/IP

Chaque type a ses forces et ses faiblesses, alors choisissez en fonction de vos besoins spécifiques, tels que la vitesse, la fiabilité ou le budget.

Changement de proxy entre les requêtes

Pour faire tourner 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.

Directives relatives à la rotation des procurations

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

1. Stratégie de timing

Introduisez des délais aléatoires entre les requêtes pour 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 avec élégance en passant à un nouveau proxy et en réessayant la demande :

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

3. Gestion de session

Pour les tâches nécessitant 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 tels que la gestion des blocages, des CAPTCHA et d'autres obstacles.

sbb-itb-23997f1

Techniques avancées de proxy

Proxy résidentiels et datacenters

Choisir le bon proxy est essentiel pour l'automatisation avec Puppeteer. Voici une comparaison pour vous aider à choisir :

Fonctionnalité	Proxys résidentiels	Proxys de centre de données
Source	Fourni par les FAI aux propriétés résidentielles	Provenant de centres de données
Vitesse	Plus lent en raison du routage du FAI	Plus rapide avec une infrastructure dédiée
Risque de détection	Inférieur - imite le trafic réel des utilisateurs	Plus haut - plus facile à détecter
Prix	Plus cher	Rentable
Couverture géographique	Large, sur plusieurs sites	Souvent limité
Meilleurs cas d'utilisation	Tâches à haut anonymat, scraping sensible, vérification des publicités	Exploration de données à haut volume, traitement par lots

Les proxys résidentiels sont un choix solide pour les tâches qui exigent un anonymat élevé, car ils ressemblent beaucoup à l'activité réelle des utilisateurs .

Gestion des blocs et des CAPTCHA

Pour résoudre les blocages de sites web et les problèmes de CAPTCHA, utilisez des mécanismes de rotation et de nouvelle tentative de proxy. 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 correctement :

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

Ces stratégies aident à maintenir la continuité du flux de travail, même en cas de difficultés.

Gestion des erreurs de proxy

La gestion efficace des erreurs de proxy nécessite des ajustements de délai d'expiration, des contrôles 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 directives pour une meilleure gestion des erreurs :

• Définissez des délais d’expiration de connexion pour éviter les attentes prolongées.
• Surveillez en permanence les performances du proxy.
• Gardez un pool de proxys de sauvegarde prêts.

La configuration correcte de votre navigateur joue également un rôle pour garantir des performances optimales :

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 sont fonctionnels :

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 sur les performances du proxy

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

Tests de vitesse et optimisation

Réduisez les temps de chargement en bloquant les requêtes inutiles telles que 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();
    }
});

Paire page.goto avec 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 existe peu de moyens d'accélérer le démarrage et l'arrêt de Puppeteer. Le gain le plus important viendra probablement d'un affichage plus rapide de vos pages cibles.
– Jon Yongfook, fondateur, Ours-bannière

Répartition de la charge du proxy

Répartissez le trafic sur 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, complétant les méthodes de rotation précédentes pour éviter de surcharger un seul proxy.

Problèmes courants et solutions

Voici quelques défis courants et comment les gérer efficacement :

• La latence du réseau Utilisez le code suivant pour gérer les délais d’attente 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 du débit Détectez et répondez aux limites de débit 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 nouvelles informations d’identification :

  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 garantir un fonctionnement fluide et efficace avec des résultats précis et cohérents. »
- ScrapeOps

Gardez un œil sur les temps de réponse et les taux de réussite pour garantir que vos proxys restent efficaces et non détectés.

Conclusion

Méthodes de configuration des clés

La configuration de Puppeteer avec des proxys implique quelques étapes importantes. Pour les proxys privés, utilisez le authenticate fonction permettant de fournir des informations d'identification :

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

Pour garantir que la page se charge complètement, utilisez le waitUntil option (par exemple, 'networkidle2') et définissez un délai d'attente (par exemple, 30 secondes) :

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

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

Pratiques d'excellence

Pour maintenir des opérations proxy sécurisées 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 pour identifier les goulots d’étranglement.

Optimisation de la sécurité

• Faites tourner 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 bref résumé des considérations importantes pour la mise en œuvre du proxy :

Aspect	Mise en œuvre	Bénéfice
Authentification	Utilisez authenticate fonction	Sécurise l'accès aux proxys privés
Gestion de la charge	Activer l'interception des demandes	Réduit la bande passante et accélère le chargement
Gestion des erreurs	Mettre en œuvre le try-catch blocs	Gère les problèmes de connexion avec élégance
Protection d'identité	Faire tourner les proxys et les agents utilisateurs	Améliore les taux de réussite et évite les blocages

articles similaires

• Comment fonctionne la détection de navigateur sans tête et comment la contourner
• Installation et configuration de Puppeteer : résolution des problèmes courants de dépendance et de Chromium
• Interception et modification des requêtes réseau dans Puppeteer : guide pratique
• Gestion des agents utilisateurs dans Puppeteer pour l'émulation de périphériques