Sessions persistantes et rotation d’IP : IDs de session, TTL et réutilisation des connexions

Que se passe-t-il à la passerelle lorsque j'envoie un ID de session ?

La passerelle lit le nom d'utilisateur à chaque nouvelle connexion. Sans partie session, elle choisit une sortie proxy résidentiel qui correspond à votre ciblage pour cette connexion uniquement. Avec une partie session, elle conserve la même sortie pour cet ID pendant la durée TTL que vous avez définie.

Une IP collante est une connexion résidentielle réelle, donc elle peut disparaître avant la fin du TTL : appareil éteint, perte de Wi-Fi ou changement de réseau. Les flux longs doivent gérer cela, en vérifiant l'IP de sortie à des points de contrôle et en redémarrant depuis un point de contrôle au lieu d'échouer complètement.

Comment gérer un pool de sessions sticky en Python ?

Un petit pool répartit la charge sur quelques exits stables et retire chacun après un nombre défini de requêtes ou après un signe d'échec de l'exit, comme 502 ou 503. Notez ce qu’il ne fait pas : il ne change pas les IP pour contourner un 403 ou un 429. Ceux-ci signifient que le site veut que vous ralentissiez, donc le pool transmet cela à votre code.

import random
import uuid

import requests

GATEWAY = "gw.crawlrelay.com:7777"
BASE_USER, PASSWORD = "USERNAME-country-us", "PASSWORD"


class SlowDown(Exception):
    """The target asked us to slow down (403 or 429): back off, do not rotate."""


class StickySession:
    def __init__(self, ttl=15, max_requests=50):
        self.id = uuid.uuid4().hex[:10]
        self.max_requests, self.used = max_requests, 0
        user = "%s-session-%s-ttl-%d" % (BASE_USER, self.id, ttl)
        proxy = "http://%s:%s@%s" % (user, PASSWORD, GATEWAY)
        self.http = requests.Session()
        self.http.proxies = {"http": proxy, "https": proxy}


class SessionPool:
    EXIT_PROBLEMS = {502, 503, 504}

    def __init__(self, size=5, **options):
        self.options = options
        self.sessions = [StickySession(**options) for _ in range(size)]

    def _replace(self, i):
        self.sessions[i].http.close()
        self.sessions[i] = StickySession(**self.options)

    def get(self, url, **kwargs):
        i = random.randrange(len(self.sessions))
        s = self.sessions[i]
        s.used += 1
        try:
            r = s.http.get(url, timeout=(10, 30), **kwargs)
        except requests.exceptions.RequestException:
            self._replace(i)  # dropped exit or timeout: start a fresh session
            raise
        if r.status_code in (403, 429):
            raise SlowDown("%s returned %d" % (url, r.status_code))
        if r.status_code in self.EXIT_PROBLEMS or s.used >= s.max_requests:
            self._replace(i)
        return r


pool = SessionPool(size=5, ttl=15, max_requests=50)
print(pool.get("https://api.ipify.org").text)

Comment savoir quand une IP sticky a changé ?

Demandez. Faites appel à un service d'écho IP comme https://api.ipify.org via la même session au début d’un flux et à chaque point de contrôle, puis comparez les réponses. Un changement signifie que l’exit derrière la session a changé : redémarrez le flux depuis son dernier point de contrôle ou ouvrez une nouvelle session. Enregistrez-le avec l’ID de session pour distinguer les changements d’IP du comportement du site lors du débogage.

Quelles erreurs de session coûtent le plus cher ?

• Rotation à chaque requête d’un flux multi-étapes. Le site voit un panier, un curseur ou un jeton de recherche changer de pays et réinitialise.
• Un ID de session par travailleur. Une session est prévue pour un seul flux ; donnez à chaque travailleur et à chaque flux son propre ID.
• Sessions bien plus longues que la tâche. Un TTL de 30 minutes pour un flux de 2 minutes immobilise inutilement une IP et complique les logs.
• Prendre un 429 pour un problème IP. Une nouvelle IP ne modifie pas la règle du site ; ralentir le fait. Voir 429 Too Many Requests.
• Supposer une rotation à chaque requête. Le keep-alive maintient l’exit ; consultez le tableau ci-dessus selon votre bibliothèque.