Skip to content
Advanced / 6 min read

Web scraping avancé avec les proxies résidentiels Dataimpulse et Puppeteer sur Windows

Apprenez à intégrer les proxies résidentiels rotatifs Dataimpulse avec Puppeteer sur Windows pour du web scraping avancé à haut volume. Ce guide couvre la configuration, l'authentification, la rotation des proxies et la gestion de la concurrence.

Windows HTTP(S) Scraping Web

Aperçu

Puppeteer est une puissante bibliothèque Node.js pour contrôler Chrome en mode headless. Lorsqu'elle est combinée aux proxies résidentiels rotatifs de Dataimpulse, vous pouvez scraper de grands sites web sans être bloqué. Ce tutoriel vous montre comment configurer Puppeteer sur Windows pour utiliser les proxies résidentiels Dataimpulse, gérer l'authentification et mettre en œuvre une rotation efficace pour le scraping à haut volume.

Prérequis

  • Windows 10 ou version ultérieure.
  • Node.js 14+ installé (téléchargez-le depuis le site officiel de Node.js).
  • Un compte Dataimpulse avec des identifiants de proxy résidentiel (nom d'utilisateur, mot de passe, point de terminaison).
  • Connaissance de base de JavaScript et async/await.

Étape 1 : Installer Node.js et Puppeteer

Si ce n'est pas déjà fait, installez Node.js depuis le site officiel. Ensuite, créez un nouveau dossier de projet et installez Puppeteer.

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

Étape 2 : Obtenir les identifiants de proxy Dataimpulse

Connectez-vous à votre tableau de bord Dataimpulse et accédez à la section des proxies résidentiels. Vous y trouverez :

  • Point de terminaison : un hôte et un port, par ex., proxy.dataimpulse.com:12321 (vérifiez les détails exacts sur votre tableau de bord).
  • Nom d'utilisateur : votre nom d'utilisateur Dataimpulse.
  • Mot de passe : votre mot de passe Dataimpulse.

Dataimpulse utilise une passerelle rotative, donc chaque requête via ce point de terminaison utilisera une IP différente du pool (sauf si vous utilisez des ports de session sticky). Pour ce tutoriel, nous utiliserons le point de terminaison rotatif.

Étape 3 : Configurer Puppeteer avec l'authentification proxy

Puppeteer peut utiliser un proxy en passant l'argument --proxy-server lors du lancement du navigateur. L'authentification est gérée via page.authenticate(). Créez un fichier scrape.js :

const puppeteer = require('puppeteer');

const PROXY_HOST = 'YOUR_ENDPOINT_HOST'; // Replace with your Dataimpulse proxy host
const PROXY_PORT = 'YOUR_ENDPOINT_PORT'; // Replace with your 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); // Should show the proxy IP

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

Exécutez le script avec node scrape.js. Vous devriez voir une adresse IP qui n'est pas la vôtre, ce qui confirme que le proxy fonctionne.

Étape 4 : Mettre en œuvre la logique de rotation des proxies

Comme le point de terminaison de Dataimpulse fait tourner les IP automatiquement, vous pouvez effectuer plusieurs requêtes via la même instance de navigateur et chacune utilisera une IP différente. Cependant, pour un meilleur contrôle et pour éviter la détection, vous pouvez fermer et rouvrir le navigateur ou utiliser des contextes incognito. Voici un exemple qui extrait plusieurs pages avec rotation :

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

Chaque nouvelle page utilisera une IP rotative du pool de Dataimpulse.

Étape 5 : Gérer la concurrence et la gestion des erreurs

Pour le scraping à haut volume, vous devez gérer la concurrence et les erreurs avec soin. Utilisez puppeteer-cluster pour gérer plusieurs pages en parallèle tout en respectant les limites de mémoire.

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, // Adjust based on your resources
    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',
    // Add more URLs
  ];

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

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

Cette configuration vous permet de scraper plusieurs pages simultanément tout en tirant parti des proxies rotatifs de Dataimpulse.

Étape 6 : Tester et valider

Exécutez votre script et vérifiez que :

  • L'adresse IP change entre les requêtes (vérifiez avec https://httpbin.org/ip).
  • Aucune erreur d'authentification proxy ne se produit.
  • Les pages cibles se chargent correctement.

Vous pouvez également journaliser l'IP utilisée pour chaque requête afin de vous assurer que la rotation fonctionne.

Dépannage

  • 407 Proxy Authentication Required : Vérifiez votre nom d'utilisateur et votre mot de passe. Assurez-vous d'utiliser la bonne méthode d'authentification (page.authenticate()).
  • Délais de connexion dépassés : Augmentez l'option timeout dans page.goto(). Assurez-vous également que le point de terminaison et le port de votre proxy sont corrects.
  • Le lancement du navigateur échoue avec une erreur proxy : Assurez-vous que l'argument --proxy-server utilise le bon format : http://hôte:port (sans identifiants dans l'URL).
  • La rotation ne fonctionne pas : Le point de terminaison rotatif de Dataimpulse devrait fournir une nouvelle IP pour chaque nouvelle connexion. Si vous avez besoin de sessions sticky, utilisez le port sticky dédié fourni dans votre tableau de bord.

Résumé

Vous avez appris à intégrer les proxies résidentiels Dataimpulse avec Puppeteer sur Windows pour du web scraping avancé. En tirant parti de l'authentification proxy de Puppeteer et du pool d'IP rotatives de Dataimpulse, vous pouvez créer des scrapers évolutifs qui évitent les blocages d'IP. N'oubliez pas de gérer les erreurs, de gérer la concurrence et de respecter les conditions d'utilisation des sites web.