Impostazione del proxy in curl e wget: guida completa

Durante lo scraping di siti web, l'automazione delle richieste API o il monitoraggio dei prezzi dei concorrenti sui marketplace, ci si imbatte inevitabilmente in blocchi per IP. Gli strumenti curl e wget sono strumenti standard per lavorare con le richieste HTTP nella riga di comando, e una corretta configurazione del proxy in essi è fondamentale per eludere le restrizioni. In questo articolo esamineremo tutti i modi per utilizzare i proxy in curl e wget: dai comandi di base agli scenari avanzati con rotazione IP e gestione degli errori.

Sintassi di base del proxy in curl e wget

Iniziamo con i comandi più semplici per connettersi tramite proxy. Entrambi gli strumenti supportano un parametro per specificare il server proxy, ma la sintassi è leggermente diversa.

Utilizzo del proxy in curl

In curl, il proxy è specificato tramite il parametro -x o --proxy. Il formato di base del comando è:

curl -x http://proxy-server:port http://example.com

Un esempio specifico con un server proxy reale:

curl -x http://45.130.123.45:8080 http://api.ipify.org

Questo comando invierà una richiesta a api.ipify.org (un servizio che restituisce il tuo indirizzo IP) tramite il server proxy specificato. Vedrai l'IP del proxy, non il tuo indirizzo reale.

Utilizzo del proxy in wget

In wget, il proxy è configurato tramite il parametro -e use_proxy=yes e variabili d'ambiente, oppure direttamente tramite opzioni:

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

Oppure una versione più breve tramite variabili d'ambiente (di cui parleremo più avanti):

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

Autenticazione sul server proxy

La maggior parte dei servizi proxy commerciali richiede l'autenticazione con nome utente e password. Questo protegge il proxy da utilizzi non autorizzati e consente di monitorare il traffico di ogni cliente. Vediamo come passare le credenziali in curl e wget.

Autenticazione in curl

In curl, il nome utente e la password possono essere specificati direttamente nell'URL del server proxy o tramite un parametro separato -U:

# Metodo 1: nome utente e password nell'URL
curl -x http://username:password@proxy-server:port http://example.com

# Metodo 2: tramite parametro -U
curl -x http://proxy-server:port -U username:password http://example.com

Un esempio specifico con le credenziali:

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

Un punto importante: se la password contiene caratteri speciali (@, :, /, ?), devono essere codificati in formato URL. Ad esempio, il carattere @ deve essere sostituito con %40:

# Se la password contiene @: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Autenticazione in wget

In wget, l'autenticazione è configurata tramite i parametri --proxy-user e --proxy-password:

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

Oppure tramite variabili d'ambiente con le credenziali nell'URL:

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

Lavorare con diversi tipi di proxy: HTTP, HTTPS, SOCKS5

I server proxy operano su diversi protocolli, e la scelta del tipo dipende dal compito. I proxy HTTP sono adatti per richieste semplici, gli HTTPS forniscono crittografia, mentre i SOCKS5 operano a un livello più basso e supportano qualsiasi tipo di traffico. Durante lo scraping di marketplace come Wildberries o Ozon, si utilizzano spesso proxy residenziali, che possono funzionare su uno qualsiasi di questi protocolli.

Proxy HTTP e HTTPS

I proxy HTTP sono il tipo più comune. Operano a livello del protocollo HTTP e sono adatti per la maggior parte delle attività di scraping web:

# Proxy HTTP in curl
curl -x http://proxy-server:8080 http://example.com

# Proxy HTTPS in curl (per connessioni sicure)
curl -x https://proxy-server:8080 https://example.com

Importante: anche se il sito target utilizza HTTPS, il proxy può essere HTTP. Curl stabilirà automaticamente un tunnel tramite il metodo CONNECT:

# Proxy HTTP per un sito HTTPS (funziona correttamente)
curl -x http://proxy-server:8080 https://secure-site.com

Proxy SOCKS5

SOCKS5 è un protocollo più versatile che opera a livello TCP e supporta qualsiasi tipo di traffico (HTTP, HTTPS, FTP, anche UDP). Questo rende SOCKS5 una scelta ideale per compiti complessi di automazione:

# SOCKS5 in curl
curl -x socks5://proxy-server:1080 http://example.com

# SOCKS5 con autenticazione
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (risoluzione DNS tramite proxy)
curl -x socks5h://proxy-server:1080 http://example.com

La differenza tra socks5 e socks5h: nel primo caso, le richieste DNS vengono effettuate dal tuo computer, nel secondo — tramite il server proxy. Usa socks5h se vuoi nascondere completamente la tua attività, comprese le richieste DNS.

In wget, il supporto per SOCKS5 è limitato, quindi per tali compiti è meglio utilizzare curl o strumenti aggiuntivi come proxychains.

Consiglio: Per lo scraping di marketplace (Wildberries, Ozon, Yandex.Market) si consiglia di utilizzare proxy residenziali o mobili con protocollo HTTP/HTTPS — sono meno soggetti a blocchi, poiché hanno IP di utenti reali.

Configurazione del proxy tramite variabili d'ambiente

Se lavori regolarmente tramite proxy, è più comodo configurare le variabili d'ambiente una volta piuttosto che specificare i parametri in ogni comando. Curl e wget leggono automaticamente queste variabili.

Configurazione per la sessione corrente

Esporta le variabili nel terminale (valide fino alla chiusura della sessione):

# Per traffico HTTP
export http_proxy="http://username:password@proxy-server:8080"

# Per traffico HTTPS
export https_proxy="http://username:password@proxy-server:8080"

# Per traffico FTP
export ftp_proxy="http://username:password@proxy-server:8080"

# Per SOCKS5
export all_proxy="socks5://username:password@proxy-server:1080"

Dopo di che, curl e wget utilizzeranno automaticamente il proxy:

# Il proxy verrà applicato automaticamente
curl http://api.ipify.org
wget http://example.com

Configurazione permanente in .bashrc o .zshrc

Per applicare i proxy ad ogni avvio del terminale, aggiungi le variabili nel file di configurazione della tua shell:

# Apri il file in un editor
nano ~/.bashrc  # per bash
# oppure
nano ~/.zshrc   # per zsh

# Aggiungi alla fine del file:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Salva e applica le modifiche:
source ~/.bashrc

Eccezioni: no_proxy

A volte è necessario escludere determinati indirizzi dalla proxy (ad esempio, localhost o servizi interni):

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

Ora le richieste a questi indirizzi andranno direttamente, bypassando il proxy.

Rotazione dei proxy negli script bash

Durante lo scraping massivo (ad esempio, raccogliere prezzi da migliaia di schede prodotto su Wildberries), l'uso di un solo proxy porterà a un blocco. La soluzione è la rotazione degli indirizzi IP. Vediamo come implementarlo negli script bash.

Rotazione semplice da un elenco di proxy

Crea un file proxies.txt con l'elenco dei server proxy (uno per riga):

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

Script per la rotazione sequenziale dei proxy:

#!/bin/bash

# File con l'elenco degli URL da fare scraping
urls_file="urls.txt"
# File con l'elenco dei proxy
proxies_file="proxies.txt"

# Leggi i proxy in un array
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Elabora ogni URL
while IFS= read -r url; do
    # Seleziona il proxy in modo circolare
    proxy="${proxies[$current_proxy]}"
    
    echo "Richiesta a $url tramite $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Passa al proxy successivo
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Pausa tra le richieste (1-3 secondi)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Questo script utilizza sequenzialmente i proxy dall'elenco, tornando al primo dopo l'ultimo. Una pausa casuale tra le richieste rende l'attività più naturale.

Scelta casuale del proxy

Per maggiore imprevedibilità, puoi scegliere i proxy in modo casuale:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # Scelta casuale del proxy
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Richiesta a $url tramite proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Rotazione automatica tramite API del servizio proxy

Molti fornitori di proxy (inclusi i servizi che offrono proxy residenziali) offrono rotazione automatica tramite un unico punto di accesso. Utilizzi un solo indirizzo proxy, mentre l'IP cambia ad ogni richiesta o secondo un timer:

# Proxy con rotazione automatica
# L'IP cambia ad ogni richiesta
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# Le due richieste sopra riceveranno indirizzi IP diversi

Questo è il modo più conveniente per lo scraping su larga scala — non è necessario gestire manualmente un elenco di proxy.

Trasmissione di intestazioni e User-Agent tramite proxy

I siti moderni analizzano non solo l'indirizzo IP, ma anche le intestazioni HTTP della richiesta. L'assenza di User-Agent o intestazioni sospette possono portare a un blocco anche quando si utilizzano proxy di alta qualità. Vediamo come configurare correttamente le intestazioni in curl e wget.

User-Agent in curl

User-Agent è un'intestazione che identifica il browser e il sistema operativo. Curl per impostazione predefinita invia il proprio User-Agent (curl/7.x.x), il che rivela immediatamente l'automazione. Sostituiscilo con un browser reale:

# Chrome su Windows
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# Firefox su macOS
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

Intestazioni aggiuntive

Per una richiesta più realistica, aggiungi intestazioni tipiche dei browser:

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: it-IT,it;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

User-Agent in wget

In wget, lo User-Agent è impostato tramite il parametro --user-agent:

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

Randomizzazione dello User-Agent negli script

Per lo scraping su larga scala, è utile alternare lo User-Agent, in modo che le richieste sembrino provenire da utenti diversi:

#!/bin/bash

# Array di User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # User-Agent casuale
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

Diagnosi dei problemi e gestione degli errori

Quando si lavora con i proxy, si verificano spesso errori: timeout, rifiuti di connessione, autenticazione errata. Vediamo come diagnosticare e gestire queste situazioni.

Controllo della funzionalità del proxy

Il modo più semplice per controllare un proxy è richiedere un servizio che restituisce il tuo IP:

# Controllo del proxy HTTP
curl -x http://proxy:8080 http://api.ipify.org

# Controllo del proxy SOCKS5
curl -x socks5://proxy:1080 http://api.ipify.org

# Con output dettagliato
curl -x http://proxy:8080 -v http://api.ipify.org

Il parametro -v (verbose) mostrerà i dettagli della connessione, comprese le intestazioni e gli errori.

Gestione dei timeout

Proxy lenti o server sovraccarichi possono causare timeout. Imposta limiti di tempo ragionevoli:

# Timeout di connessione 10 secondi, timeout totale 30 secondi
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# In wget
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

Gestione automatica degli errori negli script

Script per lo scraping con commutazione automatica al proxy successivo in caso di errore:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "Tentativo tramite proxy: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Successo con il proxy: $proxy"
            return 0
        else
            echo "Errore con il proxy: $proxy, proviamo il successivo"
        fi
    done
    
    echo "Tutti i proxy non disponibili per $url"
    return 1
}

# Utilizzo
fetch_with_retry "http://example.com/page1"

Il parametro -f costringe curl a restituire un errore per gli stati HTTP 4xx e 5xx, consentendo di gestire non solo gli errori di rete, ma anche i blocchi a livello di applicazione.

Logging per il debug

Salva log dettagliati delle richieste per analizzare i problemi:

# Salvataggio delle intestazioni di risposta
curl -x http://proxy:8080 -D headers.txt http://example.com

# Log completo delle interazioni
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# Solo stato HTTP
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

Scenari pratici di utilizzo

Esaminiamo compiti reali in cui curl e wget con proxy risolvono problemi aziendali specifici.

Scraping dei prezzi dei concorrenti sui marketplace

Compito: raccogliere i prezzi di 500 prodotti concorrenti da Wildberries per analizzare la strategia dei prezzi. Wildberries blocca attivamente le richieste massicce da un solo IP.

Soluzione: utilizzo di proxy residenziali con rotazione e randomizzazione dello User-Agent:

#!/bin/bash

# Proxy con rotazione automatica
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# Array di User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# Leggi gli ID dei prodotti da un file
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: it-IT,it;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "Scaricato prodotto $product_id"
    sleep $((RANDOM % 5 + 3))  # Pausa di 3-8 secondi
done < product_ids.txt

Monitoraggio della disponibilità dell'API da diverse regioni

Compito: verificare come l'API del tuo servizio funziona per gli utenti di diversi paesi (geoblocchi, velocità di risposta).

Soluzione: proxy con IP dai paesi desiderati:

#!/bin/bash

# Proxy da diversi paesi
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "Verifica da $country..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country: HTTP $http_code, tempo di risposta ${response_time}s"
done

Download di file tramite wget con rotazione dei proxy

Compito: scaricare un archivio di file (immagini di prodotti, documenti) da un sito che limita la velocità per un solo IP.

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "Scaricamento $filename tramite proxy #$current"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

Testare creatività pubblicitarie in diverse GEO

Compito: verificare come appaiono gli annunci pubblicitari di Facebook Ads per utenti degli Stati Uniti, Canada e Regno Unito (diverse valute, lingue, disponibilità delle offerte).

#!/bin/bash

# Proxy mobili da diversi paesi per realismo
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "Anteprima salvata per $country"
done

Per tali compiti, i proxy mobili sono particolarmente efficaci, poiché simulano utenti reali di smartphone e suscitano meno sospetti nei sistemi anti-frode di Facebook.

Importante per gli arbitraggisti: Quando verifichi le creatività pubblicitarie tramite proxy, utilizza IP mobili e i corrispondenti User-Agent dei dispositivi mobili. Facebook analizza la coerenza dei dati (il tipo di dispositivo nell'User-Agent deve corrispondere al tipo di IP).

Automazione del controllo della disponibilità del sito

Compito: monitorare la disponibilità del tuo sito ogni 5 minuti, simulando richieste da utenti reali (non dall'IP del server).

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERRORE - HTTP $http_code" >> "$LOG_FILE"
        # Invia un avviso (ad esempio, tramite l'API di Telegram)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=Sito non disponibile: HTTP $http_code"
    fi
    
    sleep 300  # 5 minuti
done

Conclusione

Curl e wget sono strumenti potenti per automatizzare le richieste HTTP, e una corretta configurazione del proxy li rende indispensabili per scraping, monitoraggio e testing. Abbiamo esaminato tutti gli aspetti chiave: dalla sintassi di base a scenari avanzati con rotazione IP, gestione degli errori e randomizzazione delle intestazioni.

Principali conclusioni dall'articolo:

Utilizza il parametro -x in curl e le variabili d'ambiente per configurare il proxy
Scegli il tipo di proxy in base al compito: HTTP per richieste semplici, SOCKS5 per versatilità
Sostituisci sempre lo User-Agent standard con uno realistico di un browser
Implementa la rotazione dei proxy per scraping su larga scala — è fondamentale per eludere i blocchi
Aggiungi gestione degli errori e timeout negli script di produzione
Utilizza pause casuali tra le richieste per simulare il comportamento umano

Per compiti che richiedono un alto livello di anonimato e un rischio minimo di blocchi (scraping di marketplace, verifica della pubblicità, monitoraggio dei concorrenti), si consiglia di utilizzare proxy residenziali. Hanno IP di utenti reali, rendendo le tue richieste indistinguibili dal traffico normale e riducendo notevolmente la probabilità di finire nelle liste di blocco.

Ora hai un insieme completo di strumenti e conoscenze per lavorare efficacemente con i proxy in curl e wget. Applica queste tecniche nei tuoi progetti, adatta gli esempi a compiti specifici e scala l'automazione senza paura di blocchi.

Impostazione del proxy in curl e wget: guida completa con esempi per il parsing