Aperçu

Si vous utilisez actuellement Dataimpulse pour le scraping web et que vous souhaitez passer à Smartproxy, ce guide vous accompagne tout au long du processus de migration sous Linux. Smartproxy propose un pool de plus de 65 millions d'IP avec prise en charge de SOCKS5, et leurs proxys résidentiels et datacenter conviennent au scraping à grande échelle. Ce tutoriel couvre la configuration avancée, y compris la rotation des proxys, la gestion des erreurs et le scraping asynchrone.

Prérequis

Un compte Smartproxy avec des proxys résidentiels ou datacenter activés.
Un système Linux (testé sur Ubuntu 22.04, mais les commandes fonctionnent sur la plupart des distributions).
Python 3.7+ installé.
Une familiarité de base avec la ligne de commande et Python.

Étapes

Récupérer vos identifiants SOCKS5 Smartproxy
Connectez-vous à votre tableau de bord Smartproxy et accédez à la section de configuration du proxy. Vous aurez besoin de :
- Point de terminaison du proxy (hôte) : par ex., gateway.smartproxy.com (vérifiez votre tableau de bord pour le point de terminaison exact).
- Port : le port fourni pour SOCKS5 (souvent 1080, mais confirmez dans votre tableau de bord).
- Nom d'utilisateur et mot de passe : vos identifiants d'authentification. Gardez-les à portée de main pour les étapes suivantes.
Configurer les variables d'environnement
Stockez vos identifiants en tant que variables d'environnement pour les garder hors de votre code. Ouvrez votre terminal et exécutez :
```
export SMARTPROXY_USER="your_username"
export SMARTPROXY_PASS="your_password"
export SMARTPROXY_HOST="gateway.smartproxy.com"
export SMARTPROXY_PORT="1080"
```
Remplacez les valeurs par vos identifiants et point de terminaison réels.
Tester la connectivité avec cURL
Vérifiez que votre proxy SOCKS5 fonctionne à l'aide de cURL :
```
curl -x socks5://$SMARTPROXY_USER:$SMARTPROXY_PASS@$SMARTPROXY_HOST:$SMARTPROXY_PORT https://httpbin.org/ip
```
Vous devriez voir l'adresse IP de votre proxy dans la réponse. Si vous obtenez une erreur, vérifiez à nouveau vos identifiants et votre point de terminaison.
Configurer Python pour les proxys SOCKS5
Installez les paquets nécessaires :
```
pip install requests requests[socks]
```
Pour le scraping asynchrone, installez également :
```
pip install aiohttp aiohttp_socks
```

Scraping de base avec Requests
Créez un script Python qui utilise Smartproxy SOCKS5 :

import os
import requests

proxy_user = os.getenv('SMARTPROXY_USER')
proxy_pass = os.getenv('SMARTPROXY_PASS')
proxy_host = os.getenv('SMARTPROXY_HOST')
proxy_port = os.getenv('SMARTPROXY_PORT')

proxy_url = f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}"
proxies = {
    'http': proxy_url,
    'https': proxy_url
}

response = requests.get('https://httpbin.org/ip', proxies=proxies, timeout=10)
print(response.json())

Exécutez le script pour confirmer qu'il fonctionne.

Mettre en œuvre la rotation des proxys
Les proxys résidentiels Smartproxy prennent en charge la rotation. Vous pouvez configurer la rotation dans votre tableau de bord (par ex., rotation par requête ou sessions persistantes). Si vous devez gérer plusieurs points de terminaison, créez une liste :
```
import random

proxy_list = [
    f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}",
    # Ajoutez-en d'autres si vous avez plusieurs points de terminaison
]

def get_random_proxy():
    return random.choice(proxy_list)
```
Pour une rotation par requête, réutilisez simplement la même URL de proxy si la rotation est activée dans votre tableau de bord.

Gestion avancée des erreurs et nouvelles tentatives
Le scraping web à grande échelle nécessite une gestion robuste des erreurs. Utilisez tenacity pour les nouvelles tentatives :

pip install tenacity

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def fetch(url, proxies):
    response = requests.get(url, proxies=proxies, timeout=15)
    response.raise_for_status()
    return response

Gérez les erreurs HTTP spécifiques (par ex., 403, 429) et faites tourner le proxy en cas d'échec.

Scraping asynchrone avec aiohttp
Pour une concurrence élevée, utilisez aiohttp avec aiohttp_socks :

import asyncio
import aiohttp
from aiohttp_socks import ProxyConnector

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    connector = ProxyConnector.from_url(f"socks5://{proxy_user}:{proxy_pass}@{proxy_host}:{proxy_port}")
    async with aiohttp.ClientSession(connector=connector) as session:
        html = await fetch(session, 'https://httpbin.org/ip')
        print(html)

asyncio.run(main())

Migrer depuis Dataimpulse
Si vous avez du code existant utilisant Dataimpulse, mettez à jour l'URL du proxy et les identifiants. Généralement, le format est similaire, mais assurez-vous d'utiliser SOCKS5. Remplacez le point de terminaison Dataimpulse par celui de Smartproxy. Testez minutieusement pour confirmer que la migration fonctionne.

Dépannage

Échec de l'authentification : Vérifiez le nom d'utilisateur et le mot de passe. Assurez-vous d'utiliser le bon port pour SOCKS5.
Délai de connexion dépassé : Vérifiez que votre pare-feu autorise les connexions sortantes sur le port SOCKS5.
Fuites DNS : Utilisez socks5h:// au lieu de socks5:// pour résoudre le DNS via le proxy.
Vitesses lentes : Essayez un autre emplacement de proxy ou passez à des proxys datacenter pour des vitesses plus rapides.
IP bloquée : Passez à une nouvelle IP ou utilisez un autre type de proxy.

Résumé

La migration de Dataimpulse vers Smartproxy sous Linux est simple. En suivant ces étapes, vous pouvez configurer des proxys SOCKS5, mettre en œuvre la rotation et gérer les erreurs pour un scraping web avancé. Le large pool d'IP de Smartproxy et son tableau de bord convivial en font un choix solide. Respectez toujours les conditions d'utilisation et le fichier robots.txt des sites web cibles.