Comment faire pivoter les proxys en Python

Dans ce guide sur la rotation des proxies en Python, vous apprendrez :

• Qu’est-ce qu’un proxy et pourquoi l’utiliser ?
• Qu’est-ce que la rotation des procurations et pourquoi en avez-vous besoin ?
• Comment faire pivoter les proxies en Python
• Limitations courantes lors de la rotation des proxies en Python

Plongeons dans l’aventure !

Qu’est-ce qu’une procuration ?

Un proxy est un serveur qui agit comme un intermédiaire entre un utilisateur et une ressource réseau sur Internet. On peut donc considérer un proxy comme un intermédiaire qui transmet les demandes et les réponses entre les parties.

Pourquoi utiliser des proxy en Python ?

Lorsque vous envoyez une demande à un site web à l’aide d’un proxy, la demande passe d’abord par le serveur proxy. Ensuite, le proxy transmet votre demande au site web, reçoit la réponse et vous la renvoie. Ce processus masque votre adresse IP à la destination, ce qui donne l’impression que la demande provient du serveur proxy et non de votre appareil.

La raison typique pour laquelle vous souhaitez utiliser un proxy est dans le cas de l’automatisation des requêtes web ou du web scraping. Dans ce cas, Python est l’un des meilleurs langages pour le web scraping, grâce à ses vastes bibliothèques et à sa communauté active.

Qu’est-ce que la rotation des procurations et pourquoi en avez-vous besoin ?

Si vous faites trop de requêtes à partir d’une seule adresse IP, les sites web peuvent vous bloquer en limitant le débit ou en interdisant purement et simplement l’accès à votre adresse IP. C’est là que la rotation de proxy via des proxys entre en jeu.

Le passage systématique d’un serveur proxy à l’autre lors des requêtes web est l’une des meilleures façons de mettre en œuvre la rotation des adresses IP. Cette procédure vous permet de contourner les techniques anti-scraping les plus courantes et vous offre les avantages suivants :

• Éviter les blocages d’IP: Répartissez les demandes sur plusieurs IP, ce qui rendra plus difficile la détection et le blocage de votre activité de scraping par les sites web.
• Contournement des limites de débit: Les sites web fixent souvent des limites de requêtes par adresse IP dans un délai spécifique. La rotation des proxies vous permet de continuer à scraper même après avoir atteint ces limites sur une IP.
• Accès à des contenus soumis à des restrictions géographiques: Certains sites web affichent un contenu différent en fonction de l’emplacement géographique. La rotation de proxys avec des proxys de différents pays vous permet d’accéder à des contenus spécifiques à votre localisation.

Comment faire pivoter les proxies en Python : 3 approches

Maintenant que vous savez ce que sont les proxies et pourquoi les faire pivoter, préparez-vous à suivre des tutoriels pas à pas en Python. Les paragraphes suivants vous montreront comment faire pivoter des proxies en Python en utilisant différentes approches et bibliothèques.

Le site cible de tous les scripts sera le point de terminaison /ip du projet HTTPBin. Ce point d’accès spécial renvoie l’adresse IP de l’appelant, ce qui est parfait pour tester si l’IP vue par le serveur est tournante.

Il est temps de faire tourner des proxies en Python !

Exigences

Pour reproduire les tutoriels de rotation de proxies avec Python, vous devez avoir installé Python 3.7 ou une version plus récente sur votre machine.

Conditions préalables

Supposons que vous appeliez le dossier principal de votre projet proxy_rotation/. À la fin de cette étape, le dossier aura la structure suivante :

proxy_rotation/
    ├── requests_file.py
    ├── async.py
    ├── scrapy_rotation/
    └── venv/ 

Où ?

• requests.py et async.py sont des fichiers Python qui contiennent respectivement la logique de rotation des requêtes et du proxy AIOHTTP.
• scrapy_rotation/ est un dossier qui contient un projet Scrapy. Vous le créerez et l’instancierez plus tard.
• venv/ contient l’environnement virtuel

Vous pouvez créer le répertoire de l ‘environnement virtuel venv/ de la manière suivante :

python -m venv venv

Pour l’activer, sous Windows, exécutez :

venv\Scripts\activate

De manière équivalente, sous macOS et Linux, exécutez :

source venv/bin/activate

Comme dernier prérequis, vous devez récupérer une liste de proxies. Pour cet article, vous pouvez utiliser notre liste de proxies gratuits.

Comment faire tourner les proxys en Python avec des requêtes

Dans cette section du tutoriel, vous apprendrez à faire pivoter des proxies en Python avec Requests.

Étape 1 : Installation des dépendances

Dans l’environnement virtuel activé, installez Requests avec :

pip install requests

Étape 2 : Définir la logique de rotation

Pour faire pivoter les proxies en Python avec Requests, écrivez le code suivant dans le fichier requests_file.py :

import random
import requests

# Define a list of proxies and return a random one
def get_random_proxy():
    proxies = [
        "http://PROXY_1:PORT_X",
        "http://PROXY_2:PORT_Y",
        "http://PROXY_3:PORT_X",
        # Add more proxies here...
    ]

    # Randomly pick a proxy
    return random.choice(proxies)

for i in range(3):
    proxy_url = get_random_proxy()
    proxies = {
        "http": proxy_url,
        "https": proxy_url,
    }
    response = requests.get("https://httpbin.io/ip", proxies=proxies)
    print(response.text)

Où ?

• La fonction get_random_proxy() stocke la liste des mandataires que vous avez récupérés et renvoie un mandataire aléatoire à l’aide de la méthode random.choice().
• La boucle for itère sur la liste aléatoire des mandataires et effectue la demande réelle avec la méthode requests.get(). Pour plus d’informations, lisez notre guide sur l’utilisation d’un proxy avec Python Requests.

Étape 3 : Lancer le script

Pour lancer le script, exécutez :

python requests_file.py

Vous trouverez ci-dessous la réponse attendue :

{
  "origin": "PROXY_3:PORT_K"
}
{
  "origin": "PROXY_1:PORT_N"
}
{
  "origin": "PROXY_2:PORT_P"
}

Merveilleux ! Les IP de sortie de votre script ont été tournées comme vous le souhaitiez.

Comment faire tourner les proxies en Python avec AIOHTTP

La principale limitation de l’approche aléatoire utilisant la bibliothèque Requests est qu’elle utilise un proxy à la fois. Cela signifie qu’il faut attendre la fin de chaque requête avant d’utiliser le proxy suivant.

Pour éviter cette limitation, vous pouvez utiliser AIOHTTP. Cette bibliothèque vous permet d’effectuer des requêtes asynchrones, et donc d’utiliser simultanément plusieurs serveurs mandataires de manière non bloquante. En d’autres termes, elle vous permet de faire tourner les proxies de votre liste en effectuant des requêtes parallèles asynchrones vers le serveur cible. Découvrez AIOHTTP en action dans notre guide sur le web scraping asynchrone.

La section suivante montre comment faire tourner les proxies en Python avec AIOHTTP.

Étape 1 : Installation des dépendances

Dans l’environnement virtuel activé, installez AIOHTTP avec :

pip install aiohttp

Étape 2 : Définir la logique de rotation

Pour faire tourner les proxies en Python avec AIOHTTP, écrivez le code suivant dans le fichier async.py :

import asyncio
import aiohttp

# Define a list of proxies
proxies_list = [
    "http://PROXY_1:PORT_X",
    "http://PROXY_2:PORT_Y",
    "http://PROXY_3:PORT_X",
    # Add more proxies here...
]

async def fetch_ip(session, proxy_address, attempt):
    print(f"Attempt {attempt} using proxy: {proxy_address}")
    async with session.get("https://httpbin.io/ip", proxy=proxy_address) as response:
        json_response = await response.json()
        print(f"Response from httpbin.io/ip (Attempt {attempt}):")
        print(f"IP Address: {json_response.get('origin', 'Unknown')}")
        print("-" * 40)
        return json_response

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        num_attempts = 3
        for i in range(num_attempts):
            # Rotate proxies using the modulus operator.
            proxy_address = proxies_list[i % len(proxies_list)]
            tasks.append(fetch_ip(session, proxy_address, i + 1))
        # Run all requests concurrently
        await asyncio.gather(*tasks)

# Launch the script
asyncio.run(main())

Ce code effectue les opérations suivantes :

• La fonction fetch_ip() gère les demandes en prenant la session, un proxy et le numéro de la tentative. En particulier, elle envoie une requête GET au site web cible et imprime la réponse.
• La fonction main()

  :Polylang placeholder do not modify

Étape 3 : Lancer le script

Pour lancer le script, exécutez :

python async.py

C’est la réponse attendue :

Attempt 1 using proxy: http://PROXY_1:PORT_X
Attempt 2 using proxy: http://PROXY_2:PORT_Y
Attempt 3 using proxy: http://PROXY_3:PORT_Z

Response from httpbin.io/ip (Attempt 3):
IP Address: xxx.xxx.xxx.xxx
----------------------------------------
Response from httpbin.io/ip (Attempt 1):
IP Address: yyy.yyy.yyy.yyy
----------------------------------------
Response from httpbin.io/ip (Attempt 2):
IP Address: zzz.zzz.zzz.zzz
----------------------------------------

C’est incroyable ! La rotation des adresses IP s’effectue comme prévu.

Comment faire pivoter les proxies avec Python Scrapy

Dans un article précédent, nous avons discuté de la possibilité de faire tourner les proxies en Python avec Scrapy en utilisant scrapy-rotating-proxies.

Dans cette section guidée, vous apprendrez à le faire !

Étape 1 : Installation des dépendances

Dans l’environnement virtuel activé, installez les bibliothèques nécessaires :

pip install scrapy scrapy-rotating-proxies

Étape 2 : Créer un nouveau projet Scrapy

Dans le dossier principal de votre dépôt(proxy_rotation/), instanciez un nouveau projet Scrapy avec cette commande :

scrapy startproject scrapy_rotation

Cela créera un nouveau sous-dossier appelé scrapy_rotation/ qui aura la structure suivante :

scrapy_rotation/
  ├── scrapy_rotation/ 
  │   ├── __init__.py
  │   ├── items.py # Defines the data structure for scraped items
  │   ├── middlewares.py # Custom middlewares
  │   ├── pipelines.py # Handles post-processing of scraped data
  │   ├── settings.py # Project settings
  │   └── spiders/ # Folder for all spiders
  └── scrapy.cfg # Scrapy configuration file

Depuis le dossier principal(proxy_rotation/), déplacez-vous vers le dossier scrapy_rotation/ :

cd scrapy_rotation

Vous pouvez maintenant créer un nouveau spider qui pointe vers le site web cible en exécutant :

scrapy genspider rotation http://httpbin.io/ip

Ce script crée également le fichier rotation.py dans le dossier spiders/.

Étape 3 : Définir la logique de rotation

La logique de rotation du proxy peut être gérée en modifiant le fichier settings.py avec les paramètres suivants :

# Enable the rotating proxies middleware
DOWNLOADER_MIDDLEWARES = {
    "rotating_proxies.middlewares.RotatingProxyMiddleware": 610,
    "rotating_proxies.middlewares.BanDetectionMiddleware": 620,
}

# List of proxies to rotate
ROTATING_PROXY_LIST = [
    "http://PROXY_1:PORT_X",
    "http://PROXY_2:PORT_Y",
    "http://PROXY_3:PORT_Z",
    # Add more proxies as needed
]

# Configure retry settings
RETRY_TIMES = 5  # Number of retries for failed requests
RETRY_HTTP_CODES = [500, 502, 503, 504, 408]  # HTTP codes to retry

C’est l’option rotating_proxies.middlewares.RotatingProxyMiddleware : 610 de DOWNLOADER_MIDDLEWARES qui gère la rotation des mandataires. En particulier, cette option sélectionne un proxy dans la ROTATING_PROXY_LIST et l’affecte à chaque requête.

En outre, l’option rotating_proxies.middlewares.BanDetectionMiddleware : 620 permet au scraper de détecter si une IP a été bannie ou bloquée par le site web cible. Si une requête échoue pour cette raison, le middleware réessayera la requête avec un nouveau proxy. Cette option travaille donc en étroite collaboration avec l’intergiciel RotatingProxyMiddleware pour s’assurer que les mandataires interdits sont automatiquement évités.

Maintenant, dans le fichier rotation.py à l’intérieur du dossier spiders/, vous pouvez écrire ce qui suit :

import scrapy

class IpSpider(scrapy.Spider):
    name = "ip_spider"
    start_urls = ["http://httpbin.io/ip"]
    def parse(self, response):
        # Extract and print the IP address from the response
        ip = response.json().get("origin")
        self.log(f"IP Address: {ip}")

Cette classe instancie l’ensemble de l’araignée et imprime la réponse à chaque demande.

Étape 4 : Lancer le script

Pour lancer le script, vous devez utiliser le nom de la classe IpSpider(), à savoir ip_spider:

scrapy crawl ip_spider

Les données retournées par Scrapy sur le CLI sont particulièrement complètes. Ainsi, si tout s’est bien passé, parmi les autres informations, vous trouverez quelque chose comme ceci :

2025-02-18 14:55:17 [rotating_proxies.expire] DEBUG: Proxy <http://PROXY_1:PORT_X> is GOOD
2025-02-18 14:55:17 [scrapy.core.engine] DEBUG: Crawled (200) <GET http://httpbin.io/robots.txt> (referer: None)
2025-02-18 14:55:24 [rotating_proxies.middlewares] INFO: Proxies(good: 1, dead: 0, unchecked: 2, reanimated: 0, mean backoff time: 0s)

Limites des approches précédentes de la rotation des mandataires en Python

Les méthodes de rotation par procuration mentionnées ci-dessus sont utiles, mais elles présentent certaines limites :

• Ils vous obligent à récupérer et à gérer manuellement une liste de mandataires.
• Il s’agit de code standard.
• Ils peuvent encore entraîner des interdictions d’accès à l’Internet si vous n’utilisez pas des serveurs proxy de haute qualité.

Si vous cherchez un moyen plus efficace de gérer la rotation de proxy en Python, Bright Data propose certains des meilleurs proxys rotatifs du marché. Avec une seule URL de proxy, vous pouvez les intégrer à votre client HTTP ou à votre bibliothèque de scraping. Vous n’avez donc plus besoin de code standard ni de gestion manuelle de la rotation.

Les autres avantages de cette approche sont les suivants

• Rotation automatique des adresses IP avec des adresses IP collantes configurables
• Accès à 150 million+ millions d’IP résidentielles
• Contrôle de la géolocalisation des serveurs proxy
• Prise en charge des protocoles HTTP, HTTPS et SOCKS

Simplifiez la gestion de vos procurations – découvrez nos procurations à rotation automatique!

Conclusion

Dans cet article, vous avez appris à faire tourner des proxies en Python en utilisant trois bibliothèques différentes : Requests, AIOHTTP et Scrapy. Comme le montrent les sections guidées ci-dessus, le processus n’est pas complexe et ne nécessite que quelques lignes de code.

Cette approche présente toutefois quelques inconvénients :

• Le code est lourd, ce qui rend votre script moins facile à maintenir.
• Vous devez gérer et fournir un accès à une grande liste de serveurs proxy.

Heureusement, vous pouvez éviter tous ces tracas grâce aux proxies à rotation automatique de Bright Data, une solution plus efficace pour faire pivoter les proxies en Python.

Bright Data contrôle les meilleurs serveurs proxy au monde, au service des entreprises Fortune 500 et de plus de 20 000 clients. Son offre comprend une large gamme de types de proxy :

• Proxies de centres de données – Plus de 770 000 IP de centres de données.
• Proxies résidentiels – Plus de 150 million+ IP résidentielles dans plus de 195 pays.
• Proxies ISP – Plus de 700 000 IP ISP.
• Proxies mobiles – Plus de 7 millions d’IP mobiles.

Créez un compte Bright Data gratuit dès aujourd’hui pour tester nos proxys et nos solutions de scraping !