Sebagian besar kode proxy memiliki satu jalur kesalahan — tangkap semuanya, rotasi, coba lagi — dan jalur tunggal itulah yang membuat pool cepat habis dan target meningkat. Permintaan proxy yang gagal adalah salah satu dari lima peristiwa berbeda: proxy itu sendiri tidak dapat dijangkau; proxy menolak kredensial Anda; target menolak IP ini; target membatasi kecepatan Anda; atau target menjawab 200 dengan halaman tantangan alih-alih konten. Rotasi membantu tepat pada salah satu dari itu. Mencoba ulang segera tidak membantu sama sekali. Panduan ini mengklasifikasikan kegagalan, lalu membangun lapisan retry Python yang ringkas yang merespons masing-masing dengan benar, dengan backoff eksponensial, rotasi hanya jika diperlukan, dan circuit breaker sehingga target yang telah berkata “berhenti” benar-benar dibiarkan. Cuplikan kode menggunakan requests; logikanya dapat dipindahkan langsung ke httpx dan aiohttp (nama parameter di Proxies in Python).

Lima jenis kegagalan

#Apa yang terjadiBagaimana muncul di PythonRespons yang tepat
1Proxy tidak dapat dijangkau — host/port salah, gangguan penyedia, jaringanProxyError yang membungkus kesalahan koneksi; ConnectTimeout sebelum HTTP apa punCoba lagi dengan backoff; setelah N kegagalan, tandai endpoint proxy mati dan beri peringatan. Rotasi dalam gateway yang sama tidak akan membantu jika gateway-nya mati.
2Proxy menolak Anda — kredensial salah, IP tidak masuk daftar putih, paket habisProxyError dengan 407; kadang 4xx khusus penyedia dari gatewayJangan coba lagi. Perbaiki konfigurasi; mencoba ulang 407 dalam loop dapat membuat akun Anda dibatasi oleh penyedia.
3Target menolak IP ini — reputasi, ASN, blokir geo403, kadang 401/451; kadang koneksi di-resetRotasi ke exit baru (session ID baru) dan cookie jar baru; coba lagi sekali atau dua kali; jika berlanjut di berbagai IP, masalahnya adalah sidik jari atau tipe, bukan IP — berhenti dan evaluasi ulang (alasannya).
4Target membatasi kecepatan Anda429, atau 503 dengan Retry-AfterTidur selama Retry-After (atau backoff) pada exit ini; lalu lanjutkan di sana. Merotasi alih-alih menunggu justru menyebarkan blokir. Lihat sinyal batas kecepatan.
5Tantangan disajikan sebagai 200 — halaman CAPTCHA/interstitialStatus 200 tetapi body bukan konten yang diharapkanPerlakukan sebagai kegagalan tipe 3. Deteksi berdasarkan konten (teks penanda, elemen yang diharapkan hilang, body terlalu kecil), jangan pernah hanya berdasarkan status.
—Jaringan sementara / target 5xxReadTimeout, ConnectionError di tengah aliran, 500/502/504Coba lagi dengan backoff pada exit yang sama; ini biasanya bukan tentang Anda.

Tabel di atas adalah inti artikel; semua di bawah ini adalah membuat program mematuhinya.

Klasifikasi dulu

import requests
from enum import Enum

class Fail(Enum):
    NONE = 0; PROXY_DOWN = 1; PROXY_AUTH = 2; IP_BLOCKED = 3; RATE_LIMITED = 4; CHALLENGE = 5; TRANSIENT = 6

CHALLENGE_MARKERS = (b"captcha", b"cf-chl", b"challenge-platform", b"datadome", b"px-captcha")

def classify(resp: requests.Response | None, exc: Exception | None, min_bytes: int = 2000) -> Fail:
    if exc is not None:
        if isinstance(exc, requests.exceptions.ProxyError):
            return Fail.PROXY_AUTH if "407" in str(exc) else Fail.PROXY_DOWN
        if isinstance(exc, (requests.exceptions.ConnectTimeout,)):
            return Fail.PROXY_DOWN            # tidak pernah mencapai proxy (atau tidak pernah menjawab CONNECT)
        if isinstance(exc, (requests.exceptions.ReadTimeout, requests.exceptions.ConnectionError)):
            return Fail.TRANSIENT
        return Fail.TRANSIENT
    s = resp.status_code
    if s == 429 or (s == 503 and "Retry-After" in resp.headers):
        return Fail.RATE_LIMITED
    if s in (401, 403, 451):
        return Fail.IP_BLOCKED
    if s >= 500:
        return Fail.TRANSIENT
    if s == 200:
        body = resp.content[:20000].lower()
        if len(resp.content) < min_bytes or any(m in body for m in CHALLENGE_MARKERS):
            return Fail.CHALLENGE
        return Fail.NONE
    return Fail.TRANSIENT

Sesuaikan CHALLENGE_MARKERS dan min_bytes per target: pemeriksaan yang andal adalah “apakah halaman berisi elemen yang saya cari?” — judul produk, kunci JSON — dan ketidakhadirannya adalah sinyal tantangan.

Backoff, dilakukan dengan benar

Backoff eksponensial dengan jitter: penundaan yang berlipat ganda menyebarkan percobaan ulang; jitter mencegah seratus pekerja mencoba ulang secara bersamaan. Hormati Retry-After jika ada.

import random, time, email.utils

def backoff_delay(attempt: int, base: float = 1.0, cap: float = 60.0) -> float:
    return random.uniform(0, min(cap, base * (2 ** attempt)))     # "full jitter"

def retry_after_seconds(resp: requests.Response | None) -> float | None:
    if resp is None or "Retry-After" not in resp.headers:
        return None
    v = resp.headers["Retry-After"].strip()
    if v.isdigit():
        return float(v)
    dt = email.utils.parsedate_to_datetime(v)      # bentuk HTTP-date
    return max(0.0, dt.timestamp() - time.time()) if dt else None

Circuit breaker per (target, exit)

Ketika sebuah target telah menolak sebuah exit beberapa kali berturut-turut, berhentilah menawarkan exit itu ke target tersebut untuk sementara waktu alih-alih menemukan blokir pada setiap permintaan. Ide yang sama untuk endpoint proxy yang mati.

import time
from collections import defaultdict

class Breaker:
    def __init__(self, threshold=3, cooldown=300):
        self.fail = defaultdict(int); self.open_until = {}
        self.threshold, self.cooldown = threshold, cooldown
    def allow(self, key) -> bool:
        return time.time() >= self.open_until.get(key, 0)
    def ok(self, key):
        self.fail[key] = 0
    def bad(self, key):
        self.fail[key] += 1
        if self.fail[key] >= self.threshold:
            self.open_until[key] = time.time() + self.cooldown
            self.fail[key] = 0

Menggabungkan semuanya

import secrets

GATE, PORT, PASS = "gate.provider.com", 7777, "PASSWORD"
breaker = Breaker()

def proxies_for(session_id: str) -> dict:
    url = f"http://customer-session-{session_id}:{PASS}@{GATE}:{PORT}"
    return {"http": url, "https": url}

def fetch(url: str, host: str, max_attempts: int = 5, timeout=(10, 30)) -> requests.Response | None:
    sid = secrets.token_hex(4)
    sess = requests.Session()
    for attempt in range(max_attempts):
        key = (host, sid)
        if not breaker.allow(key) or not breaker.allow(("gateway", GATE)):
            sid = secrets.token_hex(4); sess = requests.Session(); continue   # pilih exit yang berbeda
        resp = exc = None
        try:
            resp = sess.get(url, proxies=proxies_for(sid), timeout=timeout)
        except requests.RequestException as e:
            exc = e
        kind = classify(resp, exc)

        if kind is Fail.NONE:
            breaker.ok(key); breaker.ok(("gateway", GATE)); return resp
        if kind is Fail.PROXY_AUTH:
            raise RuntimeError("proxy menolak kredensial/whitelist — perbaiki konfigurasi, bukan retry")
        if kind is Fail.PROXY_DOWN:
            breaker.bad(("gateway", GATE)); time.sleep(backoff_delay(attempt, base=2)); continue
        if kind is Fail.RATE_LIMITED:
            time.sleep(retry_after_seconds(resp) or backoff_delay(attempt, base=5)); continue   # exit yang sama
        if kind in (Fail.IP_BLOCKED, Fail.CHALLENGE):
            breaker.bad(key)
            sid = secrets.token_hex(4); sess = requests.Session()        # exit baru + cookie baru
            time.sleep(backoff_delay(attempt)); continue
        # TRANSIENT
        time.sleep(backoff_delay(attempt)); continue
    return None

Apa yang dilakukan kode ini yang tidak dilakukan loop naif: ia tidak pernah mencoba ulang 407; ia menunggu pada batas kecepatan alih-alih berpindah; ia hanya merotasi pada penolakan tingkat IP dan tantangan, dan memasangkan setiap rotasi dengan cookie jar baru (cookie yang sama pada IP baru adalah pengunjung yang sama); ia berhenti menawarkan exit yang terus gagal pada sebuah host; dan ia melakukan backoff dengan jitter di mana-mana. Hubungkan hitungan Fail ke metrik Anda — tingkat IP_BLOCKED yang meningkat di berbagai exit yang berbeda berarti sidik jari atau tipe IP salah, dan tidak ada kebijakan retry yang akan memperbaikinya (lihat TLS fingerprinting dan memilih tipe IP).

Menggunakan pustaka sebagai gantinya

tenacity memberi Anda dekorator untuk kondisi retry/backoff/stop dan merupakan basis yang baik — tetapi tetap simpan klasifikasi dan keputusan “rotasi vs tunggu vs berhenti” dalam kode Anda sendiri; pustaka retry generik memperlakukan semua pengecualian sama, yang justru merupakan kesalahan. Objek Retry milik urllib3 (dapat dipasang pada HTTPAdapter requests) menangani retry tingkat koneksi dan Retry-After untuk 429/503 dengan baik, dan layak digunakan untuk kelas TRANSIENT dan RATE_LIMITED; ia tidak dapat merotasi proxy Anda atau mendeteksi body tantangan, sehingga ia melengkapi, bukan menggantikan, lapisan di atas.

Catatan async

Dalam aiohttp/httpx.AsyncClient strukturnya identik dengan await asyncio.sleep(); satu tambahan adalah semaphore per-host sehingga backoff pada satu host tidak menghentikan yang lain, dan konkurensi per host tetap sopan. Semaphore global saja memungkinkan seratus korutin menumpuk ke satu target saat ia satu-satunya yang tidak tidur.

Pertanyaan yang sering diajukan

Haruskah saya merotasi proxy pada setiap kesalahan?

Tidak. Rotasi pada penolakan tingkat IP (kelas 403) dan halaman tantangan, selalu dengan cookie jar baru. Tunggu — jangan rotasi — pada 429/Retry-After. Perbaiki konfigurasi pada 407. Coba lagi exit yang sama pada kesalahan sementara dan 5xx.

Berapa kali saya harus mencoba ulang?

Tiga hingga lima percobaan dengan backoff eksponensial dan jitter adalah batas umum; lebih dari itu Anda menghadapi blokir persisten (batas rotasi tercapai) atau gangguan (breaker harus terbuka). Batasi total waktu tunggu per permintaan.

Bagaimana cara mendeteksi halaman CAPTCHA dalam kode?

Berdasarkan konten, bukan status: periksa elemen yang Anda harapkan (judul, kunci JSON), penanda tantangan yang dikenal di body, dan respons yang terlalu kecil. 200 tanpa konten Anda adalah kegagalan.

Apa itu circuit breaker untuk proxy?

Penghitung per (target, exit) yang, setelah beberapa kegagalan berturut-turut, berhenti menggunakan exit itu untuk target itu selama periode cooldown — sehingga Anda tidak menemukan blokir pada setiap permintaan dan tidak terus menghantam host yang menolak Anda.

Mengapa tidak menggunakan tenacity atau urllib3 Retry saja?

Gunakan untuk retry sementara dan batas kecepatan; tetapi mereka tidak dapat membedakan 407 dari 403 dari tantangan, tidak dapat merotasi session ID Anda, dan tidak dapat mengatur ulang cookie. Simpan logika keputusan itu dalam kode Anda.

Apa artinya tingkat blokir yang meningkat di banyak IP?

Itu berarti IP bukan masalahnya: target mengidentifikasi Anda melalui sidik jari TLS/HTTP, header, atau perilaku, atau tipe IP salah untuk situs itu. Berhenti merotasi dan perbaiki lapisan yang sebenarnya gagal.