In questo articolo
Questa è una pagina di riferimento più che un tutorial: la configurazione funzionante dei proxy per lo scraping in cinque linguaggi il cui pubblico è abbastanza ristretto da rendere una guida separata per ciascuno una ripetizione della stessa cosa cinque volte. Go, Kotlin, Scala, Perl ed Elixir, con il codice, la scelta della libreria e l’unica insidia che fa perdere più tempo in ciascuno.
La regola valida per tutti è la stessa. La configurazione del proxy per il web scraping va sull’oggetto client, configurato una volta e riutilizzato, perché quel client mantiene il pool di connessioni, il cookie jar e, con una sticky session, l’indirizzo di uscita. Qualsiasi soluzione che crea un client nuovo per ogni richiesta perde tutti e tre.
Informazioni chiave
- Una regola copre ogni linguaggio qui: configura il proxy una volta sull’oggetto client e riutilizza quel client, perché il client mantiene il pool di connessioni, i cookie e l’identità di uscita.
- Go: http.Transport con http.ProxyURL, colly per le esigenze del crawler. L’insidia è che http.Client non ha un timeout predefinito.
- Kotlin: OkHttp con un proxyAuthenticator. L’insidia è un autenticatore che non restituisce mai null e va in ciclo con una password errata.
- Scala: sttp con opzioni del backend. L’insidia è che il JDK disabilita l’autenticazione Basic del proxy nei tunnel HTTPS.
- Perl ed Elixir: LWP rispetta HTTPS_PROXY dall’ambiente e può sovrascrivere il tuo codice; in Elixir le opzioni del proxy appartengono all’adattatore, non a Req.
La regola in 3 parti valida per ogni linguaggio qui
Mantieni trasporto, parsing e pianificazione su livelli separati, e uno scraping non riuscito ti dirà dove si è interrotto.
| Parte | Gestisce | Sintomo quando fallisce |
|---|---|---|
| 1. Trasporto | Connessione, proxy, timeout, tentativi, TLS | Stato non 200, timeout, errori TLS |
| 2. Parsing | Byte in campi, con errore esplicito quando il markup cambia | 200 con campi vuoti |
| 3. Pianificazione | Concorrenza per host, cadenza, backoff | Successo che diminuisce nel giro di minuti |
Ogni linguaggio qui sotto implementa le stesse tre parti con nomi diversi. La sezione del trasporto è dove risiede il proxy in tutti e cinque.
Go: configurazione proxy, librerie e insidia da evitare
Tecnologie: net/http con un http.Transport personalizzato per il recupero, goquery o colly per un crawler completo per il parsing, chromedp quando una pagina richiede 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")
Nessun timeout predefinito. Un http.Client senza Timeout attende per sempre. Un host bloccato ferma un pool di worker che sembra sano in ogni metrica disponibile.
Corpi non chiusi. Ogni corpo della risposta deve essere chiuso, altrimenti la connessione non torna mai nel pool e il throughput crolla silenziosamente dopo qualche migliaio di richieste.
colly gestisce per te le esigenze del crawler: ha un selettore di proxy per la rotazione, limiti di frequenza per dominio e una coda integrata, quindi usalo prima di scrivere il tuo scheduler.
Usa Go quando Go è già il tuo stack, ti serve alta concorrenza con memoria prevedibile e vuoi un unico binario statico sul server del crawler. Evitalo quando il target richiede un browser reale per la maggior parte delle pagine, dove gli ecosistemi Python e Node hanno strumenti più maturi.
Kotlin: configurazione proxy, librerie e insidia da evitare
Tecnologie: OkHttp, oppure il client Ktor se usi già Ktor per il recupero, jsoup per il parsing, Playwright o Selenium sulla JVM quando è necessario il rendering.
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’autenticatore va in ciclo con una password errata. OkHttp riprova l’autenticatore finché non riesce o rinuncia. Restituisci null dopo il primo tentativo fallito, altrimenti una credenziale errata diventa una tempesta di richieste.
Un client, molte sessioni. OkHttp condivide il pool di connessioni e il cookie jar tra le chiamate. Per un’identità per sessione, crea un client per sessione o installa un cookie jar che controlli tu.
La regola di tunnelling del JDK che crea problemi in Java vale anche qui se ripieghi sul client JDK: l’autenticazione Basic del proxy su HTTPS richiede di cancellare la proprietà degli schemi disabilitati. L’autenticatore di OkHttp lo evita.
Usa Kotlin quando lavori sulla JVM e vuoi coroutine e una API moderna senza la verbosità di Java. Evitalo quando il team non ha esperienza JVM, poiché il deployment domina il codice.
Scala: configurazione proxy, librerie e insidia da evitare
Tecnologie: sttp con il backend che preferisci per il recupero, jsoup da Scala o scala-scraper per il parsing, Playwright sulla JVM se le pagine eseguono il rendering lato 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)
Il backend decide tutto. sttp è un’interfaccia; supporto proxy, timeout e streaming derivano dal backend scelto. Quando qualcosa si comporta in modo strano, leggi la documentazione di quel backend anziché quella di sttp.
Di nuovo il tunnelling JDK. Se il backend avvolge il client JDK, l’autenticazione Basic del proxy su HTTPS è disabilitata per impostazione predefinita e richiede di cancellare la proprietà jdk.http.auth.tunneling.disabledSchemes.
scala-scraper avvolge jsoup con una API Scala e vale la pena usarlo se il tuo parsing supera una manciata di selettori.
Usa Scala quando il crawler alimenta una pipeline Spark o di streaming già in Scala e la gestione della pressione a valle conta. Evitalo quando il compito è un semplice lavoro di recupero e parsing senza pipeline a valle.
Perl: configurazione proxy, librerie e insidia da evitare
Tecnologie: LWP::UserAgent, oppure Mojo::UserAgent per una API moderna per il recupero, HTML::TreeBuilder o Mojo::DOM per il parsing; nessuno in-process, chiama uno strumento esterno quando è necessario il rendering.
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 attraverso un proxy richiede i moduli giusti. LWP richiede LWP::Protocol::https e un IO::Socket::SSL funzionante, e rispetta anche la variabile d’ambiente HTTPS_PROXY, che sovrascrive silenziosamente ciò che imposti nel codice.
Le variabili d’ambiente prevalgono silenziosamente. env_proxy rileva impostazioni di sistema che potresti aver dimenticato. Imposta esplicitamente i proxy e, nei job pianificati, pulisci l’ambiente affinché un’impostazione a livello di host non possa reindirizzare il traffico.
Mojo::UserAgent offre richieste non bloccanti e una API DOM simile a jQuery in un’unica dipendenza, il che lo rende il punto di partenza migliore per nuovi scraper Perl.
Usa Perl quando Perl è il linguaggio del sistema circostante, tipicamente in strumenti operativi e per dati di lunga durata. Evitalo quando parti da zero senza Perl nello stack.
Elixir: configurazione proxy, librerie e insidia da evitare
Tecnologie: Req sopra Finch per il recupero, Floki per il parsing, Wallaby o un servizio browser esterno quando è necessario il rendering.
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!()
Le opzioni del proxy appartengono all’adattatore. Req passa connect_options a Finch e Mint. Se usi uno stack HTTPoison o hackney più vecchio, la forma delle opzioni è diversa, per questo gli snippet copiati spesso falliscono silenziosamente.
Un processo per URL non è un piano. Creare un Task per link avvia ogni richiesta subito. Task.async_stream con max_concurrency, dimensionato per host, è il limite idiomatico.
Floki con selettori CSS mantiene il parsing dichiarativo, e la gestione integrata di tentativi e reindirizzamenti di Req elimina gran parte del boilerplate che le persone scrivono a mano.
Usa Elixir quando il crawler gira in un sistema Elixir o Phoenix esistente e vuoi supervisione e concorrenza senza costi aggiuntivi. Evitalo quando ti serve una pipeline incentrata sul browser, dove l’ecosistema è più limitato rispetto a Node o Python.
Quale linguaggio dovresti usare davvero?
Il fattore decisivo è la manutenzione più che la capacità. Un crawler nel linguaggio che il tuo team scrive ogni giorno sopravvive al prossimo cambiamento del markup; uno intelligente in un linguaggio poco noto viene abbandonato al primo problema.
| Linguaggio | Ideale per | Punto più debole |
|---|---|---|
| Go | Alta concorrenza con memoria prevedibile, unico binario statico | Gli strumenti per il rendering browser sono più limitati che in Python o Node |
| Kotlin | Aziende JVM che desiderano coroutine e una API moderna | Peso del deployment per un lavoro piccolo |
| Scala | Crawler che alimentano pipeline Spark o di streaming | Comportamento dipendente dal backend e configurazione complessa |
| Perl | Strumenti operativi e per dati esistenti già in Perl | Nessun browser pratico in-process |
| Elixir | Sistemi Phoenix che vogliono supervisione e concorrenza senza costi aggiuntivi | Ecosistema per l’automazione browser limitato |
Se il tuo linguaggio non è qui, vale la stessa regola in tre parti: le nostre guide separate trattano Java, C#, PHP, R, C++, VBA ed Excel e JavaScript.
Cosa è uguale ovunque e quali sono i limiti?
Tre aspetti non cambiano con il linguaggio. Le sessioni gestiscono le uscite, quindi un percorso tra pagine mantiene un indirizzo sticky per tutta la sua durata: le regole sono in best practice per la proxy rotation. Un rifiuto è una decisione da diagnosticare anziché ritentare, come illustra passo dopo passo la nostra guida a 403 Forbidden durante lo scraping. E un proxy modifica solo l’indirizzo di uscita: non esegue JavaScript, non risolve un client incoerente e non rende accettabile una frequenza aggressiva.
Quanto alle regole: rispetta robots.txt e i termini del sito, preferisci le API ufficiali, evita tutto ciò che è dietro un login e considera i dati personali una questione di base giuridica anziché di parsing. Non trattiamo la risoluzione di CAPTCHA né l’elusione dei controlli di accesso. Informazioni generali, non consulenza legale: vedi il web scraping è legale.
Domande frequenti
Come imposto un proxy in Go?
Analizza l’URL del proxy con le credenziali, inserisci http.ProxyURL in un http.Transport e assegna a http.Client un timeout esplicito, perché non ne ha uno predefinito. Riutilizza quel client così il pool di connessioni e qualsiasi sticky session restano intatti.
Perché l’autenticatore proxy OkHttp di Kotlin va in ciclo?
Perché OkHttp continua a chiamare l’autenticatore finché non riesce o rinuncia. Restituisci null dopo il primo tentativo fallito, così una credenziale errata fallisce rapidamente invece di trasformarsi in una tempesta di richieste contro il gateway.
Perché l’autenticazione Basic del proxy fallisce su HTTPS nella JVM?
Il JDK disabilita per impostazione predefinita l’autenticazione Basic sui tunnel CONNECT, quindi un proxy autenticato funziona per HTTP e fallisce per HTTPS. Cancella la proprietà jdk.http.auth.tunneling.disabledSchemes, oppure usa un client come OkHttp che invia direttamente l’header Proxy-Authorization.
Perché il mio script Perl ignora il proxy impostato?
LWP rispetta le variabili d’ambiente HTTPS_PROXY e HTTP_PROXY, ed env_proxy rileva impostazioni a livello di host che potresti non conoscere. Imposta esplicitamente i proxy nel codice e pulisci l’ambiente nei job pianificati affinché un’impostazione della macchina non possa reindirizzare il traffico.
Dove vanno le opzioni del proxy in Elixir?
Sull’adattatore anziché su Req stesso: connect_options viene passato a Finch e Mint, per questo gli snippet scritti per stack più vecchi basati su hackney non fanno nulla silenziosamente. Adatta la forma delle opzioni all’adattatore che usi davvero.
Una credenziale, tutti i linguaggi qui sopra
Ogni snippet di questa pagina funziona con una credenziale gateway DataImpulse: uscite residential a $1 per GB in 195 paesi, sessioni rotating o sticky, HTTP, HTTPS e SOCKS5, targeting per paese incluso. Crea un account e testa un target dal tuo client prima di aumentare la scala.
Correlati: proxy per il web scraping · configurazione proxy Crawl4AI · caso d’uso del web scraping.
Ultimo aggiornamento: 17 settembre 2026.
