Dans cet article
Cette page est une référence plutôt qu’un tutoriel : la configuration de proxy fonctionnelle pour le scraping dans cinq langages dont l’audience est suffisamment restreinte pour que des guides séparés répètent la même chose cinq fois. Go, Kotlin, Scala, Perl et Elixir, avec le code, le choix de bibliothèque et le piège qui coûte le plus de temps dans chacun.
La règle applicable à tous est la même. La configuration du proxy pour le web scraping doit se trouver sur l’objet client, configuré une fois et réutilisé, car ce client porte le pool de connexions, le gestionnaire de cookies et, avec une session sticky, l’adresse de sortie. Tout ce qui crée un nouveau client à chaque requête perd ces trois éléments.
Points clés
- Une règle couvre tous les langages présentés ici : configurez le proxy une fois sur l’objet client et réutilisez ce client, car il porte le pool de connexions, les cookies et l’identité de sortie.
- Go : http.Transport avec http.ProxyURL, colly pour les besoins du crawler. Le piège est que http.Client n’a pas de délai d’expiration par défaut.
- Kotlin : OkHttp avec un proxyAuthenticator. Le piège est un authentificateur qui ne renvoie jamais null et boucle avec un mauvais mot de passe.
- Scala : sttp avec des options de backend. Le piège est que le JDK désactive l’authentification Basic du proxy dans les tunnels HTTPS.
- Perl et Elixir : LWP respecte HTTPS_PROXY de l’environnement et peut remplacer votre code ; dans Elixir, les options de proxy appartiennent à l’adaptateur, pas à Req.
La règle en 3 parties applicable à tous les langages présentés ici
Conservez le transport, l’analyse et la planification dans des couches distinctes ; un scraping défaillant vous indique ainsi où il a échoué.
| Partie | Gère | Symptôme en cas d’échec |
|---|---|---|
| 1. Transport | Connexion, proxy, délais d’expiration, tentatives, TLS | Statut autre que 200, délais d’expiration, erreurs TLS |
| 2. Analyse | Conversion des octets en champs et échec explicite lorsque le balisage change | 200 avec champs vides |
| 3. Planification | Concurrence par hôte, cadence, temporisation progressive | Succès qui se dégrade au fil des minutes |
Chaque langage ci-dessous implémente ces mêmes trois parties sous des noms différents. Dans les cinq cas, le proxy se trouve dans la section transport.
Go : configuration du proxy, bibliothèques et piège à éviter
Environnement : net/http avec un http.Transport personnalisé pour les requêtes, goquery, ou colly pour un robot d’exploration complet pour l’analyse, chromedp lorsqu’une page nécessite JavaScript.
proxyURL, _ := url.Parse("http://USER:[email protected]:823")
client := &http.Client{
Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
Timeout: 30 * time.Second,
}
resp, err := client.Get("https://example.com")
Aucun délai d’expiration par défaut. Un http.Client sans Timeout attend indéfiniment. Un hôte bloqué immobilise un pool de workers qui semble sain dans toutes vos métriques.
Corps non fermés. Chaque corps de réponse doit être fermé, faute de quoi la connexion ne retourne jamais au pool et le débit s’effondre discrètement après quelques milliers de requêtes.
colly gère les besoins du crawler pour vous : il possède un sélecteur de proxy pour la rotation, des limites de débit par domaine et une file intégrée ; utilisez-le avant d’écrire votre propre planificateur.
Utilisez Go lorsque Go fait déjà partie de votre environnement, que vous avez besoin d’une forte concurrence avec une mémoire prévisible et que vous voulez un unique binaire statique sur la machine du robot d’exploration. Évitez-le lorsque la cible nécessite un vrai navigateur pour la plupart des pages, car les écosystèmes Python et Node offrent des outils plus matures.
Kotlin : configuration du proxy, bibliothèques et piège à éviter
Environnement : OkHttp, ou le client Ktor si vous utilisez déjà Ktor pour les requêtes, jsoup pour l’analyse, Playwright ou Selenium sur la JVM lorsqu’un rendu est nécessaire.
val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress("gw.dataimpulse.com", 823))
val client = OkHttpClient.Builder()
.proxy(proxy)
.proxyAuthenticator { _, response ->
response.request.newBuilder()
.header("Proxy-Authorization", Credentials.basic("USER", "PASS"))
.build()
}
.callTimeout(Duration.ofSeconds(30))
.build()
L’authentificateur boucle indéfiniment avec un mauvais mot de passe. OkHttp réessaie l’authentificateur jusqu’à abandonner. Renvoyez null après la première tentative échouée, sinon un mauvais identifiant se transforme en tempête de requêtes.
Un client, de nombreuses sessions. OkHttp partage son pool de connexions et son gestionnaire de cookies entre les appels. Pour une identité par session, créez un client par session ou installez un gestionnaire de cookies que vous contrôlez.
La règle de tunnellisation du JDK qui affecte Java s’applique aussi ici si vous revenez au client JDK : l’authentification Basic du proxy via HTTPS nécessite de supprimer la propriété des schémas désactivés. L’authentificateur d’OkHttp l’évite.
Utilisez Kotlin lorsque vous êtes sur la JVM et souhaitez des coroutines ainsi qu’une API moderne sans le formalisme de Java. Évitez-le lorsque l’équipe n’a aucune expérience de la JVM, car le déploiement prend alors le dessus sur le code.
Scala : configuration du proxy, bibliothèques et piège à éviter
Environnement : sttp avec le moteur de votre choix pour les requêtes, jsoup depuis Scala, ou scala-scraper pour l’analyse, Playwright sur la JVM si les pages sont rendues côté client.
import sttp.client3._
val backend = HttpClientSyncBackend(
options = SttpBackendOptions.httpProxy(
"gw.dataimpulse.com", 823, "USER", "PASS")
)
val response = basicRequest
.get(uri"https://example.com")
.readTimeout(30.seconds)
.send(backend)
Le moteur décide de tout. sttp est une interface ; la prise en charge du proxy, les délais d’expiration et le traitement en flux viennent du moteur choisi. Consultez la documentation de ce moteur plutôt que celle de sttp lorsqu’un comportement paraît étrange.
Encore la tunnellisation du JDK. Si le moteur encapsule le client JDK, l’authentification Basic du proxy via HTTPS est désactivée par défaut et nécessite de supprimer la propriété jdk.http.auth.tunneling.disabledSchemes.
scala-scraper encapsule jsoup avec une API Scala et vaut la peine si votre analyse dépasse une poignée de sélecteurs.
Utilisez Scala lorsque le robot d’exploration alimente un pipeline Spark ou de traitement en flux déjà en Scala et que la contre-pression est importante. Évitez-le lorsque la tâche consiste en une simple récupération et analyse sans pipeline en aval.
Perl : configuration du proxy, bibliothèques et piège à éviter
Environnement : LWP::UserAgent, ou Mojo::UserAgent pour une API moderne de récupération, HTML::TreeBuilder ou Mojo::DOM pour l’analyse, aucun outil en processus ; appelez un outil externe lorsqu’un rendu est nécessaire.
use LWP::UserAgent;
my $ua = LWP::UserAgent->new(timeout => 30);
$ua->proxy(['http','https'] => 'http://USER:[email protected]:823');
my $res = $ua->get('https://example.com');
die $res->status_line unless $res->is_success;
# Mojo equivalent
my $mojo = Mojo::UserAgent->new;
$mojo->proxy->http('http://USER:[email protected]:823')
->https('http://USER:[email protected]:823');
HTTPS via un proxy nécessite les bons modules. LWP nécessite LWP::Protocol::https et un IO::Socket::SSL fonctionnel ; il respecte aussi la variable d’environnement HTTPS_PROXY, qui remplace silencieusement ce que vous définissez dans le code.
Les variables d’environnement gagnent discrètement. env_proxy récupère des réglages système que vous avez oubliés. Définissez les proxies explicitement et, dans les tâches planifiées, effacez l’environnement afin qu’un réglage au niveau de l’hôte ne puisse pas rediriger votre trafic.
Mojo::UserAgent vous offre des requêtes non bloquantes et une API DOM proche de jQuery dans une seule dépendance, ce qui en fait le meilleur point de départ pour de nouveaux scrapers Perl.
Utilisez Perl lorsque Perl est le langage du système environnant, généralement dans des outils d’exploitation et de données durables. Évitez-le lorsque vous commencez de zéro sans Perl dans votre environnement.
Elixir : configuration du proxy, bibliothèques et piège à éviter
Environnement : Req au-dessus de Finch pour les requêtes, Floki pour l’analyse, Wallaby ou un service de navigateur externe lorsqu’un rendu est nécessaire.
Req.get!("https://example.com",
connect_options: [
proxy: {:http, "gw.dataimpulse.com", 823, []},
proxy_headers: [
{"proxy-authorization",
"Basic " <> Base.encode64("USER:PASS")}
]
],
receive_timeout: 30_000
)
|> Map.get(:body)
|> Floki.parse_document!()
Les options de proxy appartiennent à l’adaptateur. Req transmet connect_options à Finch et Mint. Si vous utilisez un ancien environnement HTTPoison ou hackney, la structure des options est différente, ce qui explique pourquoi les extraits copiés échouent souvent en silence.
Un processus par URL n’est pas un plan. Créer une Task par lien lance toutes les requêtes en même temps. Task.async_stream avec max_concurrency, dimensionné par hôte, est la limite idiomatique.
Floki avec des sélecteurs CSS conserve une analyse déclarative, et la gestion intégrée des tentatives et redirections de Req élimine la plupart du code passe-partout que les gens écrivent à la main.
Utilisez Elixir lorsque le crawler s’exécute dans un système Elixir ou Phoenix existant et que vous voulez bénéficier de la supervision et de la concurrence. Évitez-le lorsque vous avez besoin d’un pipeline fortement centré sur le navigateur, car l’écosystème est moins développé que sur Node ou Python.
Quel langage devriez-vous réellement utiliser ?
Le facteur décisif est la maintenance plutôt que la capacité. Un robot d’exploration dans le langage que votre équipe utilise quotidiennement survit au prochain changement de balisage ; un robot d’exploration ingénieux dans un langage peu connu est abandonné dès la première panne.
| Langage | Meilleur cas d’usage | Point le plus faible |
|---|---|---|
| Go | Forte concurrence avec mémoire prévisible, unique binaire statique | Outils de rendu navigateur moins développés que Python ou Node |
| Kotlin | Équipes JVM souhaitant des coroutines et une API moderne | Poids du déploiement pour une petite tâche |
| Scala | Robots d’exploration alimentant des pipelines Spark ou de traitement en flux | Comportement dépendant du moteur et configuration exigeante |
| Perl | Outils d’exploitation et de données existants déjà en Perl | Pas de navigateur pratique en processus |
| Elixir | Systèmes Phoenix recherchant supervision et concurrence | Écosystème d’automatisation du navigateur limité |
Si votre langage n’est pas présent, la même règle en trois parties s’applique : nos guides distincts couvrent Java, C#, PHP, R, C++, VBA et Excel et JavaScript.
Qu’est-ce qui est identique partout et quelles sont les limites ?
Trois choses ne changent pas avec le langage. Les sessions déterminent les sorties, donc un parcours sur plusieurs pages conserve une même adresse sticky pendant toute sa durée : les règles figurent dans les bonnes pratiques de rotation des proxies. Un refus est une décision à diagnostiquer plutôt qu’à réessayer, comme l’explique pas à pas notre guide sur l’erreur 403 Forbidden lors du scraping. Et un proxy ne modifie que l’adresse de sortie : il n’exécute pas JavaScript, ne corrige pas un client incohérent et ne rend pas acceptable une cadence agressive.
Concernant les règles : respectez robots.txt et les conditions des sites, privilégiez les API officielles, ne faites rien derrière une connexion et considérez les données personnelles comme une question de base légale plutôt que d’analyse. Nous ne couvrons pas la résolution de CAPTCHA ni le contournement des contrôles d’accès. Informations générales, pas un avis juridique : consultez le web scraping est-il légitime.
Questions fréquentes
Comment configurer un proxy dans Go ?
Analysez l’URL du proxy avec les identifiants, placez http.ProxyURL sur un http.Transport et donnez à http.Client un délai d’expiration explicite, car il n’en a aucun par défaut. Réutilisez ce client afin que le pool de connexions et toute session sticky restent intacts.
Pourquoi l’authentificateur de proxy OkHttp de Kotlin boucle-t-il ?
Parce qu’OkHttp continue d’appeler l’authentificateur jusqu’à ce qu’il réussisse ou abandonne. Renvoyez null après la première tentative échouée afin qu’un mauvais identifiant échoue rapidement au lieu de se transformer en tempête de requêtes contre la passerelle.
Pourquoi l’authentification Basic du proxy échoue-t-elle via HTTPS sur la JVM ?
Le JDK désactive par défaut l’authentification Basic sur les tunnels CONNECT ; un proxy authentifié fonctionne donc avec HTTP et échoue avec HTTPS. Supprimez la propriété jdk.http.auth.tunneling.disabledSchemes ou utilisez un client tel qu’OkHttp qui envoie lui-même l’en-tête Proxy-Authorization.
Pourquoi mon script Perl ignore-t-il le proxy que j’ai défini ?
LWP respecte les variables d’environnement HTTPS_PROXY et HTTP_PROXY, et env_proxy récupère des réglages au niveau de l’hôte que vous ne connaissez peut-être pas. Définissez les proxies explicitement dans le code et effacez l’environnement dans les tâches planifiées afin qu’un réglage de la machine ne puisse pas rediriger votre trafic.
Où placer les options de proxy dans Elixir ?
Sur l’adaptateur plutôt que sur Req lui-même : connect_options est transmis à Finch et Mint, c’est pourquoi les extraits écrits pour les anciennes stacks basées sur hackney ne font silencieusement rien. Faites correspondre la structure des options à l’adaptateur que vous utilisez réellement.
Un identifiant, tous les langages ci-dessus
Chaque extrait de cette page fonctionne avec un identifiant de passerelle DataImpulse : des sorties résidentielles à $1 par GB dans 195 pays, des sessions avec rotation ou sticky, HTTP, HTTPS et SOCKS5, avec ciblage par pays. Créez un compte et testez une cible depuis votre propre client avant de passer à l’échelle.
À lire aussi : proxies pour le web scraping · configuration du proxy Crawl4AI · cas d’usage du web scraping.
Dernière mise à jour : 17 septembre 2026.
