Cara Memecahkan Blokir 403 DataDome di Scrapy dengan Middleware

datadome scrapy - How to Solve DataDome Scrapy 403 Blocks With a 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 pages

Pada 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.generation

Langkah 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 SDKJeda tick terpanjang pada satu PC
Panggilan langsung di dalam coroutinesekitar 3770 sampai 3840 ms
asyncio.to_thread, kode di atassekitar 65 sampai 75 ms
AsyncCapSkip di-await di dalam coroutinesekitar 220 sampai 530 ms
deferToThread dengan maybe_deferred_to_futuresekitar 65 sampai 90 ms
deferToThread di-await tanpa konversisekitar 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 lihatPenyebabPerbaiki
TypeError tentang argumen keyword tak terduga "spider"Scrapy 2.13 atau lebih lamaUpgrade ke 2.14 atau lebih baru
RuntimeError: Task got bad yieldSebuah Deferred di-await langsung di dalam coroutinePakai asyncio.to_thread atau maybe_deferred_to_future
Halaman 403 sampai ke HttpErrorMiddleware dan tidak ada task yang dikirimNomor middleware di atas 590, atau halaman blokir tidak memiliki alamat iframe maupun dd objekPakai 551 sampai 589 dan cari salah satunya di halaman blokir
Halaman tetap terblokir dan hitungan budget_used_up muncul di statsCookie dimatikan, header Cookie, atau User-Agent yang diubahBandingkan percobaan ulang dengan identitasnya
ERROR_PROXY_BANNED atau ERROR_PROXY_CONNECT_REFUSED di logCapSkip menyebut alamat itu diblokir atau tidak terjangkauGanti proxy untuk jar itu
ValidationException dengan t=bv di logHalaman blokir menyatakan alamat itu diblokirGanti proxy untuk jar itu
NetworkException di logTidak ada yang menjawab di host dan port pada settings.pyJalankan 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.