Aperçu

Scrapy est un puissant framework Python pour le web scraping à grande échelle. Ce tutoriel montre comment intégrer les proxies résidentiels rotatifs Dataimpulse dans un projet Scrapy sur Linux, avec un middleware personnalisé pour la rotation, la logique de retry et la prise en charge de SOCKS5. Nous aborderons également la mise à l'échelle avec plusieurs spiders.

Prérequis

Serveur Linux (Ubuntu 20.04+ recommandé)
Python 3.8+
Scrapy installé (pip install scrapy)
Identifiants de proxy résidentiel Dataimpulse (HTTP ou SOCKS5)
Connaissance de base des middleware et des paramètres Scrapy

Architecture

Nous utiliserons un middleware de téléchargement personnalisé pour faire tourner les proxies à chaque requête. Dataimpulse fournit un endpoint rotatif (un seul host:port qui fait tourner les IP automatiquement) ou une liste d'endpoints de session sticky. Consultez votre tableau de bord Dataimpulse pour le format exact de l'endpoint.

Étapes

Configurer un projet Scrapy.

pip install scrapy
scrapy startproject advanced_scraper
cd advanced_scraper

Stockez vos identifiants de proxy en toute sécurité. Créez un fichier .env (et ajoutez-le à .gitignore) ou exportez des variables d'environnement :

export DAI_PROXY_HOST="votre-proxy-host"
export DAI_PROXY_PORT="votre-proxy-port"
export DAI_PROXY_USER="votre-nom-utilisateur"
export DAI_PROXY_PASS="votre-mot-de-passe"

Créez un middleware proxy personnalisé. Dans advanced_scraper/middlewares.py, ajoutez :

import os
from scrapy import signals
from scrapy.exceptions import NotConfigured

class DataimpulseProxyMiddleware:
    def __init__(self, proxy_url):
        self.proxy_url = proxy_url

    @classmethod
    def from_crawler(cls, crawler):
        proxy_host = os.getenv('DAI_PROXY_HOST')
        proxy_port = os.getenv('DAI_PROXY_PORT')
        proxy_user = os.getenv('DAI_PROXY_USER')
        proxy_pass = os.getenv('DAI_PROXY_PASS')

        if not all([proxy_host, proxy_port, proxy_user, proxy_pass]):
            raise NotConfigured('Dataimpulse proxy credentials missing')

        proxy_url = f'socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}'
        return cls(proxy_url)

    def process_request(self, request, spider):
        request.meta['proxy'] = self.proxy_url
        # Pour SOCKS5, Scrapy exige le schéma du proxy dans meta
        # Aucun en-tête supplémentaire nécessaire pour SOCKS5

Activez le middleware et configurez les paramètres Scrapy. Dans advanced_scraper/settings.py, mettez à jour :

DOWNLOADER_MIDDLEWARES = {
    'advanced_scraper.middlewares.DataimpulseProxyMiddleware': 543,
    # Désactiver le middleware proxy par défaut s'il est activé
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': None,
}

# Paramètres de retry
RETRY_ENABLED = True
RETRY_TIMES = 5
RETRY_HTTP_CODES = [500, 502, 503, 504, 522, 524, 408, 429]

# Concurrence et délai
CONCURRENT_REQUESTS = 16
DOWNLOAD_DELAY = 0.5

Créez un spider qui utilise le middleware. Dans advanced_scraper/spiders/example.py :

import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = ['https://httpbin.org/ip']

    def parse(self, response):
        yield {'ip': response.json()['origin']}

Lancez-le :

scrapy crawl example

La sortie devrait afficher une IP Dataimpulse.

Implémentez la rotation de proxy pour les sessions sticky (facultatif). Si vous disposez de plusieurs endpoints de session sticky, modifiez le middleware pour sélectionner un proxy aléatoire dans une liste :

import random

class RotatingProxyMiddleware:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list

    @classmethod
    def from_crawler(cls, crawler):
        # Construire la liste à partir de l'environnement ou de la configuration
        proxy_list = [
            f'socks5://{os.getenv("DAI_PROXY_USER")}:{os.getenv("DAI_PROXY_PASS")}@{host}:{port}'
            for host, port in [('host1', 'port1'), ('host2', 'port2')]
        ]
        return cls(proxy_list)

    def process_request(self, request, spider):
        request.meta['proxy'] = random.choice(self.proxy_list)

Mettez à l'échelle avec plusieurs spiders en utilisant scrapyd. Installez scrapyd :
```
pip install scrapyd scrapyd-client
```
Déployez votre projet et planifiez plusieurs spiders avec différents endpoints proxy. Utilisez une file d'attente de tâches pour distribuer les URL.

Surveillez et gérez les erreurs. Journalisez les échecs de proxy dans le middleware :

def process_response(self, request, response, spider):
    if response.status in [403, 429]:
        spider.logger.warning(f'Blocked with proxy {request.meta.get("proxy")}')
    return response

Dépannage

SOCKS5 ne fonctionne pas : assurez-vous d'utiliser le schéma socks5:// dans request.meta['proxy'] et que le HttpProxyMiddleware de Scrapy est désactivé. Scrapy s'appuie sur txsocksx ou PySocks ; installez pip install txsocksx si nécessaire.
Erreurs d'authentification : encodez en URL les caractères spéciaux dans le nom d'utilisateur/mot de passe.
Taux de bannissement élevé : augmentez le délai, réduisez la concurrence et assurez-vous d'utiliser des endpoints rotatifs. Envisagez d'utiliser les sessions sticky de Dataimpulse pour les sites nécessitant une connexion.
Fuites de mémoire : surveillez l'utilisation de la mémoire de Scrapy avec scrapy stats et redémarrez périodiquement les spiders.

Résumé

L'intégration des proxies résidentiels rotatifs Dataimpulse avec Scrapy sur Linux implique un middleware de téléchargement personnalisé, des paramètres de retry appropriés et éventuellement SOCKS5 pour une flexibilité de protocole. En mettant à l'échelle avec scrapyd et en surveillant les performances des proxies, vous pouvez construire un pipeline de scraping robuste. Respectez toujours les conditions d'utilisation et le fichier robots.txt des sites cibles.