Proxies pour l'entraînement de l'IA : comment collecter des millions de données pour des modèles sans blocages

L'entraînement des modèles AI nécessite d'énormes volumes de données — textes, images, vidéos, informations structurées provenant des sites. Le problème est qu'en cas de scraping massif, les sites bloquent rapidement les adresses IP, considérant l'activité comme celle d'un bot. Dans cet article, nous allons examiner comment organiser correctement la collecte de données via des proxies, quel type d'IP choisir pour différentes tâches et comment configurer l'infrastructure pour un fonctionnement stable.

Pourquoi des proxies sont nécessaires pour l'entraînement AI

Les modèles linguistiques modernes comme GPT, LLaMA ou Claude sont formés sur des milliards de tokens de texte. Les modèles de vision par ordinateur nécessitent des dizaines de millions d'images. Les systèmes de recommandation analysent le comportement des utilisateurs sur des milliers de sites. Toutes ces données doivent être obtenues quelque part.

Le principal problème est que les sites se protègent activement contre le scraping massif. Si vous envoyez 100+ requêtes par minute depuis une seule IP, vous serez bloqué en 5 à 10 minutes. Les raisons des blocages :

• Limitation de débit : restriction du nombre de requêtes depuis une seule IP (généralement 10-60 requêtes par minute)
• Systèmes anti-bot : Cloudflare, Akamai, PerimeterX analysent le comportement et bloquent l'activité suspecte
• Restrictions géographiques : une partie du contenu est accessible uniquement depuis certains pays
• Protection contre les concurrents : les marketplaces et agrégateurs bloquent la collecte massive de prix et de produits

Les proxies résolvent ce problème en répartissant les requêtes à travers des milliers d'adresses IP différentes. Au lieu de 1000 requêtes depuis une seule IP, vous faites 1 à 2 requêtes depuis chacune des 500 à 1000 adresses différentes — cela ressemble à l'activité d'utilisateurs ordinaires.

Quel type de proxy choisir pour la collecte de données

Pour l'entraînement AI, trois types de proxies sont utilisés, chacun avec ses avantages et ses limitations. Le choix dépend de la source de données, des volumes et du budget du projet.

Proxies Datacenter : vitesse pour de grands volumes

Les proxies de datacenter sont des adresses IP de serveurs chez des fournisseurs cloud (AWS, Google Cloud, Hetzner). Le principal avantage est la vitesse et le faible coût. Une IP de datacenter peut traiter des centaines de requêtes par seconde.

Ils conviennent pour la collecte de données à partir de sources qui n'utilisent pas de protection agressive : APIs ouvertes (GitHub, Wikipedia, Stack Overflow), bases de données gouvernementales, sites d'actualités sans Cloudflare, publications scientifiques. Si le site fournit des données sans rendu JavaScript et ne vérifie pas l'empreinte du navigateur, les datacenters fonctionneront.

Le inconvénient est que de nombreux sites maintiennent une liste noire des IP de datacenters. Instagram, Facebook, Google Search et les grandes marketplaces bloquent les IP de datacenters presque immédiatement. Pour ces sources, des proxies résidentiels sont nécessaires.

Proxies Résidentiels : contournement de toute protection

Les proxies résidentiels utilisent des adresses IP d'utilisateurs domestiques réels. Pour le site, cette requête ressemble à celle d'un visiteur ordinaire depuis chez lui. Cela permet de contourner Cloudflare, Akamai, et de collecter des données à partir de réseaux sociaux et de plateformes protégées.

Les proxies résidentiels sont nécessaires pour : Instagram, Facebook, Twitter/X (collecte de publications, commentaires, profils), Google Search (parsing des résultats de recherche pour les modèles NLP), marketplaces (Amazon, eBay, Wildberries — produits, avis, prix), sites avec des restrictions géographiques (contenu accessible uniquement depuis certains pays).

Le coût est plus élevé — paiement pour le trafic ($5-15 par Go). Pour économiser, utilisez des résidentiels uniquement pour les sources critiques, et scrapez les sites simples via des datacenters.

Proxies Mobiles : pour les applications mobiles

Les proxies mobiles utilisent des IP d'opérateurs mobiles (4G/5G). Ils sont rarement nécessaires — principalement pour la collecte de données à partir d'applications mobiles (TikTok, Instagram app, jeux mobiles) ou lorsque le site distingue le trafic mobile et de bureau.

L'avantage des IP mobiles est que les opérateurs utilisent CGNAT (une IP pour des centaines d'utilisateurs), donc bloquer ces adresses n'est pas rentable. Mais pour la plupart des tâches d'entraînement AI, les résidentiels suffisent.

Types de sources de données et exigences en matière de proxies

Différents types de données nécessitent différentes approches en matière de proxies. Examinons les sources populaires pour l'entraînement des modèles AI.

Données textuelles pour les modèles NLP

Pour entraîner des modèles linguistiques, on collecte des textes à partir de sites d'actualités, forums, blogs, réseaux sociaux, Wikipedia et ressources spécialisées. Les volumes atteignent des dizaines de téraoctets de texte.

Une caractéristique du parsing textuel est qu'il faut conserver la structure (titres, paragraphes, métadonnées). Utilisez des navigateurs sans tête (Puppeteer, Playwright) pour les sites JavaScript ou des clients HTTP simples (requests, axios) pour les pages statiques.

Images pour la vision par ordinateur

L'entraînement des modèles de reconnaissance nécessite des millions d'images annotées. Sources : Google Images, Pinterest, Instagram, banques d'images spécialisées, sites e-commerce (photos de produits).

Le problème est que les images pèsent beaucoup (taille moyenne de 200-500 Ko), donc le trafic s'épuise rapidement. Lors de l'utilisation de proxies résidentiels (paiement par Go), cela devient critique. Stratégie d'optimisation : commencez par collecter les URL des images via résidentiels, puis téléchargez les fichiers eux-mêmes via des datacenters ou directement (si le CDN ne vérifie pas le référent).

Données structurées des e-commerce

Les données sur les produits, les prix, les avis sont utilisées pour entraîner des systèmes de recommandation et des modèles de tarification. Sources : Amazon, eBay, Wildberries, Ozon, AliExpress.

Tous les grandes marketplaces utilisent Cloudflare ou leurs propres systèmes anti-bot. Des proxies résidentiels avec rotation sont absolument nécessaires. De plus, il est important d'avoir la bonne empreinte du navigateur — utilisez des outils comme puppeteer-extra-plugin-stealth pour masquer l'automatisation.

Données vidéo et audio

YouTube, TikTok, plateformes de podcasts — sources pour l'entraînement des modèles de reconnaissance vocale et vidéo. Le problème est le trafic énorme (une vidéo = des centaines de Mo). Pour ces tâches, les proxies résidentiels ne sont pas économiquement viables.

Solution : utilisez des résidentiels uniquement pour obtenir des métadonnées et des liens vers des vidéos, et téléchargez via des datacenters ou des outils spéciaux comme yt-dlp (qui peuvent contourner les restrictions de YouTube sans proxy).

Stratégies de rotation IP pour différents volumes

La rotation des IP est un point clé pour un scraping stable. Une mauvaise configuration entraînera soit des blocages, soit un surcoût pour le trafic.

Rotation à la demande (proxies rotatifs)

Chaque requête passe par une nouvelle IP. Convient pour le scraping massif de différents sites, lorsque la session n'a pas besoin d'être conservée. Par exemple, collecter des textes à partir de 10000 sites d'actualités différents — chaque site ne voit que 1-2 requêtes depuis une seule IP.

import requests

# Proxy rotatif - chaque requête a une nouvelle 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)
    # Chaque requête passe par une nouvelle IP
    parse_data(response.text)

Avantage — protection maximale contre les blocages. Inconvénient — il est impossible de travailler avec des sites nécessitant une authentification ou la conservation des cookies.

Rotation par temps (sessions collantes)

L'IP est conservée pendant 5-30 minutes, puis change. Convient pour le scraping d'un seul site avec pagination, lorsque vous devez passer par les pages 1, 2, 3... en conservant la session.

import requests
import time

# Session collante - l'IP est conservée pendant 10 minutes
session_id = generate_random_string()  # ID de session unique
proxies = {
    'http': f'http://username-session-{session_id}:password@sticky.proxycove.com:12345'
}

# Toutes les requêtes pendant 10 minutes passent par une seule 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)  # délai entre les requêtes

Ajustez le temps de session en fonction de la limitation de débit du site. Si la limite est de 60 requêtes par minute, définissez la session à 1-2 minutes et ne faites pas plus de 50 requêtes.

Pool d'IP statiques

Vous obtenez une liste de 100-1000 IP et gérez vous-même la répartition des requêtes. Convient pour des scénarios complexes, lorsque vous avez besoin d'un contrôle total : scraping parallèle de différentes sections du site, équilibrage de charge, logique de rotation personnalisée.

import requests
from itertools import cycle

# Pool de 500 IP statiques
ip_pool = [
    'http://user:pass@ip1.proxycove.com:12345',
    'http://user:pass@ip2.proxycove.com:12345',
    # ... 500 adresses
]

proxy_cycle = cycle(ip_pool)

for url in urls:
    proxy = next(proxy_cycle)  # prendre la prochaine IP du pool
    response = requests.get(url, proxies={'http': proxy, 'https': proxy})
    parse_data(response.text)

Cette approche offre une flexibilité maximale, mais nécessite plus de code pour gérer les erreurs (si l'IP est bloquée, il faut l'exclure du pool).

Contournement des systèmes anti-bot lors du scraping

Les proxies résolvent le problème des blocages IP, mais les sites modernes analysent des dizaines de paramètres pour identifier les bots. Même avec des IP résidentielles, vous pouvez être bloqué si l'empreinte du navigateur indique une automatisation.

Ce que vérifient les systèmes anti-bot

• User-Agent : doit correspondre à un navigateur réel (Chrome, Firefox), ne doit pas contenir les mots "headless" ou "bot"
• Headers : l'ensemble des en-têtes doit être typique d'un navigateur (Accept, Accept-Language, Accept-Encoding, Referer)
• Empreinte TLS : les paramètres de la connexion SSL diffèrent entre les navigateurs et les scripts
• Empreinte JavaScript : WebGL, Canvas, AudioContext, polices, plugins, résolution d'écran
• Comportement : mouvements de la souris, vitesse de défilement, clics (pour les sites avec rendu JavaScript)

Outils pour masquer l'automatisation

Pour contourner les protections avancées, utilisez des navigateurs sans tête avec des plugins de masquage :

// Puppeteer avec 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();
// Définir un viewport réaliste
await page.setViewport({ width: 1920, height: 1080 });

// Ajouter des délais aléatoires
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();

Pour Python, utilisez Playwright avec des configurations similaires ou Selenium avec undetected-chromedriver — une bibliothèque qui patch automatiquement ChromeDriver pour contourner la détection.

Contournement de Cloudflare et d'autres WAF

Cloudflare utilise un défi JavaScript pour vérifier le navigateur. Les clients HTTP simples (requests, axios) ne peuvent pas le passer. Solutions :

• Navigateur sans tête : Puppeteer/Playwright avec plugin stealth passent la plupart des défis
• Solutions prêtes à l'emploi : bibliothèques comme cloudscraper (Python) ou puppeteer-extra-plugin-recaptcha
• Services de contournement : API spécialisées (FlareSolverr, Anti-Captcha) résolvent les défis pour vous

Important : même avec la bonne empreinte, faites des pauses entre les requêtes. Envoyer 100 requêtes par seconde avec une empreinte de navigateur parfaite semble toujours suspect. La vitesse optimale est de 10-30 requêtes par minute depuis une seule IP.

Architecture de l'infrastructure pour la collecte de données

Lors de la collecte de données pour l'entraînement AI à grande échelle, une architecture bien pensée est nécessaire. Un simple script sur un seul serveur ne pourra pas gérer le scraping de téraoctets de données.

Composants du système de collecte

Exemple d'architecture en Python

# worker.py - processus de parsing
import redis
import requests
import json
from datetime import datetime

# Connexion à Redis (file d'attente des tâches)
queue = redis.Redis(host='redis-server', port=6379)
# Pool de proxies
proxies_pool = load_proxies_from_config()

while True:
    # Prendre une tâche de la file d'attente
    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()}
        )
        
        # Parser les données
        data = parse_html(response.text)
        
        # Sauvegarder dans S3
        save_to_s3(data, f'data/{datetime.now().isoformat()}/{hash(url)}.json')
        
        # Logger le succès
        log_success(url, proxy)
        
    except Exception as e:
        # En cas d'erreur, renvoyer la tâche dans la file d'attente
        queue.rpush('parsing_queue', url)
        log_error(url, proxy, str(e))
        mark_proxy_as_failed(proxy)

Une telle architecture permet de se mettre à l'échelle horizontalement — il suffit d'ajouter de nouveaux serveurs avec des workers. Si un worker tombe, les autres continuent de fonctionner.

Outils pour automatiser la collecte

Pour le scraping industriel, des frameworks spécialisés sont utilisés, qui résolvent des tâches typiques dès le départ.

Scrapy — framework pour Python

Scrapy est l'outil le plus populaire pour le web scraping en Python. Il prend en charge par défaut : le scraping parallèle (des centaines de requêtes simultanément), les retries automatiques en cas d'erreurs, le middleware pour la rotation des proxies et des User-Agent, l'exportation en JSON, CSV, XML, bases de données.

# settings.py - configuration de Scrapy avec des proxies
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.proxycove.com:12345',
    'http://user:pass@proxy2.proxycove.com:12345',
    # ... liste des proxies
]

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

# Concurrence
CONCURRENT_REQUESTS = 100
DOWNLOAD_DELAY = 0.5  # délai entre les requêtes

Scrapy convient pour les sites statiques (HTML sans JavaScript). Pour les sites dynamiques, utilisez Scrapy + Splash (navigateur sans tête) ou passez à Playwright.

Crawlee — framework pour Node.js

Crawlee (anciennement Apify SDK) est l'équivalent de Scrapy pour JavaScript. L'avantage est le travail natif avec Puppeteer et Playwright, la rotation intégrée des proxies, la gestion automatique de la file d'attente, la vitesse de scraping adaptative (ralentit en cas d'erreurs).

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 — pour le crawling à grande échelle

Si vous devez collecter des données sur l'ensemble d'Internet (comme les moteurs de recherche), utilisez Apache Nutch. C'est un crawler distribué fonctionnant sur Hadoop. Il peut traiter des pétaoctets de données, découvre automatiquement de nouvelles pages par des liens, et prend en charge la politique de crawling (robots.txt, sitemap.xml).

Nutch est plus complexe à configurer, mais indispensable pour la collecte de jeux de données similaires à Common Crawl. Pour travailler avec des proxies, utilisez le plugin proxy-rotator.

Optimisation de la vitesse et des coûts

La collecte de données pour l'entraînement AI est une entreprise coûteuse. Avec des volumes en téraoctets, les dépenses pour les proxies peuvent atteindre des dizaines de milliers de dollars par mois. Voyons comment optimiser les coûts sans sacrifier la qualité.

Combinez les types de proxies

N'utilisez pas de résidentiels pour toutes les tâches. Divisez les sources en trois catégories :

• Sans protection : proxies de datacenter ($0.5-2/IP) — APIs ouvertes, sites simples, bases de données gouvernementales
• Protection moyenne : résidentiels rotatifs ($5-10/Go) — sites d'actualités avec Cloudflare, forums
• Haute protection : sessions collantes résidentielles ($10-15/Go) — réseaux sociaux, marketplaces

Exemple : vous scrapez 100 sites d'actualités. 70 d'entre eux fonctionnent sans Cloudflare — utilisez des datacenters. 30 avec protection — résidentiels. L'économie sera de 60-70% du budget pour les proxies.

Mettez en cache les requêtes

Si vous scrapez un site plusieurs fois (par exemple, collecte quotidienne d'actualités), mettez en cache les pages immuables. Utilisez Redis ou un stockage local pour le cache HTML.

import hashlib
import redis

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

def fetch_with_cache(url, proxies):
    # Vérifiez le cache
    cache_key = hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(cache_key)
    
    if cached:
        return cached.decode('utf-8')
    
    # Si ce n'est pas dans le cache - faites la requête
    response = requests.get(url, proxies=proxies)
    html = response.text
    
    # Sauvegardez dans le cache pendant 24 heures
    cache.setex(cache_key, 86400, html)
    return html

Optimisez le trafic

Lors de l'utilisation de proxies résidentiels (paiement par Go), il est critique de réduire le volume de trafic :

• Désactivez le téléchargement d'images, CSS, polices si elles ne sont pas nécessaires (dans Puppeteer : page.setRequestInterception)
• Utilisez la compression (gzip, brotli) — la plupart des proxies le supportent
• Scrapez uniquement les éléments nécessaires — ne téléchargez pas toute la page si un seul bloc est requis
• Pour les APIs, utilisez JSON au lieu de HTML (5-10 fois moins de trafic)

Répartissez la charge dans le temps

De nombreux sites ont une charge différente tout au long de la journée. Scrapez pendant les heures nocturnes (selon l'heure du serveur du site) — moins de chances de tomber sous la limitation de débit. Prenez également en compte les week-ends — le samedi et le dimanche, la protection peut être plus faible.

Surveillez les métriques

Suivez les indicateurs clés pour optimiser :

Conclusion

La collecte de données pour l'entraînement des modèles AI est une tâche complexe qui nécessite un choix approprié de proxies, une configuration de rotation, un contournement des protections et une optimisation des coûts. Points clés :

• Pour les sources simples (APIs, sites sans protection), utilisez des proxies de datacenter — ils sont rapides et bon marché
• Pour les plateformes protégées (réseaux sociaux, marketplaces, sites avec Cloudflare), des proxies résidentiels sont obligatoires
• Configurez la rotation en fonction de la tâche : à la demande pour le scraping massif de différents sites, sessions collantes pour travailler avec un seul site
• Utilisez des navigateurs sans tête avec des plugins de masquage pour contourner les systèmes anti-bot
• Construisez une architecture évolutive avec des files d'attente de tâches et des workers parallèles
• Optimisez les dépenses : combinez les types de proxies, mettez en cache les requêtes, réduisez le trafic

Avec une configuration correcte, vous pourrez collecter des téraoctets de données de manière stable et économique. Commencez par un petit projet pilote sur 10-20 sources, peaufinez le processus, puis passez à des volumes industriels.

Si vous envisagez de collecter des données à partir de plateformes protégées (réseaux sociaux, e-commerce, sites avec systèmes anti-bot), nous vous recommandons d'utiliser des proxies résidentiels — ils offrent un niveau de confiance élevé et un pourcentage de blocages minimal. Pour les sources simples et les APIs, des proxies de datacenter suffisent, offrant une vitesse maximale à faible coût.