Skip to content
Advanced / 7 min read

Comment utiliser les proxys résidentiels et datacenter Smartproxy avec Scrapy sous Linux

Construisez un middleware de téléchargement Scrapy qui alterne entre les proxys HTTP résidentiels et datacenter de Smartproxy sous Linux, avec des identifiants basés sur l'environnement et des réessais de repli entre pools.

Linux HTTP(S) Scraping Web

Aperçu

Le HttpProxyMiddleware intégré de Scrapy peut acheminer une requête via un proxy HTTP, mais le scraping en production avec Smartproxy nécessite généralement deux choses : un pool résidentiel pour les requêtes géociblées ou résistantes au bannissement, et un pool datacenter pour les requêtes à haut débit. Ce tutoriel montre comment ajouter un middleware de téléchargement personnalisé qui sélectionne un endpoint Smartproxy par requête, alterne entre les pools résidentiels et datacenter, et réessaie les erreurs de proxy courantes sans coder en dur les identifiants dans votre spider.

Smartproxy prend en charge HTTP et SOCKS5 ; ce guide utilise des endpoints proxy HTTP/HTTPS car le middleware proxy intégré de Scrapy attend des URL de proxy HTTP.

Prérequis

  • Une machine Linux ou un conteneur avec Python 3.10 ou plus récent.
  • Un compte Smartproxy avec des identifiants de proxy résidentiel et/ou datacenter.
  • Les détails de l'endpoint depuis le tableau de bord Smartproxy : hôte proxy, port, nom d'utilisateur et mot de passe pour chaque pool que vous prévoyez d'utiliser.
  • pip et venv disponibles.

Étapes

Étape 1 — Créer un environnement virtuel et installer Scrapy

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install scrapy python-dotenv

Étape 2 — Stocker les identifiants Smartproxy en tant que variables d'environnement

Ne commitez pas les identifiants dans votre dépôt.

export SMARTPROXY_RES_HOST='your-residential-host'
export SMARTPROXY_RES_PORT='your-residential-port'
export SMARTPROXY_RES_USERNAME='your-residential-username'
export SMARTPROXY_RES_PASSWORD='your-residential-password'

export SMARTPROXY_DC_HOST='your-datacenter-host'
export SMARTPROXY_DC_PORT='your-datacenter-port'
export SMARTPROXY_DC_USERNAME='your-datacenter-username'
export SMARTPROXY_DC_PASSWORD='your-datacenter-password'

Si vous préférez un fichier .env, chargez-le avant le démarrage de Scrapy. Gardez le fichier hors du contrôle de version.

Étape 3 — Créer le projet Scrapy

scrapy startproject smartproxy_scrapy
cd smartproxy_scrapy
scrapy genspider example example.com

Étape 4 — Ajouter un middleware de rotation Smartproxy

Créez smartproxy_scrapy/middlewares.py ou ajoutez au fichier généré. Le middleware définit request.meta['proxy'] avant que HttpProxyMiddleware de Scrapy ne s'exécute.

import os
from urllib.parse import quote

from scrapy import signals
from scrapy.exceptions import NotConfigured
from scrapy.utils.project import get_project_settings


class SmartproxyRotationMiddleware:
    '''Route Scrapy requests through Smartproxy residential or datacenter endpoints.'''

    def __init__(self, settings):
        self.pools = {
            'residential': {
                'host': settings.get('SMARTPROXY_RES_HOST'),
                'port': settings.get('SMARTPROXY_RES_PORT'),
                'username': settings.get('SMARTPROXY_RES_USERNAME'),
                'password': settings.get('SMARTPROXY_RES_PASSWORD'),
            },
            'datacenter': {
                'host': settings.get('SMARTPROXY_DC_HOST'),
                'port': settings.get('SMARTPROXY_DC_PORT'),
                'username': settings.get('SMARTPROXY_DC_USERNAME'),
                'password': settings.get('SMARTPROXY_DC_PASSWORD'),
            },
        }

        if not any(pool['host'] and pool['port'] for pool in self.pools.values()):
            raise NotConfigured('Set at least one Smartproxy pool host and port.')

    @classmethod
    def from_crawler(cls, crawler):
        middleware = cls(crawler.settings)
        crawler.signals.connect(middleware.spider_opened, signal=signals.spider_opened)
        return middleware

    def spider_opened(self, spider):
        spider.logger.info('Smartproxy rotation middleware enabled')

    def process_request(self, request, spider):
        pool_name = request.meta.get('proxy_pool', 'residential')
        pool = self.pools.get(pool_name)

        if not pool or not pool['host'] or not pool['port']:
            return None

        host = pool['host']
        port = pool['port']
        username = quote(pool['username'] or '', safe='')
        password = quote(pool['password'] or '', safe='')

        if username and password:
            proxy_url = f'http://{username}:{password}@{host}:{port}'
        else:
            proxy_url = f'http://{host}:{port}'

        request.meta['proxy'] = proxy_url
        request.meta['smartproxy_pool'] = pool_name
        return None

Étape 5 — Activer le middleware avant le middleware proxy de Scrapy

Modifiez smartproxy_scrapy/settings.py.

DOWNLOADER_MIDDLEWARES = {
    'smartproxy_scrapy.middlewares.SmartproxyRotationMiddleware': 749,
}

HTTPPROXY_ENABLED = True
DOWNLOAD_TIMEOUT = 30
RETRY_HTTP_CODES = [403, 407, 429, 500, 502, 503, 504]
RETRY_TIMES = 2
CONCURRENT_REQUESTS = 16
CONCURRENT_REQUESTS_PER_DOMAIN = 4

Le HttpProxyMiddleware intégré de Scrapy est ordonné à 750, donc 749 garantit que votre middleware définit l'URL du proxy en premier.

Étape 6 — Choisir résidentiel ou datacenter par requête

Utilisez meta={'proxy_pool': 'residential'} pour les pages géociblées ou à haute anonymité. Utilisez meta={'proxy_pool': 'datacenter'} pour les pages stables à haut débit.

import scrapy


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

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={'proxy_pool': 'residential'},
                callback=self.parse,
                dont_filter=True,
            )
            yield scrapy.Request(
                url,
                meta={'proxy_pool': 'datacenter'},
                callback=self.parse,
                dont_filter=True,
            )

    def parse(self, response):
        yield {
            'pool': response.meta.get('smartproxy_pool'),
            'status': response.status,
            'origin': response.text.strip(),
        }

Étape 7 — Ajouter des réessais de repli entre les pools

Un code 403 ou 429 du site cible signifie souvent que l'IP actuelle est bloquée. Ajoutez cette méthode à l'intérieur de la classe SmartproxyRotationMiddleware afin qu'une requête échouée soit réessayée une fois avec l'autre pool Smartproxy.

    def process_response(self, request, response, spider):
        retryable = {403, 429}
        already_switched = request.meta.get('smartproxy_pool_retry', False)

        if response.status in retryable and not already_switched:
            current = request.meta.get('proxy_pool', 'residential')
            alternate = 'datacenter' if current == 'residential' else 'residential'

            new_meta = request.meta.copy()
            new_meta['proxy_pool'] = alternate
            new_meta['smartproxy_pool_retry'] = True

            spider.logger.warning(
                'Retrying %s with %s pool after HTTP %s',
                request.url,
                alternate,
                response.status,
            )
            return request.replace(meta=new_meta, dont_filter=True)

        return response

Si vous utilisez ce repli, gardez RETRY_TIMES faible pour que les requêtes bloquées ne bouclent pas indéfiniment.

Étape 8 — Exécuter le spider et enregistrer les résultats

scrapy crawl smartproxy_demo -O smartproxy_results.json

Étape 9 — Vérifier l'IP de sortie du proxy avec cURL

Utilisez le même endpoint HTTP Smartproxy en dehors de Scrapy pour confirmer les identifiants et la connectivité.

curl --proxy 'http://USERNAME:PASSWORD@HOST:PORT' https://httpbin.org/ip

Remplacez USERNAME, PASSWORD, HOST et PORT par les valeurs du pool que vous testez.

Dépannage

  • 407 Proxy Authentication Required : vérifiez le nom d'utilisateur et le mot de passe, assurez-vous qu'ils sont encodés URL, et confirmez que vous utilisez le bon hôte et le bon port pour le pool sélectionné.
  • Tunnel connection failed ou erreurs TLS : confirmez que l'endpoint Smartproxy prend en charge les cibles HTTPS via HTTP CONNECT. Testez-le d'abord avec la commande cURL de l'étape 9.
  • Scrapy ignore le proxy : confirmez que SmartproxyRotationMiddleware est défini en dessous de 750 dans DOWNLOADER_MIDDLEWARES, et que HTTPPROXY_ENABLED est True.
  • 403 ou 429 fréquents : réduisez CONCURRENT_REQUESTS_PER_DOMAIN, ajoutez DOWNLOAD_DELAY, passez aux proxys résidentiels et faites tourner les user agents uniquement là où la cible le permet.
  • Réponses lentes : les proxys datacenter sont généralement meilleurs pour le débit brut ; les proxys résidentiels sont meilleurs pour les requêtes géociblées et les sites qui bloquent les plages d'IP datacenter.
  • Les identifiants contiennent @, : ou / : conservez les appels urllib.parse.quote dans le middleware. L'encodage évite les URL de proxy mal formées.

Résumé

Vous disposez maintenant d'un projet Scrapy qui achemine les requêtes via les proxys HTTP résidentiels et datacenter de Smartproxy sous Linux. Le middleware sélectionne un pool par requête, conserve les identifiants dans des variables d'environnement et peut basculer vers l'autre pool lorsqu'une cible bloque une IP. Commencez avec une faible concurrence, vérifiez vos IP de sortie avec cURL, et augmentez CONCURRENT_REQUESTS_PER_DOMAIN seulement après que le crawl se comporte de manière fiable.