Cara Memecahkan Blokir 403 DataDome di Scrapy dengan Middleware

Untuk menangani DataDome di Scrapy, taruh semua pekerjaannya dalam satu downloader middleware. Middleware itu mengenali halaman blokir 403, mengambil cookie datadome dari CapSkip dengan metode datadome milik SDK Python, lalu mencoba ulang dengan cookie itu, User-Agent-nya dan proxy yang sama. Berhasil tidaknya penyiapan DataDome Scrapy bergantung pada nomor prioritas, duplicate filter, panggilan SDK yang memblokir, dan satu cookie jar per proxy. Panduan ini memasang pemecah DataDome CapSkip ke dalam proyek Scrapy dan melaporkan apa yang dihasilkan setiap pilihan dalam uji coba saya.
Apa yang Anda butuhkan
- PC Windows dengan CapSkip 3.2.0 atau lebih baru, rilis pertama yang mendukung DataDome. Ikuti panduan penyiapan untuk menginstal CapSkip dan menjalankannya.
- Python 3.11 atau lebih baru, yang dibutuhkan oleh Scrapy 2.20, w3lib dan itemadapter.
- Scrapy 2.14 atau lebih baru. Pada 2.13.4 middleware gagal dengan TypeError, karena rilis itu masih meneruskan "spider" ke setiap metode middleware.
- capskip 1.5.0 atau lebih baru, versi pertama dengan metode datadome.
- Alamat tempat CapSkip menjawab: 127.0.0.1 dalam mode Local, yang hanya menjangkau PC yang sama, atau IP jaringan atau IP publik Anda dalam mode Server.
- Satu proxy sticky per identitas crawl, berupa URL lengkap seperti
http://user:[email protected]:8080. Proxy yang mengganti IP keluarnya pada setiap koneksi tidak dapat menghasilkan cookie yang berfungsi, menurut dokumentasi CapSkip.
Di prompt PowerShell, buat proyek tempat semua blok di bawah ini dimasukkan. Nama file relatif terhadap folder yang berisi scrapy.cfg, dan blok yang membuka sebuah file menggantikan file hasil generate.
pip install scrapy capskip scrapy startproject shop cd shop
Saya menguji dengan mock server buatan saya, bukan situs DataDome sungguhan dan bukan aplikasi CapSkip. Satu mock menyalin pemeriksaan in.php dan res.php dari dokumentasi API CapSkip. Mock yang lain menjawab 403 kecuali request membawa cookie yang diterbitkan mock pertama, untuk User-Agent dan proxy yang menjadi tujuan penerbitannya; aturan pengikatan itu berasal dari dokumentasi CapSkip, bukan dari DataDome. Saya menjalankan Python 3.11.7 dan 3.14.0. Kecuali disebutkan lain, hitungan berasal dari Scrapy 2.20.0 dan capskip 1.7.0, dengan DOWNLOAD_DELAY bernilai 0 dan mock yang memecahkan dalam 0.4 detik, dan hasilnya sama di kedua Python. Scrapy 2.14.0 dengan capskip 1.5.0 dan Scrapy 2.19.0 dengan capskip 1.6.0 memberi hitungan yang sama dalam beberapa kasus.
Membuat middleware DataDome Scrapy
Langkah 1: pilih nomor prioritas
Scrapy memanggil process_request dari nomor kecil ke besar, dan process_response dari nomor besar ke kecil, sehingga nomor yang lebih besar berada lebih dekat ke downloader. HttpCompressionMiddleware di 590 membuka kompresi body, jadi nomor kita harus lebih kecil dari 590 agar dapat membaca halaman blokir. RetryMiddleware di 550 mengubah respons menjadi percobaan ulang, jadi nomor kita harus lebih besar agar melihatnya lebih dulu. Itu menyisakan 551 sampai 589, dan karena 580 milik MetaRefreshMiddleware, pengaturannya memakai 570. Blok-blok di bawah membentuk satu proyek, ditempel berurutan, dan tidak ada yang berjalan sendiri.
# shop/settings.py: add these lines at the end
DOWNLOADER_MIDDLEWARES = {
# process_response runs from high numbers to low, so 570 sees a response
# after HttpCompressionMiddleware (590) and before RetryMiddleware (550).
"shop.middlewares.DataDomeMiddleware": 570,
}
DATADOME_CAPSKIP_HOST = "127.0.0.1" # Server mode: your server's address
DATADOME_CAPSKIP_PORT = 8080
DATADOME_MAX_SOLVES = 3 # per request, and per domain and jar between good pagesPada 650, halaman blokir yang di-gzip sampai ke middleware sebagai byte 1f 8b dan 403 lolos begitu saja; pada 570 halaman itu terpecahkan. Dengan 403 di RETRY_HTTP_CODES, situs mock menyajikan 3 halaman blokir sebelum pemecahan pada 540 dan 1 halaman pada 570.
Langkah 2: kenali halaman blokir
Blokir DataDome datang sebagai status 401 atau 403. Jika halamannya sudah memuat iframe tantangan, kode mengambil alamat itu apa adanya, seperti yang dinyatakan dokumentasi CapSkip. Jika tidak, kode menyusun captcha_url dari objek skrip dd, tempat nilai rt menentukan path: /interstitial/ untuk pemeriksaan perangkat dan /captcha/ untuk slider. Tabel di dokumentasi mencantumkan parameter t hanya untuk /captcha/, tetapi JavaScript milik dokumentasi itu sendiri menyetelnya tanpa syarat, dan saya mengikuti JavaScript-nya. Apa pun yang tidak terbaca mengembalikan None, sehingga 403 biasa lewat tanpa diubah. Sembilan respons buatan tangan mencakup setiap kasus, dan sebuah pemeriksaan perangkat mock memakai 1 task untuk 2 halaman. Tata letaknya berasal dari dokumentasi CapSkip, bukan dari halaman yang hidup.
# shop/middlewares.py
import asyncio
import html
import json
import logging
import re
from urllib.parse import urlencode
from capskip import ApiException, CapSkip, CapSkipError
from scrapy.http import TextResponse
from scrapy.utils.httpobj import urlparse_cached
log = logging.getLogger(__name__)
DD_OBJECT = re.compile(r"var\s+dd\s*=\s*(\{[^}]*\})")
IFRAME = re.compile(r'src="(https://[^"]*captcha-delivery\.com/(?:captcha|interstitial)/\?[^"]*)"')
def captcha_url_for(response):
"""The challenge address from a DataDome block page, or None."""
if response.status not in (401, 403) or not isinstance(response, TextResponse):
return None
frame = IFRAME.search(response.text)
if frame: # the page already carries the challenge address
return html.unescape(frame.group(1))
found = DD_OBJECT.search(response.text)
if not found:
return None
try:
dd = json.loads(found.group(1).replace("'", '"'))
path = "interstitial" if dd["rt"] == "i" else "captcha"
query = {"initialCid": dd["cid"], "hash": dd["hsh"], "cid": dd["cookie"],
"t": dd.get("t"), "referer": response.url, "s": dd["s"],
"e": dd.get("e"), "b": dd.get("b"), "dm": "cd"}
except (KeyError, ValueError):
return None # a dd object this code does not understand
query = {k: v for k, v in query.items() if v}
host = dd.get("host", "geo.captcha-delivery.com")
return f"https://{host}/{path}/?{urlencode(query)}"Langkah 3: simpan satu identitas per cookie jar
Sebuah cookie berada di jar yang dipilih oleh cookiejar key meta, sehingga middleware menyimpan satu identitas per jar: cookie, User-Agent-nya, proxy ketika CapSkip memilihnya, dan nomor generasi yang bertambah setiap pemecahan. Tanpa baris User-Agent, percobaan ulang keluar dengan User-Agent Scrapy bawaan, dan empat halaman langsung berakhir dengan 3 task dan tanpa satu pun halaman.
Cookie dimasukkan lewat argumen "cookies", yang disalin CookiesMiddleware di 700 ke dalam jar. Cookie itu ditambahkan hanya sampai satu request yang membawanya sudah kembali, sehingga cookie pengganti dari situs tidak tertimpa. Mock mengirim satu, dan halaman yang diambil sesudahnya membawanya tanpa task baru. Header Cookie tidak berfungsi, karena CookiesMiddleware membangun ulang header itu dari jar, dan mematikan cookie juga tidak berfungsi. Keduanya berakhir dengan 3 task dan tanpa satu pun halaman.
Atribut "Domain" dan "Path" berasal dari field "code" pada hasilnya, yang memuat cookie sebagaimana DataDome menyetelnya, sehingga cookie untuk situs bernama tetap memiliki domainnya. Mock memberi halaman di 127.0.0.1 sebuah cookie khusus host.
# shop/middlewares.py, continued
def cookie_attributes(code):
"""Domain, Path and the rest of a Set-Cookie string, names in lower case."""
pairs = (part.partition("=") for part in code.split(";")[1:])
return {name.strip().lower(): value.strip() for name, _, value in pairs if value}
def cookies_without(cookies, name):
"""A request's cookies as a list, minus any with this name."""
if isinstance(cookies, dict):
cookies = [{"name": k, "value": v} for k, v in cookies.items()]
return [c for c in cookies if c["name"] != name]
class Identity:
"""What every request in one cookie jar has to keep sending."""
def __init__(self):
self.user_agent = None
self.cookie = None # datadome=VALUE
self.attrs = {} # Domain and Path, from the cookie as DataDome set it
self.proxy = None # set only when CapSkip solved through its own list
self.generation = 0 # grows with every solve
self.fresh = False # True until a request has carried the cookie to the jar
class DataDomeMiddleware:
def __init__(self, crawler):
s = crawler.settings
self.stats = crawler.stats
self.max_solves = s.getint("DATADOME_MAX_SOLVES", 3)
self.solver = CapSkip(host=s.get("DATADOME_CAPSKIP_HOST", "127.0.0.1"),
port=s.getint("DATADOME_CAPSKIP_PORT", 8080))
self.identities = {} # cookiejar key -> Identity
self.solving = {} # cookiejar key -> the solve that is running
self.spent = {} # (domain, jar) -> solves since the last page that was not a block
@classmethod
def from_crawler(cls, crawler):
return cls(crawler)
def process_request(self, request):
# HttpProxyMiddleware (750) moves the proxy login into a header, so
# keep the proxy as the spider wrote it, login included.
request.meta.setdefault("dd_proxy", request.meta.get("proxy"))
ident = self.identities.get(request.meta.get("cookiejar"))
request.meta["dd_generation"] = ident.generation if ident else 0
if not ident:
return
# The cookie only works with the User-Agent and address that earned it.
request.headers["User-Agent"] = ident.user_agent
if ident.proxy:
request.meta["proxy"] = ident.proxy
if ident.fresh: # CookiesMiddleware (700) copies this into the jar
name, value = ident.cookie.split("=", 1)
cookie = {"name": name, "value": value,
"path": ident.attrs.get("path", "/")}
if "domain" in ident.attrs:
cookie["domain"] = ident.attrs["domain"]
request.cookies = cookies_without(request.cookies, name) + [cookie]
request.meta["dd_carried"] = ident.generationLangkah 4: pecahkan di dalam thread, lalu coba ulang
Metode datadome milik CapSkip memblokir selama polling. Jika dipanggil langsung dari sebuah coroutine, ia menahan reactor, jadi middleware menyerahkannya ke asyncio.to_thread. SDK juga menyediakan AsyncCapSkip, yang metode datadome-nya dapat Anda await. Request yang dicoba ulang menyetel dont_filter, karena URL-nya sudah melewati duplicate filter. Tanpa itu, dupefilter membuang kedua percobaan ulang, dan dupefilter/filtered bernilai 2.
# shop/middlewares.py, continued
async def solve(self, key, captcha_url, request):
proxy = request.meta.get("dd_proxy")
arg = None
if proxy: # solve through the proxy the crawl uses
scheme, rest = proxy.split("://", 1)
arg = {"type": scheme.upper(), "uri": rest}
# The SDK blocks, so it runs in a thread and the reactor stays free.
result = await asyncio.to_thread(
self.solver.datadome, captcha_url, request.url, proxy=arg)
ident = self.identities.setdefault(key, Identity())
ident.user_agent = result["userAgent"]
ident.cookie = result["cookie"]
ident.attrs = cookie_attributes(result["code"])
if result.get("proxy"):
ident.proxy = "http://" + result["proxy"]
ident.generation += 1
ident.fresh = True
self.stats.inc_value("datadome/solves")
return ident
def retry(self, request):
meta = {**request.meta, "dd_tries": request.meta.get("dd_tries", 0) + 1}
cookies = cookies_without(request.cookies, "datadome") # process_request adds the current one
# dont_filter: the dupefilter has already seen this URL
return request.replace(cookies=cookies, dont_filter=True, meta=meta)Ekstensi ini berdetak setiap 50 milidetik dan mencatat jeda terpanjang. Crawl memiliki satu halaman terblokir, 30 halaman terbuka dan 8 request sekaligus, mock membutuhkan 3 detik, dan hanya panggilan pemecahan yang berubah. Setiap baris adalah rentang dari sedikitnya tiga eksekusi pada setiap Python.
# shop/heartbeat.py (settings.py then needs EXTENSIONS = {"shop.heartbeat.Heartbeat": 500})
import asyncio
import time
from scrapy import signals
class Heartbeat:
"""Ticks every 50 ms and records the longest gap between two ticks."""
@classmethod
def from_crawler(cls, crawler):
ext = cls()
ext.stats = crawler.stats
crawler.signals.connect(ext.start, signals.spider_opened)
crawler.signals.connect(ext.stop, signals.spider_closed)
return ext
def start(self):
self.longest, self.last, self.running = 0.0, time.perf_counter(), True
self.tick()
def tick(self):
if self.running:
now = time.perf_counter()
self.longest = max(self.longest, now - self.last)
self.last = now
asyncio.get_running_loop().call_later(0.05, self.tick)
def stop(self):
self.running = False
self.stats.set_value("heartbeat/longest_gap_ms", round(self.longest * 1000))| Cara solve memanggil SDK | Jeda tick terpanjang pada satu PC |
|---|---|
| Panggilan langsung di dalam coroutine | sekitar 3770 sampai 3840 ms |
| asyncio.to_thread, kode di atas | sekitar 65 sampai 75 ms |
| AsyncCapSkip di-await di dalam coroutine | sekitar 220 sampai 530 ms |
| deferToThread dengan maybe_deferred_to_future | sekitar 65 sampai 90 ms |
| deferToThread di-await tanpa konversi | sekitar 65 sampai 80 ms, request hilang |
AsyncCapSkip, yang saya jalankan enam kali pada setiap Python, berfungsi tetapi macet lebih lama: setiap panggilan ke CapSkip membangun httpx client baru, dan membangunnya memakan sekitar 130 sampai 190 ms di PC ini. Baris terakhir tampak benar padahal tidak: ia memunculkan RuntimeError, Task got bad yield, dan request hilang. Seluruh middleware juga membutuhkan asyncio reactor, yang menjadi default di Scrapy 2.20.0. Di bawah select reactor klasik, ia memunculkan RuntimeError dan tidak mengirim task.
Langkah 5: tentukan apa yang dilakukan setiap respons yang terblokir
Request dalam satu jar diblokir bersamaan, dan masing-masing akan memulai pemecahan. Respons terblokir pertama memulainya dan menyimpannya di self.solving, dan yang lain dalam jar itu menunggunya. Delapan halaman melalui satu proxy menghasilkan 1 task dengan kode ini dan 8 task ketika setiap respons memecahkan sendiri. Menyetel CONCURRENT_REQUESTS_PER_DOMAIN ke 1 tidak mengurangi halaman blokir: empat halaman yang dikirim tanpa proxy tetap mengumpulkan empat halaman blokir sebelum cookie pertama tiba.
DATADOME_MAX_SOLVES membatasi dua hitungan, dan Anda memerlukan keduanya. Sebuah request dapat dicoba ulang sebanyak itu (dd_tries). Setiap pasangan domain dan cookie jar dapat memulai pemecahan sebanyak itu di antara halaman yang lolos (self.spent). Jika dikunci hanya oleh domain, lima jar yang masing-masing mengambil satu halaman sekaligus (16 request per domain diizinkan) mendapat 3 task dan kehilangan 2 halaman. Jika dikunci oleh domain dan jar, mereka mendapat 5 task dan 5 halaman. Sebuah URL yang menolak setiap cookie, di antara 60 halaman yang baik, terus mereset anggaran, dan hanya hitungan per request yang menghentikannya, pada 3 task. Karena CapSkip adalah pemecah captcha tanpa batas dengan lisensi tetap, batas ini menjaga dari loop, bukan dari dompet Anda.
# shop/middlewares.py, continued
async def process_response(self, request, response):
key = request.meta.get("cookiejar")
ident = self.identities.get(key)
if ident and request.meta.get("dd_carried") == ident.generation:
ident.fresh = False # the jar has seen the cookie by now
captcha_url = captcha_url_for(response)
budget = (urlparse_cached(request).hostname, key)
if captcha_url is None:
self.spent.pop(budget, None) # a page got through: reset the budget
return response
if request.meta.get("dd_tries", 0) >= self.max_solves:
return response
if ident and ident.generation > request.meta.get("dd_generation", 0):
return self.retry(request) # sent before the last solve
if self.spent.get(budget, 0) >= self.max_solves:
self.stats.inc_value("datadome/budget_used_up")
return response
task = self.solving.get(key)
if task is None: # the first blocked request starts the solve
self.spent[budget] = self.spent.get(budget, 0) + 1
task = asyncio.ensure_future(self.solve(key, captcha_url, request))
self.solving[key] = task
task.add_done_callback(lambda _: self.solving.pop(key, None))
try:
await task # the others in the same jar wait for it
except ApiException as err:
if "ERROR_PROXY" in str(err): # a retry through that address fails again
log.error("DataDome solve refused for the address: %s", err)
return response
log.warning("DataDome solve refused: %s", err)
return self.retry(request) # fetch the page again: a new challenge
except CapSkipError as err:
log.error("DataDome solve failed: %r", err)
return response
return self.retry(request)Langkah 6: satu cookie jar per proxy
Crawl melalui beberapa proxy memerlukan satu jar per proxy, sehingga setiap identitas memiliki satu alamat, dan spider menamai setiap jar sesuai proxy-nya. Scrapy tidak membawa kedua key itu ke request yang Anda bangun dari sebuah respons: tautan yang diikuti dengan response.follow dan tanpa meta keluar langsung lewat jar default, lalu diblokir dan dipecahkan lagi. Salin key proxy dan cookiejar ke setiap request yang Anda buat.
Satu jar yang dipakai bersama oleh dua proxy adalah kesalahan lainnya: delapan halaman yang dibagi di antara keduanya selesai dengan 12 halaman blokir, bukan 8 secara keseluruhan, pada ketiga eksekusi di setiap Python, dengan satu request dalam satu waktu dan jeda 0.2 detik. Kedua tata letak memakai 2 task.
# shop/spiders/shop.py import scrapy # your own sticky proxies, with the login if they need one PROXIES = ["http://user:[email protected]:8080", "http://user:[email protected]:8080"] # your own DataDome-protected pages URLS = [f"https://www.example.com/page/{n}" for n in range(1, 9)] class ShopSpider(scrapy.Spider): name = "shop" async def start(self): for n, url in enumerate(URLS): proxy = PROXIES[n % len(PROXIES)] # one cookie jar per proxy, named after it yield scrapy.Request(url, meta={"proxy": proxy, "cookiejar": proxy}) def parse(self, response): yield {"url": response.url, "status": response.status, "h1": response.css("h1::text").get()}
Kedua daftar berisi placeholder; untuk eksekusi saya, saya menggantinya dengan proxy dan halaman mock saya dan tidak mengubah hal lain. Dengan jeda template 1, ia memakai 2 task dan memuat kedelapan halaman. Scrapy memindahkan login proxy ke sebuah header sebelum respons kembali, jadi middleware menyimpan proxy sebagaimana tertulis; tanpa itu mock saya menerima task tanpa login.
# run this in the folder that holds scrapy.cfg scrapy crawl shop -O out.jsonl
Ketika CapSkip memecahkan lewat daftar proxy-nya sendiri, hasilnya menyebut proxy itu dan identitas menyimpannya, karena cookie hanya berfungsi melaluinya. Dokumentasi menyatakan proxy itu kembali tanpa login-nya, sehingga proxy dalam daftar yang memakai login belum diuji.
Error 403 DataDome yang mungkin Anda temui di Scrapy
Saya memicu setiap baris dalam eksekusi terhadap mock saya, kecuali dd objek yang hilang dan halaman yang hanya berisi iframe, yang hanya dicakup oleh respons buatan tangan. Task yang ditolak dicatat di log dan halamannya diambil lagi. Penolakan yang menyebut alamat, ERROR_PROXY_BANNED atau ERROR_PROXY_CONNECT_REFUSED, dicatat di log dan diteruskan, karena dokumentasi menyatakan percobaan ulang lewat alamat itu akan gagal lagi. Mock saya mengembalikan keduanya pada saat hasil, dan saya tidak memicunya terhadap aplikasi asli. Error SDK lainnya dicatat di log dan diteruskan.
| Apa yang Anda lihat | Penyebab | Perbaiki |
|---|---|---|
| TypeError tentang argumen keyword tak terduga "spider" | Scrapy 2.13 atau lebih lama | Upgrade ke 2.14 atau lebih baru |
| RuntimeError: Task got bad yield | Sebuah Deferred di-await langsung di dalam coroutine | Pakai asyncio.to_thread atau maybe_deferred_to_future |
| Halaman 403 sampai ke HttpErrorMiddleware dan tidak ada task yang dikirim | Nomor middleware di atas 590, atau halaman blokir tidak memiliki alamat iframe maupun dd objek | Pakai 551 sampai 589 dan cari salah satunya di halaman blokir |
| Halaman tetap terblokir dan hitungan budget_used_up muncul di stats | Cookie dimatikan, header Cookie, atau User-Agent yang diubah | Bandingkan percobaan ulang dengan identitasnya |
| ERROR_PROXY_BANNED atau ERROR_PROXY_CONNECT_REFUSED di log | CapSkip menyebut alamat itu diblokir atau tidak terjangkau | Ganti proxy untuk jar itu |
ValidationException dengan t=bv di log | Halaman blokir menyatakan alamat itu diblokir | Ganti proxy untuk jar itu |
| NetworkException di log | Tidak ada yang menjawab di host dan port pada settings.py | Jalankan CapSkip dan periksa keduanya |
Aturan urutan ada di referensi downloader middleware dari proyek Scrapy. Untuk gagasan yang sama yang diterapkan pada reCAPTCHA, lihat Panduan middleware CAPTCHA Scrapy, dan untuk crawling skala besar lihat halaman web scraping.
Menjalankan CapSkip di server
Mode Server membuat CapSkip menjawab di alamat jaringan atau IP publik Anda, sehingga crawler di PC lain atau Windows VPS dapat menjangkaunya. Pilih mode itu di pengaturan koneksi CapSkip dan tulis alamat mesin itu di DATADOME_CAPSKIP_HOST; tidak ada hal lain yang berubah. Menjalankan mode Server membiarkan port CapSkip terbuka untuk semua alamat, jadi tambahkan aturan Windows Firewall yang memblokir mesin yang tidak boleh menjangkaunya. Pemecahan berjalan di server, jadi cookie diperoleh dari alamatnya kecuali request membawa proxy, yang diteruskan oleh middleware. Saya tidak menjalankan semua ini, hanya sebuah mock di 127.0.0.1, dan dengan API Key Validation aktif Anda akan meneruskan apiKey ke konstruktor CapSkip.
FAQ
Bisakah saya meng-await AsyncCapSkip alih-alih memakai thread?
Bisa. Bangun AsyncCapSkip sebagai ganti CapSkip dan await metode datadome-nya di self.solve. Hasil hitungannya sama dengan thread di kedua Python, dengan jeda yang lebih lama, sekitar 220 sampai 530 ms di PC saya.
Berapa banyak pemecahan yang dibutuhkan sebuah crawl DataDome Scrapy sungguhan?
Saya tidak bisa memastikannya. Di mock jumlahnya satu per proxy, karena mock tidak pernah mengedarluarsakan cookie. Key stats datadome/solves menghitung pemecahan di crawl Anda sendiri.
