Sesiones persistentes y rotación de IP: IDs de sesión, TTL y reutilización de conexión

¿Qué sucede en la puerta de enlace cuando envío un ID de sesión?

La puerta de enlace lee el nombre de usuario en cada nueva conexión. Sin una parte de sesión, selecciona una salida residencial que coincida con tu segmentación solo para esa conexión. Con una parte de sesión, mantiene la misma salida para ese ID hasta el TTL que configures.

Una IP fija es una conexión real de un hogar, por lo que puede desaparecer antes de que termine el TTL: el dispositivo se apaga, pierde Wi-Fi o cambia de red. Los flujos largos deben sobrevivir a eso, verificando la IP de salida en puntos de control y reiniciando desde un punto de control en lugar de fallar toda la tarea.

¿Cómo gestiono un grupo de sesiones sticky en Python?

Un grupo pequeño distribuye la carga entre varios proxies móviles 4G estables y retira cada uno tras un número establecido de solicitudes o tras una señal de que su proxy está fallando, como un 502 o 503. Nota lo que no hace: no cambia IPs para pasar un 403 o un 429. Eso significa que el sitio quiere que reduzcas la velocidad, así que el grupo los eleva a tu código.

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)

¿Cómo sé si una IP sticky ha cambiado?

Pregunta. Solicita un servicio de eco de IP como https://api.ipify.org usando la misma sesión al inicio del proceso y en cada punto de control, y compara las respuestas. Un cambio significa que el proxy residencial detrás de la sesión cambió: reinicia el flujo desde su último punto de control o abre una nueva sesión. Regístralo con el ID de sesión para distinguir cambios de IP del comportamiento del sitio al hacer debug.

¿Cuáles errores en las sesiones cuestan más?

• Rotar en cada solicitud de un flujo con varios pasos. El sitio ve un carrito, cursor o token de búsqueda saltar entre países y lo reinicia.
• Un ID de sesión para cada trabajador. Una sesión es para un solo flujo; da a cada trabajador y flujo su propio ID.
• Sesiones mucho más largas que el trabajo. Un TTL de 30 minutos para un flujo de 2 minutos mantiene una IP ocupada inútilmente y complica los registros.
• Tratar un 429 como problema de IP. Una IP nueva no cambia la regla del sitio; reducir la velocidad sí. Consulta 429 Too Many Requests.
• Asumir rotación en cada solicitud. Keep-alive mantiene el proxy; verifica la tabla arriba según tu biblioteca.