Sessioni sticky e rotazione IP: ID sessione, TTL e riuso connessioni

Cosa succede al gateway quando invio un ID di sessione?

Il gateway legge il nome utente ad ogni nuova connessione. Senza una parte di sessione, seleziona un'uscita proxy residenziale che corrisponde al tuo targeting solo per quella connessione. Con una parte di sessione, mantiene la stessa uscita per quell'ID fino al TTL che imposti.

Un IP persistente è una vera connessione domestica, quindi può scomparire prima che il TTL termini: il dispositivo può essere spento, perdere il Wi-Fi o cambiare rete. Flussi lunghi devono sopravvivere a ciò, verificando l'IP di uscita a checkpoint e ripartendo da un checkpoint invece di fallire l’intero lavoro.

Come gestisco un pool di sessioni sticky in Python?

Un piccolo pool distribuisce il carico su alcune uscite stabili e ritira ciascuna dopo un numero prefissato di richieste o dopo un segnale che la sua uscita sta fallendo, come 502 o 503. Nota cosa non fa: non cambia IP per superare un 403 o un 429. Significano che il sito vuole che rallenti, quindi il pool li passa al tuo codice.

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)

Come faccio a sapere se un IP sticky è cambiato?

Chiedilo. Richiedi un servizio di eco IP come https://api.ipify.org usando la stessa sessione all'inizio di un flusso e a ogni checkpoint, quindi confronta le risposte. Un cambiamento significa che l'uscita dietro la sessione è cambiata: riavvia il flusso dal suo ultimo checkpoint oppure apri una nuova sessione. Registralo con l'ID sessione così puoi distinguere i cambi IP dal comportamento del sito durante il debug.

Quali errori nelle sessioni costano di più?

• Ruotare ad ogni richiesta di un flusso a più step. Il sito vede un carrello, un cursore o un token di ricerca saltare tra paesi e lo resetta.
• Un ID sessione per ogni worker. Una sessione serve per un solo flusso; assegna a ogni worker e flusso un proprio ID.
• Sessioni troppo lunghe rispetto al lavoro. Un TTL di 30 minuti per un flusso di 2 minuti occupa inutilmente un IP e rende i log più difficili da leggere.
• Trattare un 429 come un problema IP. Un nuovo IP non cambia la regola del sito; rallentare sì. Vedi 429 Too Many Requests.
• Assumere rotazione a ogni richiesta. Keep-alive mantiene l'uscita; consulta la tabella sopra per la tua libreria.