Sessões fixas e rotação de IPs: IDs de sessão, TTL e reutilização de conexão

O que acontece no gateway quando envio um ID de sessão?

O gateway lê o nome de usuário em cada nova conexão. Sem uma parte de sessão, ele escolhe uma saída residencial que corresponde ao seu direcionamento apenas para aquela conexão. Com uma parte de sessão, mantém a mesma saída para esse ID pelo TTL que você definir.

Um IP fixo é uma conexão residencial real, então pode desaparecer antes do TTL acabar: o dispositivo pode ser desligado, perder o Wi-Fi ou mudar de rede. Fluxos longos devem suportar isso, verificando o IP de saída em pontos de controle e reiniciando a partir de um ponto de controle em vez de falhar o trabalho todo.

Como gerencio um pool de sessões sticky em Python?

Um pequeno pool distribui a carga por algumas saídas estáveis e aposenta cada uma após determinado número de requisições ou ao sinal de que a saída está falhando, como 502 ou 503. Note o que ele não faz: não troca IPs para passar por um 403 ou 429. Isso significa que o site quer que você desacelere, então o pool levanta esses erros para seu 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)

Como sei que um IP sticky mudou?

Pergunte. Solicite um serviço de eco de IP como https://api.ipify.org na mesma sessão no início do fluxo e em cada checkpoint, e compare as respostas. Uma mudança indica que a saída atrás da sessão mudou: reinicie o fluxo do último checkpoint ou abra uma nova sessão. Registre isso com o ID da sessão para diferenciar mudanças de IP do comportamento do site na depuração.

Quais erros de sessão custam mais?

• Rotacionar a cada requisição de um fluxo multi-etapas. O site vê um carrinho, cursor ou token de busca pulando entre países e reinicia.
• Um ID de sessão para cada worker. Uma sessão é para um fluxo; dê a cada worker e fluxo o seu próprio ID.
• Sessões muito mais longas que o trabalho. TTL de 30 minutos para fluxo de 2 minutos ocupa IP sem necessidade e dificulta a leitura dos logs.
• Tratar um 429 como problema de IP. Novo IP não altera regra do site; desacelerar sim. Veja 429 Too Many Requests.
• Assumir rotação por requisição. Keep-alive mantém a saída; confira a tabela acima para sua biblioteca.