Proxies Puppeteer : le guide pratique complet [2023]

Pourquoi Puppeteer a besoin d'un proxy

Les proxys pour Puppeteer permettent à l'outil de se connecter via une adresse IP différente, au lieu d'utiliser systématiquement celle de la machine sur laquelle il est exécuté. Cela s'avère utile pour les tâches liées à la localisation, les tests, la surveillance et d'autres opérations où la source de la connexion a son importance.

Puppeteer continue de gérer la tâche principale. Le proxy gère quant à lui la provenance de la connexion.

Que se passe-t-il sans proxy : blocages d'adresses IP, limitations de débit, restrictions géographiques

Sans proxy, les sites web continuent de voir la même adresse IP. À mesure que l'activité augmente, cette adresse IP risque d'atteindre une limite de débit ou d'être bloquée.

La localisation peut également avoir son importance. Une page ouverte depuis l'Allemagne peut ne pas afficher le même contenu qu'une page ouverte depuis les États-Unis.

Un proxy pour Puppeteer permet de se connecter à partir de différentes adresses IP et de différents emplacements lorsque cela est nécessaire.

Quel type de proxy utiliser avec Puppeteer

Le choix du type de proxy dépend de la tâche à effectuer.

Type de proxy	Scraping	Gestion des comptes	Tests	Surveillance
Résidentiel	Idéal lorsque l'emplacement et l'adresse IP d'origine sont importants	Utile lorsque les comptes nécessitent des adresses IP résidentielles	Idéal pour les tests basés sur la localisation	Utile pour vérifier le contenu depuis différents emplacements
FAI	Idéal lorsqu’une adresse IP stable est nécessaire	Utile pour des sessions prolongées sur une même adresse IP	Idéal pour les tests avec une adresse IP constante	Utile pour des vérifications continues depuis la même adresse IP
Centre de données	Idéal pour la vitesse et les volumes de requêtes importants	Préférable lorsque des adresses IP résidentielles ne sont pas requises	Idéal pour les tests généraux	Idéal pour les vérifications automatisées fréquentes

Les proxys résidentiels sont utiles lorsque l’adresse IP source et la localisation ont de l’importance. Les proxys FAI fonctionnent bien lorsqu’une même adresse IP doit rester active plus longtemps. Les proxys de centre de données sont indiqués lorsque la priorité est donnée à la vitesse et à l’échelle.

Le choix de la meilleure option dépend également de la nécessité d’un ciblage géographique, d’une connexion stable ou d’un accès à un pool d’adresses IP plus étendu.

Comment configurer un proxy dans Puppeteer

La configuration du proxy dans Puppeteer nécessite l'Geonode, le port, le nom d'utilisateur et le mot de passe. Enregistrez ces informations d'identification dans des variables d'environnement, puis chargez-les lors de la configuration du proxy dans le code.

Vous utilisez Geonode ? Récupérez le nom d'utilisateur et le mot de passe dans la section Identifiants d'accès et l'hôte, le port et le protocole dans la section Informations sur le serveur proxy.

Chemin d'accès aux paramètres ou code

Pour Puppeteer, transmettez l'hôte et le port du proxy via --proxy-server

lors du lancement du navigateur :

import puppeteer from "puppeteer";
import "dotenv/config";

const browser = await puppeteer.launch({
  headless: true,
  args: [
    `--proxy-server=http://${process.env.GEONODE_PROXY_HOST}:${process.env.GEONODE_PROXY_PORT}`,
  ],
});

Créez ensuite la page et indiquez les identifiants du proxy :

const page = await browser.newPage();

await page.authenticate({
  username: process.env.GEONODE_PROXY_USER,
  password: process.env.GEONODE_PROXY_PASS,
});

Conservez le nom d'utilisateur et le mot de passe réels dans des variables d'environnement plutôt que de les inscrire directement dans le fichier source. Lors de notre test, cette configuration a permis d'obtenir un code HTTP 200 via le proxy.

Le format d'authentification hôte:port:utilisateur:mot-de-passe

Geonode

vous fournit quatre valeurs :

proxy.geonode.io:PORT:USERNAME:PASSWORD

Pour Puppeteer, veillez à séparer ces valeurs. Enregistrez-les dans des variables d'environnement :

GEONODE_PROXY_HOST=proxy.geonode.io
GEONODE_PROXY_PORT=9000
GEONODE_PROXY_USER=USERNAME
GEONODE_PROXY_PASS=PASSWORD

Chargez l’hôte et le port via --proxy-server

, puis authentifiez-vous sur la page :

const browser = await puppeteer.launch({
  headless: true,
  args: [
    `--proxy-server=http://${process.env.GEONODE_PROXY_HOST}:${process.env.GEONODE_PROXY_PORT}`,
  ],
});

const page = await browser.newPage();

await page.authenticate({
  username: process.env.GEONODE_PROXY_USER,
  password: process.env.GEONODE_PROXY_PASS,
});

Nous avons testé cela avec des identifiants valides et avons reçu un code HTTP 200. Avec un mot de passe incorrect, le proxy a renvoyé un code HTTP 407 et :

Authentication error. Please check your authentication settings.

Rotation ou session persistante dans Puppeteer

Si les requêtes n’ont pas besoin de conserver la même adresse IP, utilisez la rotation.

Pour notre test, nous avons lancé Puppeteer avec le port HTTP en rotation :

const browser = await puppeteer.launch({
  headless: true,
  args: ["--proxy-server=http://proxy.geonode.io:9000"],
});

const page = await browser.newPage();

await page.authenticate({
  username: process.env.GEONODE_PROXY_USER,
  password: process.env.GEONODE_PROXY_PASS,
});

Nous avons effectué cinq requêtes en utilisant des sessions de navigateur neuves :

Request 1: 108.31.182.167
Request 2: 45.186.93.125
Request 3: 109.254.131.42
Request 4: 109.153.11.141
Request 5: 37.113.173.139

Nombre d’adresses IP uniques : 5

Rotation : Oui

Les cinq requêtes ont renvoyé des adresses IP différentes lors de ce test. Cela confirme que la rotation a fonctionné pendant l’exécution, mais ne garantit pas une nouvelle adresse IP pour chaque requête future.

Si des requêtes liées doivent rester sur la même adresse IP, utilisez plutôt une session « sticky ». Utilisez le port « sticky » et ajoutez les détails de la session au nom d’utilisateur :

const browser = await puppeteer.launch({
  headless: true,
  args: ["--proxy-server=http://proxy.geonode.io:10000"],
});

const page = await browser.newPage();

await page.authenticate({
  username:
    `${process.env.GEONODE_PROXY_USER}-session-blogpuppeteer01-lifetime-10`,
  password: process.env.GEONODE_PROXY_PASS,
});

Nous avons effectué trois requêtes en utilisant la même session :

Request 1: 178.64.64.40
Request 2: 178.64.64.40
Request 3: 178.64.64.40

Même adresse IP : Oui

Les trois requêtes ont utilisé la même adresse IP.

Consultez les guides d’Geonode

s sur les proxys rotatifs et les sessions « sticky » pour connaître les paramètres disponibles.

Erreurs courantes liées au proxy dans Puppeteer et comment les résoudre

Si le proxy ne fonctionne pas, commencez par vérifier les informations de connexion. Vérifiez le nom d'utilisateur et le mot de passe, puis l'hôte, le port et le protocole. L'erreur renvoyée par Puppeteer permet généralement de cerner le problème.

407 Authentification par proxy requise

Un code d'erreur 407 indique généralement un problème d'authentification.

Lorsque nous avons testé Puppeteer avec un mot de passe incorrect, le proxy a renvoyé le message suivant : «

HTTP status: 407
Authentication error. Please check your authentication settings.
``` »

Vérifiez d'abord le nom d'utilisateur et le mot de passe. S'ils sont corrects, assurez-vous que la méthode ``page.authenticate()`` est appelée après la création de la page.

ERR_TUNNEL_CONNECTION_FAILED / connexion refusée

Une erreur de connexion signifie généralement que Puppeteer n'a pas pu atteindre le proxy.

Vérifiez d'abord l'hôte et le port. Assurez-vous ensuite que le protocole correspond bien à celui du serveur proxy utilisé.

Lors de notre test de connexion ayant échoué, Puppeteer n'a pas renvoyé le message « ERR_TUNNEL_CONNECTION_FAILED

». L'utilisation d'un port de proxy inaccessible a renvoyé le message : «

net::ERR_CONNECTION_RESET at http://ip-api.com/json

». L'erreur Chromium exacte peut donc varier en fonction de la nature de l'échec de la connexion.

Délais d'expiration et réponses vides

Un délai d'expiration signifie que la page n'a pas reçu de réponse dans le délai configuré.

Vérifiez tout d’abord si l’URL cible fonctionne et si le proxy peut s’y connecter. Si les deux fonctionnent, vérifiez le délai d’expiration transmis à ``page.goto()`

Pour notre test, nous avons utilisé un proxy non routable avec un délai d’expiration de cinq secondes :

await page.goto(url, {
  timeout: 5000,
});

. Puppeteer a renvoyé :

TimeoutError: Navigation timeout of 5000 ms exceeded

. Définir un délai d’expiration explicite peut permettre à un script d’échouer rapidement lorsque la connexion au proxy se bloque.

ERR_NO_SUPPORTED_PROXIES

L'un des problèmes spécifiques à Puppeteer que nous avons rencontrés concernait l'insertion directe du nom d'utilisateur et du mot de passe dans ``--proxy-server`

Cette configuration a échoué :

--proxy-server=http://USERNAME:PASSWORD@proxy.geonode.io:9000

Puppeteer a renvoyé :

net::ERR_NO_SUPPORTED_PROXIES

La solution consiste à ne passer que le serveur proxy via l’argument de lancement :

args: ["--proxy-server=http://proxy.geonode.io:9000"]

Puis à s’authentifier séparément :

await page.authenticate({
  username: process.env.GEONODE_PROXY_USER,
  password: process.env.GEONODE_PROXY_PASS,
});

Après avoir modifié la configuration, la requête a abouti avec un code HTTP 200.

Puppeteer + Geonode : ce que cela vous apporte

Puppeteer gère les requêtes ou les connexions au sein de l’application. Geonode gère la connexion via le proxy.

Vous pouvez choisir des proxys résidentiels, FAI ou de centre de données en fonction de la tâche à accomplir, puis utiliser la rotation, les sessions persistantes et le ciblage géographique si nécessaire. Cela permet de séparer la configuration du proxy du reste du code de l'application.

Les formules varient selon le type de proxy, certaines options étant facturées au Go.

Foire aux questions

Puppeteer prend-il en charge les proxys de type « SOCKS5 » ?

L'authentification SOCKS5 n'a pas fonctionné avec la configuration Puppeteer que nous avons testée.

Nous avons essayé le port rotatif SOCKS5 de Geonode avec page.authenticate(), mais Puppeteer a renvoyé :

net::ERR_SOCKS_CONNECTION_FAILED

Nous avons également essayé d'intégrer les identifiants dans --proxy-server, ce qui a renvoyé :

net::ERR_NO_SUPPORTED_PROXIES

Comme aucune des configurations SOCKS5 avec authentification testées n'a fonctionné, la configuration HTTP vérifiée avec --proxy-server et page.authenticate() est l'option la plus sûre pour cette configuration.

Puis-je faire tourner les adresses IP à chaque requête dans Puppeteer ?

Oui, Puppeteer peut utiliser un proxy à rotation lorsque le navigateur est lancé via la configuration du proxy à rotation.

Lors de notre test, cinq nouvelles sessions de navigateur ont généré cinq adresses IP différentes. Cela confirme que la rotation a bien eu lieu pendant le test, mais il n’est pas garanti qu’une adresse IP différente soit attribuée à chaque requête ou session de navigateur.

Existe-t-il une période d'essai gratuite ?

Oui. Geonode propose une période d'essai gratuite, ce qui permet de tester le proxy avec Puppeteer avant de passer à une formule payante. Consultez les conditions actuelles de la période d'essai gratuite et les formules disponibles.

Où dois-je configurer le proxy dans Puppeteer ?

Définissez l'hôte et le port du proxy dans ``puppeteer.launch()`

à l'aide de ``--proxy-server

Appelez ensuite ``page.authenticate()`

` après la création de chaque page pour fournir le nom d'utilisateur et le mot de passe :

const browser = await puppeteer.launch({
  args: ["--proxy-server=http://proxy.geonode.io:9000"],
});

const page = await browser.newPage();

await page.authenticate({
  username: process.env.GEONODE_PROXY_USER,
  password: process.env.GEONODE_PROXY_PASS,
});

C'est la configuration qui a fonctionné lors de nos tests.

Dois-je indiquer le nom d'utilisateur et le mot de passe du proxy dans l'option --proxy-server ?

Non. Veillez à séparer les identifiants lorsque vous utilisez cette configuration de Puppeteer.

Lors de nos tests, l'intégration directe de USERNAME:PASSWORD@ dans --proxy-server a renvoyé l'erreur « ERR_NO_SUPPORTED_PROXIES ». En ne transmettant que l'hôte et le port à cet endroit, puis en utilisant page.authenticate() pour les identifiants, cela a fonctionné correctement.

Comment utiliser des serveurs proxy avec Puppeteer