Wie man Proxies in Python rotiert

Ein Proxy verbirgt Ihre echte IP hinter einer Zwischen-IP, aber ein einzelner statischer Proxy ist immer noch eine IP, die ein Ziel mit einer Ratenbegrenzung belegen und sperren kann. Die Proxy-Rotation wechselt die ausgehende IP pro Anfrage oder pro Sitzung, sodass derselbe Scraper scheinbar von vielen verschiedenen Quellen stammt.

Dies ist wichtig, da Anti-Bot-Systeme stark auf Ratenbegrenzung setzen und die Anzahl der Anfragen pro IP in einem bestimmten Zeitfenster begrenzen, bevor sie mit 429-Fehlern antworten. Die Rotation innerhalb eines gesunden Pools hält jede IP unter diesen Schwellenwerten und verhindert, dass eine einzige Sperre den gesamten Job zunichte macht.

Die Rotation ist nur so gut wie die IPs, die Sie rotieren. Die Wahl des falschen Typs ist der Grund, warum Teams Wochen damit verbringen, die Logik auf ein Ziel abzustimmen, das ihren Datenverkehr niemals akzeptieren würde.

Die erste Entscheidung bei der Proxy-Rotation in Python betrifft nicht den Algorithmus, sondern die Anpassung des Pools an die Abwehrmaßnahmen.

Verwenden Sie Python 3.8+ in einer virtualenv. Installieren Sie Requests und aiohttpund speichern Sie die Proxys in einer einfachen Textdatei, damit der Rotator sie im laufenden Betrieb neu laden kann.

mkdir proxy_rotator && cd proxy_rotator
python -m venv .venv && source .venv/bin/activate
pip install requests aiohttp
touch app.py proxies.txt

Sie können eine proxies.txt aus öffentlichen Quellen (kostenlose Proxy-Aggregatoren, GitHub-Mirrors) zusammenstellen oder Zugangsdaten aus einem kostenpflichtigen Pool laden. In jedem Fall ist damit zu rechnen, dass ein erheblicher Teil bereits vor Ihrer ersten Anfrage nicht mehr funktioniert, insbesondere bei kostenlosen Listen, bei denen die meisten Einträge möglicherweise bereits von beliebten Zielen blockiert wurden.

Verwende einen Eintrag pro Zeile in der Form http://host:port oder http://user:pass@host:port, und überprüfen Sie diese anschließend anhand eines IP-Echo-Endpunkts:

import requests

def validate(proxy, timeout=5):
    try:
        r = requests.get("https://httpbin.io/ip",
                         proxies={"http": proxy, "https": proxy},
                         timeout=timeout)
        return r.ok and proxy.split("@")[-1].split(":")[0] in r.text
    except requests.RequestException:
        return False

with open("proxies.txt") as f:
    pool = [p.strip() for p in f if p.strip() and validate(p.strip())]

Die IP-Abgleichprüfung erkennt transparente Proxys, die Ihre echte Adresse durchlassen. Für eine gründlichere Überprüfung pingen Sie eine echte Zielseite an, anstatt nur httpbin.io/ip.

Bevor Sie irgendetwas rotieren, stellen Sie sicher, dass ein Proxy durchgängig funktioniert. Requests akzeptiert ein proxies Dict get() oder auf eine Session; dieselbe URL funktioniert in der Regel für beide http und https Schlüsseln.

import requests

proxy = "http://user:pass@host:port"   # auth is embedded in the URL
proxies = {"http": proxy, "https": proxy}

with requests.Session() as s:
    s.proxies.update(proxies)
    r = s.get("https://httpbin.io/ip", timeout=10)
    print(r.status_code, r.json())

Wenn Sie die Proxy-Konfiguration lieber aus dem Code heraushalten möchten, setzen Sie die HTTP_PROXY und HTTPS_PROXY ; Requests liest diese automatisch aus. Kostenlose Proxys lösen oft SSLError: CERTIFICATE_VERIFY_FAILED , da sie TLS abfangen. Als vorübergehende Abhilfe können Sie verify=False, aber betrachten Sie dies als Debugging-Tool und nicht als Produktionskonfiguration, da dadurch die Zertifikatsvalidierung vollständig deaktiviert wird.

Sobald eine einzelne Anfrage funktioniert, wird die Frage, wie man Proxys in Python rotiert, zu einem Kompromiss zwischen Vorhersehbarkeit, Unauffälligkeit und Durchsatz. Die drei folgenden Muster decken fast jeden realen Scraper ab.

Bei der sequenziellen Rotation wird der Pool der Reihe nach durchlaufen und dann wieder von vorne begonnen, wodurch der Datenverkehr gleichmäßig verteilt wird. Dies ist das am einfachsten zu verstehende Muster, da die nächste IP-Adresse immer bekannt ist.

import itertools, requests

with open("proxies.txt") as f:
    proxies = [p.strip() for p in f if p.strip()]

pool = itertools.cycle(proxies)

for _ in range(8):
    proxy = next(pool)
    r = requests.get("https://httpbin.io/ip",
                     proxies={"http": proxy, "https": proxy},
                     timeout=10)
    print(proxy, r.status_code)

Der Nachteil ist, dass eine deterministische Reihenfolge selbst einen Fingerabdruck darstellt. Wenn ein Verteidiger innerhalb von Sekunden die IPs A, B, C, D, A, B, C, D aus demselben Browser-Fingerabdruck sieht, kann er den gesamten Pool markieren. Die sequenzielle Rotation funktioniert am besten bei größeren Pools mit längeren Verzögerungen pro IP.

Die zufällige Rotation durchbricht das Muster, indem bei jeder Anfrage ein beliebiger Proxy ausgewählt wird, was die Korrelation des Datenverkehrs erschwert.

import random, requests

with open("proxies.txt") as f:
    proxies = [p.strip() for p in f if p.strip()]

for _ in range(8):
    proxy = random.choice(proxies)
    r = requests.get("https://httpbin.io/ip",
                     proxies={"http": proxy, "https": proxy},
                     timeout=10)
    print(proxy, r.status_code)

Der Nachteil ist eine ungleichmäßige Auslastung: Ein kleiner Pool wird einige IPs überbeanspruchen und andere ungenutzt lassen. Für eine bessere Auslastung ziehen Sie ohne Zurücklegen, bis der Pool erschöpft ist, und mischen Sie dann neu. random.sample(proxies, len(proxies)) und mischen Sie anschließend neu. Dadurch bleiben die Anfragen unvorhersehbar, während die Last weiterhin verteilt wird.

Wenn Ihr Pool auf mehr als ein paar Dutzend IPs anwächst, wird die serielle Validierung zum Engpass. Die asynchrone Rotation führt viele Anfragen gleichzeitig in einem einzigen Thread aus, was die Validierungszeit drastisch verkürzt und es einem Worker-Pool ermöglicht, eine Aufgabenliste abzuarbeiten, ohne durch langsame Proxys blockiert zu werden.

import asyncio, aiohttp

CONCURRENCY = 20
TIMEOUT = aiohttp.ClientTimeout(total=10)

async def check_proxy(session, proxy, sem):
    async with sem:
        try:
            async with session.get("https://httpbin.io/ip",
                                   proxy=proxy, timeout=TIMEOUT) as r:
                return proxy, r.status, await r.text()
        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
            return proxy, None, str(e)

async def main(proxies):
    sem = asyncio.Semaphore(CONCURRENCY)
    async with aiohttp.ClientSession() as session:
        tasks = [check_proxy(session, p, sem) for p in proxies]
        return await asyncio.gather(*tasks)

with open("proxies.txt") as f:
    proxies = [p.strip() for p in f if p.strip()]
results = asyncio.run(main(proxies))

Der Semaphor begrenzt die Anzahl der gleichzeitig ausgeführten Anfragen, damit Sie die Dateideskriptoren nicht erschöpfen oder die Burst-Limits des Ziels überschreiten. aiohttp stellt ein Argument pro Anfrage proxy= Argument, das in der Dokumentation zum aiohttp-Advanced-Client zusammen mit dem Verhalten von Auth und Trust-Env ausführlich behandelt wird.

Die Rotation von IPs allein lässt immer noch einen Fingerabdruck erkennen. Wenn 200 verschiedene IPs denselben Standard- python-requests/2.31.0 User-Agent senden, kann ein Anti-Bot-System diese sofort miteinander in Verbindung bringen.

Rotieren Sie Header zusammen mit Proxys und binden Sie Cookies an die Identität, die sie gesetzt hat:

import random

UAS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) AppleWebKit/605.1.15 ...",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ...",
]
LANGS = ["en-US,en;q=0.9", "en-GB,en;q=0.8", "de-DE,de;q=0.9,en;q=0.8"]

def rotated_headers():
    return {"User-Agent": random.choice(UAS),
            "Accept-Language": random.choice(LANGS),
            "Referer": "https://www.google.com/"}

Binde einen User-Agent und einen Cookie-Jar für die Dauer einer logischen Sitzung an einen Proxy und rotier sie dann gemeinsam, wenn du die Identität wechselst.

Die meisten Anfänger-Rotatoren verwerfen einen Proxy bei jedem Fehler. Dadurch werden IPs verworfen, die lediglich einer Ratenbegrenzung unterliegen, und ein defekter Proxy wird genauso behandelt wie ein Ziel, das dich auffordert, langsamer zu machen.

Behandeln Sie den Antwortcode als Signal. Gemäß RFC 6585 bedeutet 429 zu viele Anfragen, nicht einen ausgefallenen Proxy: Warten Sie ab und versuchen Sie es erneut mit derselben IP. Brechen Sie bei 407 oder wiederholten Verbindungsfehlern ab und stellen Sie fehlerhafte Proxys unter Quarantäne, damit Sie sie nach einer Abkühlphase erneut überprüfen können.

import time, random
from collections import defaultdict

class ProxyManager:
    def __init__(self, proxies, max_fail=3, cooldown=300):
        self.live, self.dead = list(proxies), {}
        self.fails = defaultdict(int)
        self.max_fail, self.cooldown = max_fail, cooldown

    def get(self):
        self._revive()
        return random.choice(self.live) if self.live else None

    def report(self, proxy, status=None, error=None):
        if status == 429 or (status and 500 <= status < 600):
            time.sleep(min(2 ** self.fails[proxy], 30))   # keep, back off
        elif status == 407 or error:
            self.fails[proxy] += 1
            if self.fails[proxy] >= self.max_fail:
                self.live.remove(proxy)
                self.dead[proxy] = time.time() + self.cooldown

    def _revive(self):
        now = time.time()
        for p, t in list(self.dead.items()):
            if now >= t:
                self.live.append(p); self.dead.pop(p); self.fails[p] = 0

Passen Sie max_fail und die Basisverzögerung an Ihr Verkehrsprofil an, anstatt die Standardeinstellungen blind zu übernehmen.

Einen eigenen Rotator zu entwickeln, ist für Lernzwecke und kleine Aufgaben in Ordnung. In großem Maßstab wird es zu einem zweiten Produkt: Proxy-Wechsel, Validatoren, Wiederholungsversuche und Bereitschaftsdienst, wenn ein Ziel seinen Stack aktualisiert.

Ein verwalteter rotierender Proxy oder eine Scraper-API verbirgt dies hinter einem Endpunkt und berechnet pro erfolgreicher Anfrage.

Der Sinn des Lernens, wie man Proxys in Python rotiert, besteht nicht darin, einen Rotator auf Dauer zu betreiben; vielmehr geht es darum zu wissen, wann manuelle Rotation ausreicht und wann man diese Aufgabe delegieren sollte.

• Passen Sie den Proxy-Typ an das Ziel an, bevor Sie die Rotationslogik optimieren; die Rotation kostengünstiger Rechenzentrums-IPs gegen eine gehärtete Website ist ein aussichtsloser Kampf.
• Eine zuverlässige Python-Proxy-Rotationskonfiguration beginnt mit einem validierten Proxy-Pool, nicht mit einer zufälligen Liste, und überprüft nicht mehr funktionierende Proxys nach einer Abkühlphase erneut, da freie Pools zwischen funktionierendem und defektem Zustand wechseln.
• Verwenden Sie itertools.cycle für eine vorhersehbare Verteilung, random.choice für Tarnung und aiohttp mit asyncio für Validierung mit hohem Durchsatz und gleichzeitige Abrufe.
• Rotieren Sie User-Agent- und Header-Werte zusammen mit IPs, damit Sie hinter 200 verschiedenen Proxys keinen stabilen Fingerabdruck preisgeben.
• Erstellen Sie einen statusbewussten Rotator, der bei 429 und 5xx zurücksteckt, bei 407 oder wiederholten Verbindungsfehlern abbricht und schlechte Proxys unter Quarantäne stellt, anstatt jede Ausnahme auf die gleiche Weise abzufangen.

Wenn Sie Ihren eigenen Rotator erstellen, sind Sie für die Proxy-Liste, die Validierung, die Wiederholungslogik und das Geo-Routing verantwortlich. Ein rotierendes Proxy-Gateway stellt einen einzigen Endpunkt bereit, der bei jeder Anfrage eine IP-Adresse für Sie auswählt, während eine Scraping-API auch das Browser-Rendering, CAPTCHAs und das Entsperren übernimmt. DIY bietet Ihnen maximale Kontrolle; Gateways und APIs tauschen etwas Kontrolle gegen deutlich weniger Infrastrukturcode ein.

Eine nützliche Faustregel für den Anfang ist eine funktionierende IP pro gleichzeitigem Worker plus das 5- bis 10-fache als Reserve, um Fluktuation, Sperrungen und ausgefallene Proxys abzufangen. Kleine Jobs mit einigen Tausend Anfragen können auf 20 bis 50 geprüften privaten IPs laufen; Scrapes, die auf schwer zu knackende Ziele oder Millionen von Seiten abzielen, benötigen in der Regel Tausende von rotierenden IPs, um die Anfrage-Rate pro IP niedrig zu halten.

Kostenlose Proxys werden von vielen Fremden gemeinsam genutzt, die ihre eigenen Scraper betreiben, sodass die IPs in der Regel bereits von beliebten Zielen auf die Blacklist gesetzt wurden, noch bevor Sie sie überhaupt verwenden. Außerdem weisen sie offensichtliche Sicherheitslücken auf, indem sie Header wie Via oder X-Forwarded-For, die nicht mit der angegebenen IP übereinstimmen, oder durch TLS-Fehler. Eine Rotation kann eine IP-Adresse, die bereits auf der Sperrliste steht, nicht beheben.

Verwenden Sie Sticky Sessions immer dann, wenn das Ziel den Status an eine IP bindet, z. B. bei angemeldeten Seiten, mehrstufigen Checkouts oder JavaScript-intensiven Abläufen, die viele Unteranfragen auslösen. Wechseln Sie pro Anfrage, wenn Sie zustandslose Listen, Suchseiten oder Produktfeeds scrapen. Ein gängiges Muster ist eine IP pro logischer Sitzung, gefolgt von einer neuen IP für die nächste Sitzung.

Ja, mit einigen Anpassungen. Beide Browser-Automatisierungstools unterstützen Proxy-Einstellungen, aber Sie müssen in der Regel pro Proxy einen Browser-Kontext starten, da die meisten Treiber es nicht zulassen, den Proxy während einer Sitzung zu wechseln. Richten Sie einen Worker-Pool aus Browsern ein, wobei jeder an eine IP-Adresse und einen User-Agent gebunden ist, und rotieren Sie die Worker selbst, anstatt die Proxy-Variable innerhalb eines einzelnen Browsers zu wechseln.

Zu wissen, wie man Proxys in Python rotiert, ist eine grundlegende Fähigkeit für jeden Entwickler, der über einen Scraper mit einer einzigen IP hinaus skalieren möchte. Sie verfügen nun über die Bausteine: Wählen Sie den richtigen Proxy-Typ für Ihr Ziel, validieren Sie den Pool, bevor Sie ihm vertrauen, rotieren Sie sequenziell, zufällig oder asynchron, je nach Ihren Abwägungen, integrieren Sie User-Agent-Rotation und verwenden Sie einen statusbewussten Manager, damit ein einzelner 429-Fehler keine funktionierende IP lahmlegt.

Schwieriger ist es, den Betrieb sauber aufrechtzuerhalten, wenn Ziele ihre Abwehrmaßnahmen ohne Vorwarnung ändern. Kostenlose Listen veralten, Residential-Pools müssen neu ausbalanciert werden und 429-Regeln verschieben sich. Wenn Sie Ihre Entwicklungszeit lieber für die Daten als für die Infrastruktur aufwenden möchten, übernimmt die Scraper-API von WebScrapingAPI die Proxy-Rotation, die Umgehung von Anti-Bot-Maßnahmen und Wiederholungsversuche hinter einem einzigen Endpunkt, sodass Sie Ihren Requests- oder aiohttp Code beibehalten und lediglich die Abrufebene austauschen. Wechseln Sie die IPs selbst, wenn Sie lernen oder kleinere Aufgaben erledigen möchten, und greifen Sie auf eine verwaltete Ebene zurück, wenn die Wartungskosten die Einsparungen übersteigen.