Sticky sessions en IP-rotatie: sessie-ID’s, TTL en hergebruik verbinding

Wat gebeurt er bij de gateway wanneer ik een sessie-ID verzend?

De gateway leest de gebruikersnaam bij elke nieuwe verbinding. Zonder een sessie-onderdeel kiest hij een residentiële proxy als exit die bij je targeting past, alleen voor die verbinding. Met een sessie-onderdeel houdt hij dezelfde exit aan voor die ID tot de TTL die je instelt.

Een sticky IP is een echte huisverbinding, dus die kan verdwijnen vóór het einde van de TTL: het apparaat wordt uitgeschakeld, verliest Wi-Fi of wisselt netwerk. Lange flows moeten dit overleven door op checkpoints het exit-IP te controleren en opnieuw te starten vanaf een checkpoint in plaats van de hele klus te laten mislukken.

Hoe beheer ik een pool van sticky sessies in Python?

Een kleine pool verdeelt de last over enkele stabiele uitgangen en zet elke uitgang na een vastgesteld aantal verzoeken of bij een teken dat de uitgang faalt, zoals 502 of 503, uit de roulatie. Let op wat het juist niet doet: het wisselt geen IP's om langs een 403 of 429 te komen. Die betekenen dat de site wil dat je vertraagt, dus verhoogt de pool die aan jouw 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)

Hoe weet ik dat een sticky IP is veranderd?

Vraag het. Doe een IP-echo aanvraag, zoals https://api.ipify.org, via dezelfde sessie aan het begin van een flow en bij elk controlepunt, en vergelijk de antwoorden. Een verandering betekent dat de exit achter de sessie veranderde: start de flow opnieuw op vanaf het laatste controlepunt of open een nieuwe sessie. Log dit met het sessie-ID zodat je IP-wijzigingen kunt onderscheiden van sitegedrag bij het debuggen.

Welke sessiefouten kosten het meest?

• Roteren bij elk verzoek van een multi-step flow. De site ziet een winkelwagen, cursor of zoektoken tussen landen springen en reset het.
• Één sessie-ID voor elke worker. Een sessie is bedoeld voor één flow; geef elke worker en flow een eigen ID.
• Sessies veel langer dan de taak. Een TTL van 30 minuten voor een flow van 2 minuten houdt een IP onnodig bezet en maakt logs moeilijker leesbaar.
• Een 429 behandelen als een IP-probleem. Een nieuw IP verandert de regels van de site niet; vertragen wel. Zie 429 Too Many Requests.
• Aannemen van rotatie per verzoek. Keep-alive behoudt de uitgang; zie de tabel hierboven voor je bibliotheek.