Come configurare il timeout e la logica di retry per i proxy: protezione contro la perdita di dati durante il parsing

Quando lavori con proxy per il parsing di marketplace, automazione dei social media o raccolta di dati, il problema più comune è rappresentato da richieste bloccate e dati persi. Il server proxy potrebbe non rispondere in tempo, la connessione potrebbe interrompersi e il tuo script potrebbe bloccarsi per diversi minuti. Di conseguenza, perdi tempo, dati e denaro.

In questa guida ti mostrerò come configurare correttamente timeout e retry logic per lavorare con i proxy. Scoprirai quali valori di timeout utilizzare per diverse attività, come riconnettersi automaticamente in caso di errori e come non perdere nessuna richiesta. L'articolo è adatto sia a chi scrive codice in Python, sia a chi utilizza strumenti di parsing pronti all'uso.

Perché il timeout è critico quando si lavora con i proxy

Immagina una situazione: hai avviato un parser di prezzi su Wildberries per 10.000 prodotti. Lo script funziona tramite proxy per non essere bannato. Tutto procede bene, ma alla 523ª richiesta il server proxy smette di rispondere — potrebbe essere sovraccarico o temporaneamente non disponibile. Senza un timeout configurato, il tuo script attenderà una risposta indefinitamente (o finché non scade il timeout di sistema di 2-5 minuti). Di conseguenza, il parsing si interrompe, perdi tempo e, quando ti accorgi del problema, potrebbero passare diverse ore.

Il timeout è il tempo massimo di attesa per una risposta dal server. Se il server non risponde entro questo tempo, la richiesta viene interrotta e puoi riprovare con un altro proxy oppure registrare l'errore nel log. Questo è particolarmente importante quando si lavora con i proxy, perché:

• I server proxy possono essere instabili — soprattutto quelli pubblici o economici. Anche i proxy residenziali di qualità a volte perdono la connessione perché un utente reale si è disconnesso da Internet.
• Il sito target può bloccare l'IP — se il proxy è stato bannato, non risponderà affatto o risponderà molto lentamente (mostrando un captcha o un redirect).
• Le latenze di rete sono imprevedibili — soprattutto quando si utilizzano proxy di altri paesi. La richiesta potrebbe passare attraverso diversi nodi intermedi.
• Le operazioni di massa richiedono stabilità — se stai analizzando 100.000 pagine o gestendo 50 account Instagram, anche l'1% di richieste bloccate corrisponde a 1.000 operazioni perse.

Senza timeout configurati correttamente, il tuo script spenderà tempo ad attendere proxy non disponibili invece di passare a quelli funzionanti. Questo influisce direttamente sulla velocità di esecuzione e sulla stabilità del risultato.

Tipi di timeout: connect, read e total timeout

Esistono tre principali tipi di timeout che è necessario comprendere e configurare separatamente. Molti sviluppatori principianti e utenti di parser configurano solo un timeout generale, il che porta a problemi.

1. Connect timeout (timeout di connessione)

Questo è il tempo assegnato per stabilire una connessione con il server proxy. Se entro questo tempo la connessione non viene stabilita, la richiesta viene interrotta. Il connect timeout è responsabile della fase iniziale di handshake (TCP handshake) tra il tuo client e il proxy.

Quando scatta: Il server proxy è non disponibile, sovraccarico o l'IP è bloccato da un firewall.

Valori consigliati:

• Per i proxy di data center veloci: 3-5 secondi
• Per i proxy residenziali: 5-10 secondi
• Per i proxy mobili: 10-15 secondi (internet mobile è più lento)

2. Read timeout (timeout di lettura)

Questo è il tempo di attesa per una risposta dal server target dopo che la connessione con il proxy è già stata stabilita. Se il server non inizia a restituire dati entro questo tempo, la richiesta viene interrotta. Il read timeout protegge da situazioni in cui il server ha accettato la richiesta, ma è "bloccato" e non restituisce una risposta.

Quando scatta: Il sito target elabora lentamente la richiesta, è sovraccarico o rallenta intenzionalmente richieste sospette.

Valori consigliati:

• Per il parsing di pagine semplici (HTML): 10-15 secondi
• Per il parsing con rendering JavaScript: 30-60 secondi
• Per richieste API: 5-10 secondi
• Per il download di file di grandi dimensioni: 120+ secondi

3. Total timeout (timeout totale)

Questo è il tempo massimo per l'esecuzione dell'intera richiesta dall'inizio alla fine, inclusa la connessione, l'invio della richiesta, la ricezione e la lettura della risposta. Il total timeout è un "interruttore di emergenza" che garantisce che nessuna richiesta venga eseguita per più tempo del previsto.

Quando utilizzare: Quando è importante che ogni richiesta rientri in limiti di tempo rigorosi (ad esempio, durante il parsing in tempo reale per l'arbitraggio).

Formula: Total timeout = Connect timeout + Read timeout + margine del 20-30%

Valori ottimali di timeout per diverse attività

I valori corretti dei timeout dipendono dalla tua attività, dal tipo di proxy e dal sito target. Timeout troppo brevi porteranno a un gran numero di errori falsi (il proxy funziona, ma lo scarti). Timeout troppo lunghi porteranno a perdere tempo ad aspettare proxy morti.

Retry logic: come configurare correttamente i tentativi

Il timeout risolve il problema delle richieste bloccate, ma non risolve il problema della perdita di dati. Se il proxy non risponde, ricevi semplicemente un errore e perdi quella richiesta. È per questo che la retry logic è fondamentale.

La retry logic è la ripetizione automatica della richiesta in caso di errore. I principi fondamentali per una corretta configurazione sono:

1. Definisci quali errori richiedono una ripetizione

Non tutti gli errori devono essere ripetuti. Ad esempio:

• Devono essere ripetuti: Timeout, Connection refused, Proxy error, 502/503/504 (errori temporanei del server), Rate limiting (429)
• Non devono essere ripetuti: 404 (pagina non trovata), 403 (accesso negato permanentemente), 401 (autenticazione non valida), errori di validazione dei dati

2. Configura il numero di tentativi

Il numero ottimale di retry dipende dalla criticità dei dati:

• Per attività non critiche (parsing per analisi): 2-3 tentativi
• Per attività importanti (monitoraggio dei prezzi dei concorrenti): 3-5 tentativi
• Per attività critiche (gestione degli account pubblicitari): 5-10 tentativi

3. Utilizza l'exponential backoff (ritardo esponenziale)

Non ripetere la richiesta immediatamente — questo potrebbe aggravare il problema (ad esempio, se il server è sovraccarico). Utilizza un ritardo crescente tra i tentativi:

• 1° tentativo: subito
• 2° tentativo: dopo 1-2 secondi
• 3° tentativo: dopo 4-5 secondi
• 4° tentativo: dopo 10-15 secondi

Formula: ritardo = ritardo_base * (2 ^ numero_tentativo). Ad esempio: 1 sec, 2 sec, 4 sec, 8 sec, 16 sec.

4. Rotazione dei proxy durante i tentativi

La regola più importante: durante un tentativo ripeti utilizzando un altro proxy dal tuo pool. Se un proxy non è riuscito a eseguire la richiesta, la probabilità che funzioni al secondo tentativo è bassa. Un altro proxy, invece, avrà una probabilità maggiore di riuscita.

Questo è particolarmente importante quando si lavora con proxy residenziali, dove hai un pool di centinaia o migliaia di indirizzi IP. Ad ogni retry prendi un nuovo IP casuale dal pool.

Esempi di configurazione di timeout e retry in Python

Consideriamo esempi pratici di implementazione di timeout e retry logic in Python utilizzando librerie popolari.

Esempio 1: Configurazione di base con requests

La libreria requests è la più popolare per le richieste HTTP in Python. Ecco come configurare timeout e un semplice retry:

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Configurazione della retry logic
retry_strategy = Retry(
    total=5,  # Massimo 5 tentativi
    backoff_factor=1,  # Ritardo: 1, 2, 4, 8, 16 secondi
    status_forcelist=[429, 500, 502, 503, 504],  # Codici di errore per retry
    allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE"]
)

adapter = HTTPAdapter(max_retries=retry_strategy)
session = requests.Session()
session.mount("http://", adapter)
session.mount("https://", adapter)

# Configurazione del proxy
proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

# Esecuzione della richiesta con timeout
try:
    response = session.get(
        'https://www.wildberries.ru/catalog/electronics',
        proxies=proxies,
        timeout=(5, 15)  # connect timeout 5 sec, read timeout 15 sec
    )
    print(f"Successo! Stato: {response.status_code}")
    print(f"Dimensione della risposta: {len(response.content)} byte")
except requests.exceptions.Timeout:
    print("Errore: timeout superato")
except requests.exceptions.ProxyError:
    print("Errore: problema con il proxy")
except requests.exceptions.RequestException as e:
    print(f"Errore di richiesta: {e}")

In questo esempio abbiamo configurato un retry automatico a livello di sessione. In caso di errori 429, 500, 502, 503, 504, la libreria ripeterà automaticamente la richiesta fino a 5 volte con un ritardo esponenziale.

Esempio 2: Rotazione dei proxy durante il retry

Un esempio più avanzato con rotazione dei proxy dal pool ad ogni tentativo:

import requests
import random
import time

# Pool di proxy (sostituisci con i tuoi proxy reali)
PROXY_POOL = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
    'http://user:pass@proxy4.example.com:8080',
]

def make_request_with_retry(url, max_retries=5, base_delay=1):
    """
    Esegue una richiesta con retry e rotazione dei proxy
    """
    for attempt in range(max_retries):
        # Seleziona un proxy casuale dal pool
        proxy = random.choice(PROXY_POOL)
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(
                url,
                proxies=proxies,
                timeout=(5, 15),
                headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
            )
            
            # Controlla il codice di stato
            if response.status_code == 200:
                return response
            elif response.status_code in [429, 500, 502, 503, 504]:
                # Errore temporaneo - ripeti
                print(f"Tentativo {attempt + 1}: codice {response.status_code}, ripetendo...")
            else:
                # Errore permanente - interrompi
                print(f"Errore {response.status_code}, interrompo i tentativi")
                return None
                
        except (requests.exceptions.Timeout, 
                requests.exceptions.ProxyError,
                requests.exceptions.ConnectionError) as e:
            print(f"Tentativo {attempt + 1}: errore {type(e).__name__}, ripetendo...")
        
        # Se non è l'ultimo tentativo - aspetta con ritardo esponenziale
        if attempt < max_retries - 1:
            delay = base_delay * (2 ** attempt)
            print(f"Attesa di {delay} secondi prima del prossimo tentativo...")
            time.sleep(delay)
    
    print("Tutti i tentativi esauriti")
    return None

# Utilizzo
result = make_request_with_retry('https://www.ozon.ru/category/smartfony-15502/')
if result:
    print(f"Successo! Ricevuti {len(result.content)} byte di dati")
else:
    print("Impossibile eseguire la richiesta")

Questo codice seleziona un nuovo proxy casuale dal pool ad ogni tentativo, aumentando significativamente la probabilità di successo della richiesta.

Esempio 3: Utilizzo della libreria tenacity

Per una gestione più flessibile della retry logic, puoi utilizzare la libreria specializzata tenacity:

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
import requests

@retry(
    stop=stop_after_attempt(5),  # Massimo 5 tentativi
    wait=wait_exponential(multiplier=1, min=1, max=30),  # Ritardo esponenziale 1-30 sec
    retry=retry_if_exception_type((requests.exceptions.Timeout, 
                                   requests.exceptions.ProxyError,
                                   requests.exceptions.ConnectionError))
)
def fetch_with_proxy(url, proxy):
    """
    Funzione con retry automatico tramite decoratore
    """
    proxies = {'http': proxy, 'https': proxy}
    response = requests.get(url, proxies=proxies, timeout=(5, 15))
    response.raise_for_status()  # Genera un'eccezione in caso di errore HTTP
    return response

# Utilizzo
try:
    result = fetch_with_proxy(
        'https://www.avito.ru/rossiya/telefony',
        'http://user:pass@proxy.example.com:8080'
    )
    print(f"Successo! Stato: {result.status_code}")
except Exception as e:
    print(f"Impossibile eseguire la richiesta dopo tutti i tentativi: {e}")

La libreria tenacity offre possibilità di configurazione della retry tramite decoratori. Installazione: pip install tenacity

Soluzioni pronte per il parsing senza codice

Se non sei uno sviluppatore o desideri risparmiare tempo nello sviluppo, esistono strumenti di parsing pronti all'uso con supporto integrato per timeout e retry logic. Non è necessario scrivere codice — basta configurare i parametri nell'interfaccia grafica.

Octoparse

Un popolare parser visivo per Windows e Mac. Configurazione di timeout e retry:

• Apri le impostazioni del task → Opzioni avanzate
• Page Load Timeout: imposta 20-30 secondi
• Ajax Timeout: 10-15 secondi per contenuti dinamici
• Retry Times: 3-5 tentativi in caso di errore
• Nelle impostazioni del proxy puoi caricare un elenco e abilitare la rotazione automatica

ParseHub

Parser cloud con piano gratuito. Configurazione:

• Impostazioni → Avanzate → Page Load Delay: 5-10 secondi
• Request Timeout: 30 secondi
• Retry Failed Requests: attiva, 3 tentativi
• Supporta i proxy tramite le impostazioni del progetto

Apify

Piattaforma per l'automazione delle attività web con attori (script) pronti per il parsing di siti popolari. Molti attori per il parsing di marketplace (Wildberries, Ozon) hanno già impostazioni ottimali integrate per timeout e retry. Devi solo:

• Selezionare un attore pronto per il sito desiderato
• Specificare il proxy (supporta integrazioni con fornitori di proxy)
• Avviare il task — tutto il resto è configurato automaticamente

Browser anti-detect per automazione

Se lavori con social media o piattaforme pubblicitarie tramite Dolphin Anty, AdsPower o Multilogin, il timeout si configura nel profilo del browser:

• Dolphin Anty: Impostazioni profilo → Proxy → Timeout: 10-15 secondi
• AdsPower: Impostazioni Proxy → Connection Timeout: 10 secondi, Read Timeout: 20 secondi
• Multilogin: Browser Profile → Network → Proxy Timeout: 15 secondi

Durante l'automazione tramite questi browser (ad esempio, script Selenium), il timeout del proxy viene ereditato dalle impostazioni del profilo, ma puoi anche impostare timeout aggiuntivi a livello di script.

Errori comuni nella configurazione dei timeout

Anche gli sviluppatori esperti e gli specialisti del parsing commettono errori tipici quando lavorano con timeout e retry. Ecco i più comuni:

Errore 1: Assenza di timeout

Molte librerie non impostano un timeout di default o impostano un valore molto alto (diverse minuti). Se non hai specificato un timeout esplicitamente, il tuo script potrebbe bloccarsi per lungo tempo.

Soluzione: Specifica sempre esplicitamente il timeout in ogni richiesta. È meglio ricevere un errore dopo 15 secondi piuttosto che aspettare 5 minuti.

Errore 2: Stesso proxy per tutti i retry

Se il proxy non ha risposto al primo tentativo, la probabilità di successo al secondo tentativo con lo stesso proxy è molto bassa. Molti dimenticano di ruotare i proxy tra i tentativi.

Soluzione: Utilizza un nuovo proxy dal pool ad ogni retry. Questo è fondamentale per un alto tasso di successo.

Errore 3: Timeout troppo brevi per proxy lenti

I proxy mobili e alcuni residenziali possono essere più lenti dei data center. Se imposti un timeout di 5 secondi per un proxy mobile, riceverai molti errori falsi su IP perfettamente funzionanti.

Soluzione: Considera il tipo di proxy. Per i mobili utilizza un timeout di almeno 10-15 secondi.

Errore 4: Retry infiniti senza limitazione

Alcuni implementano il retry in un ciclo while True senza limitare il numero di tentativi. Se il problema è lato server (ad esempio, è completamente inaccessibile), lo script continuerà a tentare indefinitamente.

Soluzione: Limita sempre il numero di retry (massimo 3-10 tentativi) e registra le richieste non riuscite per un'analisi successiva.

Errore 5: Ignorare il tipo di errore

Non tutti gli errori devono essere ripetuti. Ad esempio, se ricevi un 404 (pagina non trovata), ripetere non ha senso, la pagina semplicemente non esiste. Ma un 503 (servizio temporaneamente non disponibile) ha senso ripetere dopo alcuni secondi.

Soluzione: Analizza il tipo di errore e ripeti solo i problemi temporanei (timeout, errore di connessione, 429, 500, 502, 503, 504).

Errore 6: Mancanza di logging

Senza log non capirai perché le richieste falliscono: è un problema di proxy, di timeout o del sito target?

Soluzione: Registra ogni errore specificando: quale proxy è stato utilizzato, quale timeout era impostato, quanti tentativi sono stati effettuati, quale errore specifico si è verificato. Questo aiuterà a ottimizzare le impostazioni.

Conclusione

La corretta configurazione di timeout e retry logic non è solo un dettaglio tecnico, ma un fattore critico per la stabilità e l'efficacia del lavoro con i proxy. Senza timeout, i tuoi script si bloccheranno su proxy morti, perdendo tempo. Senza retry logic, perderai dati in caso di errori temporanei. E senza rotazione dei proxy durante i tentativi, otterrai un basso tasso di successo anche con un buon pool di IP.

I principali punti chiave di questa guida sono:

• Imposta sempre esplicitamente il timeout: connect timeout 5-10 secondi, read timeout 10-30 secondi a seconda dell'attività
• Utilizza la retry logic con un limite di 3-5 tentativi e ritardo esponenziale
• Ruota i proxy ad ogni tentativo di ripetizione — questo è la chiave per un alto tasso di successo
• Ripeti solo errori temporanei (timeout, 429, 500, 502, 503, 504), non sprecare tentativi su errori permanenti (404, 403)
• Registra tutti gli errori per analisi e ottimizzazione delle impostazioni
• Considera il tipo di proxy: i mobili sono più lenti dei data center, aumenta i timeout di conseguenza

Se lavori con il parsing di marketplace (Wildberries, Ozon, Avito), automazione dei social media o piattaforme pubblicitarie, la stabilità dei proxy influisce direttamente sul tuo risultato. Utilizza proxy di qualità con alto uptime e configura correttamente timeout e retry — questo ti farà risparmiare ore di tempo e migliaia di richieste perse.

Per attività che richiedono la massima stabilità e il minimo numero di errori di timeout, ti consigliamo di provare i proxy di data center — offrono alta velocità di risposta e connessione stabile, particolarmente importante durante il parsing di massa e l'automazione.