Proxy per l'addestramento AI: come raccogliere milioni di dati per modelli senza blocchi

L'addestramento dei modelli AI richiede enormi volumi di dati: testi, immagini, video, informazioni strutturate dai siti web. Il problema è che durante lo scraping massivo, i siti bloccano rapidamente gli indirizzi IP, considerando l'attività come bot. In questo articolo analizzeremo come organizzare correttamente la raccolta di dati tramite proxy, quale tipo di IP scegliere per diverse attività e come configurare l'infrastruttura per un funzionamento stabile.

Perché sono necessari i proxy per l'addestramento AI

I moderni modelli linguistici come GPT, LLaMA o Claude vengono addestrati su miliardi di token di testo. I modelli di visione artificiale richiedono decine di milioni di immagini. I sistemi di raccomandazione analizzano il comportamento degli utenti su migliaia di siti. Tutti questi dati devono essere ottenuti da qualche parte.

Il problema principale è che i siti si proteggono attivamente dallo scraping massivo. Se invii più di 100 richieste al minuto da un solo IP, verrai bloccato dopo 5-10 minuti. Le ragioni dei blocchi sono:

• Rate limiting: limitazione del numero di richieste da un solo IP (di solito 10-60 richieste al minuto)
• Sistemi anti-bot: Cloudflare, Akamai, PerimeterX analizzano il comportamento e bloccano attività sospette
• Limitazioni geografiche: parte del contenuto è disponibile solo da determinati paesi
• Protezione dai concorrenti: i marketplace e gli aggregatori bloccano la raccolta massiva di prezzi e prodotti

I proxy risolvono questo problema, distribuendo le richieste attraverso migliaia di indirizzi IP diversi. Invece di 1000 richieste da un solo IP, effettui 1-2 richieste da ciascuno dei 500-1000 indirizzi diversi — questo sembra l'attività di normali utenti.

Quale tipo di proxy scegliere per la raccolta di dati

Per l'addestramento AI si utilizzano tre tipi di proxy, ognuno con i propri vantaggi e limitazioni. La scelta dipende dalla fonte dei dati, dai volumi e dal budget del progetto.

Proxy Datacenter: velocità per grandi volumi

I proxy datacenter sono indirizzi IP di server in fornitori cloud (AWS, Google Cloud, Hetzner). Il principale vantaggio è la velocità e il basso costo. Un IP datacenter può gestire centinaia di richieste al secondo.

Sono adatti per la raccolta di dati da fonti che non utilizzano protezioni aggressive: API aperti (GitHub, Wikipedia, Stack Overflow), database governativi, siti di notizie senza Cloudflare, pubblicazioni scientifiche. Se il sito fornisce dati senza rendering JavaScript e non verifica il fingerprint del browser — i datacenter funzioneranno.

Lo svantaggio è che molti siti tengono un blacklist degli IP dei datacenter. Instagram, Facebook, Google Search e grandi marketplace bloccano gli IP datacenter praticamente subito. Per tali fonti sono necessari i proxy residenziali.

Proxy Residenziali: bypass di qualsiasi protezione

I proxy residenziali utilizzano indirizzi IP di veri utenti domestici. Per il sito, tale richiesta appare come un normale visitatore da casa. Ciò consente di bypassare Cloudflare, Akamai, raccogliere dati dai social media e piattaforme protette.

I residenziali sono necessari per: Instagram, Facebook, Twitter/X (raccolta di post, commenti, profili), Google Search (scraping dei risultati di ricerca per modelli NLP), marketplace (Amazon, eBay, Wildberries — prodotti, recensioni, prezzi), siti con limitazioni geografiche (contenuto disponibile solo da determinati paesi).

Il costo è più alto — pagamento per traffico ($5-15 per GB). Per risparmiare, utilizza i residenziali solo per fonti critiche, mentre i siti semplici possono essere scrappati tramite datacenter.

Proxy Mobile: per app mobili

I proxy mobili utilizzano IP di operatori mobili (4G/5G). Necessari raramente — principalmente per raccogliere dati da app mobili (TikTok, Instagram app, giochi mobili) o quando il sito distingue tra traffico mobile e desktop.

Il vantaggio degli IP mobili è che gli operatori utilizzano CGNAT (un IP per centinaia di utenti), quindi bloccare tali indirizzi non è conveniente. Ma per la maggior parte delle attività di addestramento AI, i residenziali sono sufficienti.

Tipi di fonti di dati e requisiti per i proxy

Diversi tipi di dati richiedono approcci diversi ai proxy. Esaminiamo le fonti popolari per l'addestramento dei modelli AI.

Dati testuali per modelli NLP

Per addestrare modelli linguistici, si raccolgono testi da siti di notizie, forum, blog, social media, Wikipedia e risorse specializzate. I volumi — decine di terabyte di testo.

Una caratteristica dello scraping testuale è che è necessario mantenere la struttura (titoli, paragrafi, metadati). Utilizza browser headless (Puppeteer, Playwright) per siti JavaScript o semplici client HTTP (requests, axios) per pagine statiche.

Immagini per visione artificiale

L'addestramento di modelli di riconoscimento richiede milioni di immagini annotate. Fonti: Google Images, Pinterest, Instagram, stock fotografici specializzati, siti di e-commerce (foto di prodotti).

Il problema è che le immagini pesano molto (dimensione media 200-500 KB), quindi il traffico si consuma rapidamente. Quando si utilizzano proxy residenziali (pagamento per GB), questo è critico. Strategia di ottimizzazione: prima raccogli gli URL delle immagini tramite residenziali, poi scarica i file stessi tramite datacenter o direttamente (se il CDN non verifica il referrer).

Dati strutturati da e-commerce

I dati su prodotti, prezzi, recensioni vengono utilizzati per addestrare sistemi di raccomandazione e modelli di pricing. Fonti: Amazon, eBay, Wildberries, Ozon, AliExpress.

Tutti i grandi marketplace utilizzano Cloudflare o i propri sistemi anti-bot. Sono assolutamente necessari proxy residenziali con rotazione. Inoltre, è importante avere un fingerprint del browser corretto — utilizza strumenti come puppeteer-extra-plugin-stealth per mascherare l'automazione.

Dati video e audio

YouTube, TikTok, piattaforme di podcast — fonti per addestrare modelli di riconoscimento vocale e video. Il problema è l'enorme traffico (un video = centinaia di MB). Per tali attività, i proxy residenziali non sono economicamente vantaggiosi.

Soluzione: utilizza residenziali solo per ottenere metadati e link ai video, mentre il download fallo tramite datacenter o strumenti speciali come yt-dlp (che possono bypassare le limitazioni di YouTube senza proxy).

Strategie di rotazione IP per diversi volumi

La rotazione degli IP è un punto chiave per uno scraping stabile. Una configurazione errata porterà a blocchi o a sovrapprezzo per il traffico.

Rotazione su richiesta (proxy rotanti)

Ogni richiesta passa attraverso un nuovo IP. Adatto per scraping massivo di diversi siti, quando non è necessario mantenere la sessione. Ad esempio, raccogliere testi da 10000 diversi siti di notizie — ogni sito vede solo 1-2 richieste da un solo IP.

import requests

# Proxy rotante - ogni richiesta un nuovo IP
proxies = {
    'http': 'http://username:password@rotating.proxycove.com:12345',
    'https': 'http://username:password@rotating.proxycove.com:12345'
}

urls = ['https://site1.com', 'https://site2.com', ...]
for url in urls:
    response = requests.get(url, proxies=proxies)
    # Ogni richiesta viene effettuata con un nuovo IP
    parse_data(response.text)

Vantaggio — massima protezione dai blocchi. Svantaggio — impossibile lavorare con siti che richiedono autenticazione o salvataggio di cookies.

Rotazione temporale (sessioni sticky)

L'IP viene mantenuto per 5-30 minuti, poi cambia. Adatto per scraping di un singolo sito con paginazione, quando è necessario passare attraverso le pagine 1, 2, 3... mantenendo la sessione.

import requests
import time

# Sessione sticky - l'IP viene mantenuto per 10 minuti
session_id = generate_random_string()  # ID sessione unico
proxies = {
    'http': f'http://username-session-{session_id}:password@sticky.proxycove.com:12345'
}

# Tutte le richieste per 10 minuti vengono effettuate da un solo IP
for page in range(1, 100):
    url = f'https://site.com/catalog?page={page}'
    response = requests.get(url, proxies=proxies)
    parse_page(response.text)
    time.sleep(2)  # ritardo tra le richieste

Imposta il tempo della sessione in base al rate limit del sito. Se il limite è di 60 richieste al minuto, imposta la sessione a 1-2 minuti e non effettuare più di 50 richieste.

Pool di IP statici

Ottieni un elenco di 100-1000 IP e gestisci tu stesso la distribuzione delle richieste. Adatto per scenari complessi, dove è necessario un controllo completo: scraping parallelo di diverse sezioni del sito, bilanciamento del carico, logica di rotazione personalizzata.

import requests
from itertools import cycle

# Pool di 500 IP statici
ip_pool = [
    'http://user:pass@ip1.proxycove.com:12345',
    'http://user:pass@ip2.proxycove.com:12345',
    # ... 500 indirizzi
]

proxy_cycle = cycle(ip_pool)

for url in urls:
    proxy = next(proxy_cycle)  # prendi il prossimo IP dal pool
    response = requests.get(url, proxies={'http': proxy, 'https': proxy})
    parse_data(response.text)

Questo approccio offre la massima flessibilità, ma richiede più codice per la gestione degli errori (se l'IP è bloccato, deve essere escluso dal pool).

Bypass dei sistemi anti-bot durante lo scraping

I proxy risolvono il problema dei blocchi IP, ma i siti moderni analizzano decine di parametri per identificare i bot. Anche con IP residenziali, potresti essere bloccato se il fingerprint del browser indica automazione.

Cosa controllano i sistemi anti-bot

• User-Agent: deve corrispondere a un browser reale (Chrome, Firefox), non deve contenere le parole "headless" o "bot"
• Headers: il set di intestazioni deve essere tipico per un browser (Accept, Accept-Language, Accept-Encoding, Referer)
• Fingerprint TLS: i parametri della connessione SSL variano tra browser e script
• Fingerprint JavaScript: WebGL, Canvas, AudioContext, font, plugin, risoluzione dello schermo
• Comportamento: movimenti del mouse, velocità di scorrimento, clic (per siti con rendering JavaScript)

Strumenti per mascherare l'automazione

Per bypassare le protezioni avanzate, utilizza browser headless con plugin di mascheramento:

// Puppeteer con plugin stealth
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    headless: true,
    args: [
        '--proxy-server=http://username:password@residential.proxycove.com:12345',
        '--disable-blink-features=AutomationControlled'
    ]
});

const page = await browser.newPage();
// Imposta un viewport realistico
await page.setViewport({ width: 1920, height: 1080 });

// Aggiungi ritardi casuali
await page.goto('https://protected-site.com');
await page.waitForTimeout(2000 + Math.random() * 3000);

const data = await page.evaluate(() => {
    return document.querySelector('.data').innerText;
});

await browser.close();

Per Python, utilizza Playwright con impostazioni simili o Selenium con undetected-chromedriver — una libreria che patcha automaticamente ChromeDriver per bypassare il rilevamento.

Bypass di Cloudflare e altri WAF

Cloudflare utilizza una sfida JavaScript per verificare il browser. I semplici client HTTP (requests, axios) non possono superarla. Soluzioni:

• Browser headless: Puppeteer/Playwright con plugin stealth superano la maggior parte delle sfide
• Soluzioni pronte: librerie come cloudscraper (Python) o puppeteer-extra-plugin-recaptcha
• Servizi di bypass: API specializzate (FlareSolverr, Anti-Captcha) risolvono le sfide per te

Importante: anche con un fingerprint corretto, fai pause tra le richieste. Inviare 100 richieste al secondo con un fingerprint del browser perfetto appare comunque sospetto. La velocità ottimale è di 10-30 richieste al minuto da un solo IP.

Architettura dell'infrastruttura per la raccolta di dati

Quando si raccolgono dati per l'addestramento AI su scala industriale, è necessaria un'architettura ben progettata. Un semplice script su un server non sarà in grado di gestire il parsing di terabyte di dati.

Componenti del sistema di raccolta

Esempio di architettura in Python

# worker.py - processo di scraping
import redis
import requests
import json
from datetime import datetime

# Connessione a Redis (coda di attività)
queue = redis.Redis(host='redis-server', port=6379)
# Pool di proxy
proxies_pool = load_proxies_from_config()

while True:
    # Preleva un'attività dalla coda
    task = queue.blpop('parsing_queue', timeout=5)
    if not task:
        continue
    
    url = task[1].decode('utf-8')
    proxy = get_next_proxy(proxies_pool)
    
    try:
        response = requests.get(
            url, 
            proxies={'http': proxy, 'https': proxy},
            timeout=30,
            headers={'User-Agent': get_random_user_agent()}
        )
        
        # Parsing dei dati
        data = parse_html(response.text)
        
        # Salvataggio in S3
        save_to_s3(data, f'data/{datetime.now().isoformat()}/{hash(url)}.json')
        
        # Log di successo
        log_success(url, proxy)
        
    except Exception as e:
        # In caso di errore, restituisci l'attività alla coda
        queue.rpush('parsing_queue', url)
        log_error(url, proxy, str(e))
        mark_proxy_as_failed(proxy)

Questa architettura consente di scalare orizzontalmente: basta aggiungere nuovi server con lavoratori. Se un lavoratore fallisce, gli altri continuano a funzionare.

Strumenti per l'automazione della raccolta

Per lo scraping industriale si utilizzano framework specializzati che risolvono compiti standard out-of-the-box.

Scrapy — framework per Python

Scrapy è lo strumento più popolare per il web scraping in Python. Supporta out-of-the-box: scraping parallelo (centinaia di richieste simultanee), retry automatici in caso di errori, middleware per la rotazione di proxy e User-Agent, esportazione in JSON, CSV, XML, database.

# settings.py - configurazione di Scrapy con proxy
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.proxycove.com:12345',
    'http://user:pass@proxy2.proxycove.com:12345',
    # ... elenco di proxy
]

DOWNLOADER_MIDDLEWARES = {
    'rotating_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_proxies.middlewares.BanDetectionMiddleware': 620,
}

# Concorrenza
CONCURRENT_REQUESTS = 100
DOWNLOAD_DELAY = 0.5  # ritardo tra le richieste

Scrapy è adatto per siti statici (HTML senza JavaScript). Per siti dinamici, utilizza Scrapy + Splash (browser headless) o passa a Playwright.

Crawlee — framework per Node.js

Crawlee (precedentemente Apify SDK) è l'equivalente di Scrapy per JavaScript. Vantaggio — lavoro nativo con Puppeteer e Playwright, rotazione di proxy integrata, gestione automatica della coda, velocità di scraping adattativa (rallenta in caso di errori).

import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: [
        'http://user:pass@proxy1.proxycove.com:12345',
        'http://user:pass@proxy2.proxycove.com:12345',
    ],
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxConcurrency: 50,
    requestHandler: async ({ page, request }) => {
        await page.waitForSelector('.data');
        const data = await page.$$eval('.item', items => 
            items.map(item => ({
                title: item.querySelector('h2').innerText,
                price: item.querySelector('.price').innerText
            }))
        );
        await saveData(data);
    },
});

await crawler.run(['https://site.com/catalog']);

Apache Nutch — per crawling su larga scala

Se hai bisogno di raccogliere dati da tutto il web (come i motori di ricerca), utilizza Apache Nutch. È un crawler distribuito che funziona sopra Hadoop. Può gestire petabyte di dati, scopre automaticamente nuove pagine tramite link, supporta la politica di crawling (robots.txt, sitemap.xml).

Nutch è più complesso da configurare, ma è indispensabile per raccogliere dataset simili a Common Crawl. Per lavorare con i proxy, utilizza il plugin proxy-rotator.

Ottimizzazione della velocità e dei costi

La raccolta di dati per l'addestramento AI è un'attività costosa. Con volumi in terabyte, le spese per i proxy possono raggiungere decine di migliaia di dollari al mese. Esaminiamo come ottimizzare i costi senza compromettere la qualità.

Combina i tipi di proxy

Non utilizzare i residenziali per tutte le attività. Dividi le fonti in tre categorie:

• Senze protezione: proxy datacenter ($0.5-2/IP) — API aperti, siti semplici, database governativi
• Protezione media: residenziali rotanti ($5-10/GB) — siti di notizie con Cloudflare, forum
• Alta protezione: residenziali con sessioni sticky ($10-15/GB) — social media, marketplace

Esempio: stai scrappando 100 siti di notizie. 70 di essi funzionano senza Cloudflare — utilizza i datacenter. 30 con protezione — residenziali. Il risparmio sarà del 60-70% del budget per i proxy.

Cache delle richieste

Se stai scrappando lo stesso sito più volte (ad esempio, raccolta quotidiana di notizie), memorizza nella cache le pagine immutabili. Utilizza Redis o uno storage locale per la cache HTML.

import hashlib
import redis

cache = redis.Redis(host='localhost', port=6379)

def fetch_with_cache(url, proxies):
    # Controlla la cache
    cache_key = hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(cache_key)
    
    if cached:
        return cached.decode('utf-8')
    
    # Se non è nella cache - fai la richiesta
    response = requests.get(url, proxies=proxies)
    html = response.text
    
    # Salva nella cache per 24 ore
    cache.setex(cache_key, 86400, html)
    return html

Ottimizza il traffico

Quando utilizzi proxy residenziali (pagamento per GB), è fondamentale ridurre il volume del traffico:

• Disabilita il caricamento di immagini, CSS, font se non necessari (in Puppeteer: page.setRequestInterception)
• Utilizza la compressione (gzip, brotli) — la maggior parte dei proxy la supporta
• Scrappa solo gli elementi necessari — non scaricare l'intera pagina se ti serve solo un blocco
• Per le API utilizza JSON invece di HTML (5-10 volte meno traffico)

Distribuisci il carico nel tempo

Molti siti hanno carichi diversi durante il giorno. Scrappa nelle ore notturne (secondo l'orario del server del sito) — minore è la probabilità di incorrere nel rate limiting. Considera anche i fine settimana — il sabato e la domenica la protezione potrebbe essere più debole.

Monitora le metriche

Monitora i KPI per l'ottimizzazione:

Conclusione

La raccolta di dati per l'addestramento dei modelli AI è un compito complesso che richiede la scelta corretta dei proxy, la configurazione della rotazione, il bypass delle protezioni e l'ottimizzazione dei costi. Punti chiave:

• Per fonti semplici (API, siti senza protezione) utilizza proxy datacenter — sono veloci e economici
• Per piattaforme protette (social media, marketplace, siti con Cloudflare) sono obbligatori i proxy residenziali
• Configura la rotazione in base all'attività: su richiesta per scraping massivo di diversi siti, sessioni sticky per lavorare con un solo sito
• Utilizza browser headless con plugin di mascheramento per bypassare i sistemi anti-bot
• Costruisci un'architettura scalabile con code di attività e lavoratori paralleli
• Ottimizza le spese: combina i tipi di proxy, memorizza nella cache le richieste, riduci il traffico

Con la configurazione corretta, sarai in grado di raccogliere terabyte di dati in modo stabile ed economico. Inizia con un piccolo progetto pilota su 10-20 fonti, affina il processo, poi scala a volumi industriali.

Se prevedi di raccogliere dati da piattaforme protette (social media, e-commerce, siti con sistemi anti-bot), ti consigliamo di utilizzare proxy residenziali — forniscono un alto livello di fiducia e una percentuale minima di blocchi. Per fonti semplici e API, sono sufficienti i proxy datacenter, che offrono la massima velocità a basso costo.