Scrapy Splash Tutorial: JavaScript-Seiten rendern

Splash ist ein Headless-Browser mit einer HTTP-API, der mit JavaScript geladene Webseiten rendert. Im Gegensatz zu vollwertigen Browsern ist Splash auf Leichtigkeit ausgelegt: Es wird in einem Docker-Container gestartet, lauscht auf einem Port und gibt gerenderten HTML-Code (oder PNG-Screenshots oder HAR-Protokolle) über HTTP zurück. Scrapy Splash ist die offizielle Bibliothek, die Scrapy mit diesem Rendering-Dienst verbindet.

Greifen Sie auf Scrapy Splash zurück, wenn Ihre Zielseite wichtige Inhalte über JavaScript oder AJAX lädt und Sie die integrierten Pipeline-, Middleware- und Crawl-Management-Funktionen von Scrapy benötigen. Zyte hat Splash speziell für Scraping-Workflows entwickelt, und es lässt sich nahtlos in den Request/Response-Lebenszyklus von Scrapy einbinden. Allerdings verwendet Splash eine ältere WebKit-Engine, sodass seine JavaScript-Unterstützung nicht so modern ist wie bei Chromium-basierten Alternativen. Wenn Ihre Zielseite auf modernste Browser-APIs setzt, sollten Sie Headless-Browser-Tools mit Chromium-Backend in Betracht ziehen.

Für unkompliziertes JS-Rendering in großem Maßstab (Produktseiten, Verzeichnislisten, paginierte Ergebnisse) bleibt Splash eine praktische und ressourcenschonende Option.

Bevor Sie mit diesem Scrapy-Splash-Tutorial beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• Python 3.7+ auf Ihrem System installiert
• Ein Scrapy-Projekt (oder die Absicht, eines zu erstellen)
• Docker Desktop (oder die Docker-Engine unter Linux) zum Ausführen des Splash-Containers
• Ein Terminal zum Ausführen von Docker- und Scrapy-CLI-Befehlen

Das ist die vollständige Liste. Der nächste Abschnitt behandelt die Docker-Installation.

Splash läuft in einem Docker-Container, daher muss Docker zuerst installiert werden. Holen Sie sich Docker Desktop für macOS oder Windows oder installieren Sie die Docker-Engine direkt unter Linux. Sobald Docker läuft, laden Sie das offizielle Splash-Image herunter:

docker pull scrapinghub/splash

Starten Sie dann den Container:

docker run -it -p 8050:8050 --rm scrapinghub/splash

Dadurch wird Port 8050 des Containers auf Port 8050 Ihres Hosts abgebildet. Das --rm Flag entfernt den Container, wenn Sie ihn stoppen.

Öffnen http://localhost:8050/ in Ihrem Browser. Wenn Sie die interaktive Standardseite von Splash sehen, ist der Dienst aktiv. Testen Sie direkt dort eine URL, um zu überprüfen, ob das Rendering funktioniert, bevor Sie Scrapy-Code schreiben.

Bei einer Scrapy-Splash-Docker-Konfiguration für den Produktionsbetrieb sollten Sie Ressourcenbeschränkungen berücksichtigen. Mit dem --max-timeout Flag ermöglicht es dir, das standardmäßige 60-Sekunden-Timeout zu erhöhen (das Maximum liegt bei etwa 90 Sekunden, sofern du es nicht überschreibst; du solltest den genauen Wert jedoch anhand der aktuellen Splash-Dokumentation überprüfen, da die Details variieren können). Begrenze den Speicher mit dem Docker-Flag --memory Flag den Arbeitsspeicher begrenzen, um zu verhindern, dass außer Kontrolle geratene Seiten Ihren Host überlasten.

Wenn Sie noch kein Projekt haben, erstellen Sie eines:

scrapy startproject myproject

Installieren Sie das scrapy-splash-Plugin:

pip install scrapy scrapy-splash

Öffnen settings.py und fügen Sie diese Einträge hinzu:

SPLASH_URL = 'http://localhost:8050'

DOWNLOADER_MIDDLEWARES = {
    'scrapy_splash.SplashCookiesMiddleware': 723,
    'scrapy_splash.SplashMiddleware': 725,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}

SPIDER_MIDDLEWARES = {
    'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}

DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'

SPLASH_URL Teilt scrapy-splash mit, wo sich der Rendering-Dienst befindet. SplashCookiesMiddleware übernimmt die Weiterleitung von Cookies zwischen Scrapy und Splash. SplashMiddleware fängt SplashRequest-Objekte ab und leitet sie über die Splash-HTTP-API weiter. Das benutzerdefinierte DUPEFILTER_CLASS stellt sicher, dass Scrapys Filter für doppelte Anfragen Splash-spezifische Argumente berücksichtigt, wodurch ein versehentliches Filtern von Anfragen verhindert wird, die sich nur in den Rendering-Parametern unterscheiden.

Mit diesen Einstellungen ist Ihr Projekt für jeden Scrapy-Splash-Tutorial-Spider gerüstet, den Sie als Nächstes erstellen.

Erstellen Sie ein Spider-Gerüst:

scrapy genspider quotes_js quotes.toscrape.com

Ersetzen Sie das Standard- start_urls durch start_requests, da die Standard-Request-Klasse von Scrapy nicht über Splash geleitet wird:

import scrapy
from scrapy_splash import SplashRequest

class QuotesJsSpider(scrapy.Spider):
    name = 'quotes_js'

    def start_requests(self):
        yield SplashRequest(
            url='http://quotes.toscrape.com/js/',
            callback=self.parse,
            args={'wait': 2}
        )

    def parse(self, response):
        for quote in response.css('div.quote'):
            yield {
                'text': quote.css('span.text::text').get(),
                'author': quote.css('small.author::text').get(),
            }

Der wesentliche Unterschied zu einer Standardanfrage scrapy.Request besteht darin, dass SplashRequest die URL zuerst an Splash sendet. Splash rendert die Seite, wartet die angegebenen Sekunden, bis JavaScript ausgeführt wurde, und gibt vollständig gerenderten HTML-Code zurück. Innerhalb parsearbeiten Sie mit der Antwort genau so, wie Sie es normalerweise tun würden: CSS-Selektoren, XPath – alles funktioniert, da Splash-Antworten alle Standard-Antwort-Eigenschaften enthalten.

Führen Sie es mit scrapy crawl quotes_js und du solltest gerenderte Zitatdaten in deiner Ausgabe sehen.

SplashRequest akzeptiert mehrere Argumente, die steuern, wie Splash die Seite rendert:

Beispiel: Um eine POST-Anfrage zu senden (nützlich für Formularübermittlungen):

yield SplashRequest(
    url='https://example.com/search',
    args={
        'wait': 1,
        'http_method': 'POST',
        'body': 'query=scrapy+splash',
    },
    callback=self.parse_results,
)

Der http_method und body Argumente sind praktisch für Websites, die Suchformulare oder Anmeldevorgänge serverseitig verarbeiten. Damit sind die Grundlagen der JavaScript-Darstellung von Scrapy abgedeckt, aber für die Interaktion mit Seiten (Klicken, Scrollen, Warten auf dynamische Elemente) benötigst du Lua-Skripte.

Der render.html Endpunkt bewältigt einfache Fälle, aber sobald du mit einer Seite interagieren musst, wechselst du zum execute Endpunkt mit einem Lua-Skript. Ein Scrapy-Splash-Lua-Skript ermöglicht Ihnen die schrittweise Steuerung des Browsers:

function main(splash, args)
  splash:go(args.url)
  splash:wait(1)
  return splash:html()
end

Senden Sie dies über SplashRequest mit endpoint='execute' und übergeben Sie das Skript args={'lua_source': script}. Von hier aus fügen Sie Element-Wartezeiten, Scroll-Schleifen und Klick-Aktionen hinzu.

Ein festes wait funktioniert, wenn Sie die Ladezeit der Seite kennen, ist aber anfällig. Fragen Sie stattdessen nach einem bestimmten DOM-Element ab:

function main(splash, args)
  splash:go(args.url)
  while not splash:select('.target-element') do
    splash:wait(0.5)
  end
  splash:wait(0.5)
  return splash:html()
end

Dieses Skript läuft in einer Schleife, bis splash:select() ein Element findet, das .target-element, und wartet zwischen den Versuchen eine halbe Sekunde. Sobald das Element erscheint, sorgt eine letzte kurze Wartezeit für die verbleibende Darstellung. Dieses Muster ist weitaus zuverlässiger als das Schätzen einer statischen Verzögerung.

Splash verfügt über keine integrierten Scroll-Befehle. Füge stattdessen JavaScript ein, um die Scroll-Position zu manipulieren. Hier ist ein Lua-Skript für Scrapy Splash Infinite Scroll:

function main(splash, args)
  splash:go(args.url)
  splash:wait(2)
  local scroll_count = 5
  for i = 1, scroll_count do
    splash:runjs("window.scrollTo(0, document.body.scrollHeight)")
    splash:wait(2)
  end
  return splash:html()
end

Das Skript scrollt bis zum Ende, wartet auf neuen Inhalt und wiederholt den Vorgang. Passen Sie scroll_count und die Wartezeit an die jeweilige Website an. Vergleichen document.body.scrollHeight vor und nach jedem Scrollvorgang, um festzustellen, wann keine neuen Inhalte mehr erscheinen.

„Load More“-Schaltflächen und Paginierungslinks erfordern eine Mausinteraktion. Verwenden Sie splash:select() , um das Element zu finden und einen Klick auszulösen:

function main(splash, args)
  splash:go(args.url)
  splash:wait(2)
  local btn = splash:select('.load-more-btn')
  if btn then
    btn:mouse_click()
    splash:wait(2)
  end
  return splash:html()
end

Fassen Sie dies in eine Schleife ein für Seiten mit mehreren Auslösern. Bei der Paginierung wählen Sie den „Weiter“-Link aus, klicken Sie darauf, warten Sie auf die neue Seite und erfassen Sie bei jedem Schritt den HTML-Code.

Manchmal benötigen Sie keinen vollständigen Lua-Workflow. Splash ermöglicht es Ihnen, beliebiges JavaScript mit zwei Methoden einzubinden: splash:evaljs() (gibt einen Wert zurück) und splash:runjs() (wird ausgeführt, ohne einen Wert zurückzugeben).

function main(splash, args)
  splash:go(args.url)
  splash:wait(1)
  local title = splash:evaljs("document.title")
  splash:runjs("document.querySelector('.popup-close').click()")
  splash:wait(0.5)
  return {html = splash:html(), title = title}
end

Dies ist nützlich, um Cookie-Banner zu schließen, Modals zu schließen oder einen berechneten Wert zu extrahieren, bevor der HTML-Code der Seite abgerufen wird. Du kannst JavaScript auch über den js_source Parameter eines Standard-SplashRequest übergeben (kein Lua erforderlich), wodurch das JS nach dem Laden der Seite, aber vor der Erstellung des HTML-Snapshots ausgeführt wird.

Das Rotieren Ihrer IP-Adresse hilft, Sperren bei jedem nennenswerten Scraping-Volumen zu vermeiden. Leiten Sie Anfragen über einen Scrapy-Splash-Proxy, indem Sie Details in den SplashRequest-Argumenten übergeben:

yield SplashRequest(
    url='https://example.com',
    callback=self.parse,
    args={
        'wait': 2,
        'proxy': 'http://user:pass@proxyhost:port',
    },
)

Sie können den Proxy auch innerhalb eines Lua-Skripts konfigurieren, indem Sie splash:on_request():

function main(splash, args)
  splash:on_request(function(request)
    request:set_proxy{
      host = "proxyhost",
      port = 8080,
      username = "user",
      password = "pass",
    }
  end)
  splash:go(args.url)
  splash:wait(2)
  return splash:html()
end

Der Lua-Ansatz ermöglicht es Ihnen, verschiedene Proxys auf unterschiedliche Unteranfragen innerhalb desselben Seitenladens anzuwenden. Beachten Sie, dass Splash selbst keine Anti-Bot-Systeme umgeht; es rendert lediglich die Seite. Sie benötigen weiterhin ordnungsgemäß rotierte Residential- oder Rechenzentrums-Proxys, um Sperren auf IP-Ebene zu vermeiden.

An dieser Stelle lassen dich die meisten Scrapy-Splash-Tutorials im Stich. Hier sind die Fehler, auf die du am häufigsten stoßen wirst:

Verbindung zu localhost:8050 abgelehnt. Der Splash-Docker-Container läuft nicht. Überprüfen Sie dies mit docker ps. Wenn er läuft, aber nicht erreichbar ist, überprüfen Sie, ob Port 8050 nicht von Ihrer Firewall blockiert oder von einem anderen Prozess belegt ist.

504 Gateway-Zeitüberschreitung. Das Rendern der Seite dauerte länger als die zulässige Zeitüberschreitung. Erhöhen Sie das timeout Argument in Ihrem SplashRequest. Die Standardgrenze liegt bei etwa 90 Sekunden. Starten Sie den Container für längere Renderzeiten mit einem höheren --max-timeout Wert (überprüfen Sie dies anhand der aktuellen Splash-Dokumentation, da die Details zwischen den Releases variieren können).

Lua-Skriptfehler („bad argument“, „attempt to index a nil value“). Diese bedeuten in der Regel, dass splash:select() zurückgegeben nil , da sich das Element noch nicht im DOM befand. Fügen Sie eine Warte- oder Abfrageschleife ein, bevor Sie mit dem Element interagieren.

Docker-Container beendet (OOM). Splash kann auf ressourcenintensiven Seiten viel Speicher beanspruchen. Lege Docker-Speichergrenzen fest --memory 2g und deaktivieren Sie das Laden von Bildern (images=0). Verwenden Sie bei mehreren Instanzen Docker Compose mit Ressourcenbeschränkungen pro Container.

Es wurde leeres oder unvollständiges HTML zurückgegeben. Das JavaScript der Seite benötigt möglicherweise mehr Zeit. Erhöhen Sie wait. Wenn Ressourcen von Drittanbietern langsam sind, legen Sie resource_timeout , um sie zu überspringen.

Die Wahl des richtigen Rendering-Tools hängt von Ihrem Projekt ab. Hier sehen Sie einen Vergleich der drei gängigsten Optionen im Bereich der Scrapy-Splash-Alternativen:

Splash ist die richtige Wahl, wenn Sie minimalen Overhead wünschen und Ihre Zielseiten nicht auf brandneue Browser-APIs angewiesen sind. Für moderne Single-Page-Anwendungen ist Scrapy-Playwright mit seinem Chromium-Backend wahrscheinlich besser geeignet. Selenium funktioniert zwar, verfügt jedoch nicht über eine native Scrapy-Integration. Keines dieser Tools bietet eine eigene Anti-Bot-Schutzfunktion, sodass du für das Scraping in der Produktion weiterhin eine Proxy-Schicht benötigst. Nutze dieses Scrapy-Splash-Tutorial als Grundlage und greife auf Alternativen zurück, wenn das Projekt dies erfordert.

• Splash läuft in Docker und verbindet sich über eine HTTP-API mit Scrapy. Sobald der Container auf Port 8050 läuft und settings.py konfiguriert ist, können Ihre Spider JavaScript-Seiten mit einem einzigen SplashRequest-Aufruf rendern.
• Verwenden Sie Lua-Skripte, wenn Sie Interaktion benötigen. Feste Wartezeiten decken einfache Fälle ab, aber das Abfragen von Elementen, Scroll-Schleifen und Klickaktionen erfordern den execute Endpunkt mit einem Lua-Skript.
• Proxys sind für das Scraping in der Produktion unerlässlich. Splash rendert Seiten, umgeht jedoch keine Anti-Bot-Schutzmaßnahmen. Leiten Sie Anfragen über rotierende Proxys mithilfe von SplashRequest-Argumenten oder splash:on_request() in Lua.
• Splash ist leichtgewichtig, aber in die Jahre gekommen. Es lässt sich nahtlos in Scrapy integrieren, doch seiner WebKit-Engine fehlt die Unterstützung für einige moderne JavaScript-APIs. Ziehen Sie Scrapy-Playwright für Websites in Betracht, die ein Chromium-Backend benötigen.
• Fehlerbehebung systematisch durchführen. Die meisten Splash-Probleme lassen sich auf Timeouts, fehlende Elemente oder Docker-Ressourcenbeschränkungen zurückführen.

Es kann viele React- und Vue-Apps rendern, aber die Ergebnisse hängen davon ab, welche JavaScript-APIs die App verwendet. Splash läuft auf einer älteren WebKit-Engine, daher werden Apps, die auf moderne Browserfunktionen (wie IntersectionObserver oder ES2020+-Syntax) angewiesen sind, möglicherweise nicht korrekt gerendert. Testen Sie Ihre Ziel-URL in der Splash-Weboberfläche unter localhost:8050 , bevor Sie einen vollständigen Spider erstellen.

Planen Sie für typische Workloads mindestens 1 bis 2 GB pro Instanz ein. Seiten mit großen Bildern oder komplexem JavaScript können den Speicherbedarf erhöhen. Deaktivieren Sie das Laden von Bildern mit images=0 , um den Verbrauch zu reduzieren, und setzen Sie Dockers --memory Flag, um zu verhindern, dass ein einzelner Container die Ressourcen des Hosts erschöpft.

Splash erhält nur noch selten Updates und wird nicht mehr aktiv weiterentwickelt. Es funktioniert zwar immer noch für viele Anwendungsfälle, aber die Community hat sich bei neuen Projekten weitgehend auf Scrapy-Playwright verlagert. Selenium bleibt eine Option außerhalb des Scrapy-Ökosystems. Jedes Tool hat Vor- und Nachteile hinsichtlich der Unterstützung von Browser-Engines, asynchroner Funktionen und der Ressourcennutzung.

Fügen Sie einen cookies Schlüssel in das SplashRequest args -Wörterbuch ein, oder setze Header mithilfe des headers Argument. Verwenden Sie in einem Lua-Skript splash:set_custom_headers() vor dem Aufruf von splash:go(). Cookies aus dem Cookie-Speicher von Scrapy werden automatisch weitergeleitet, wenn SplashCookiesMiddleware in Ihren Einstellungen aktiviert ist.

Dieses Scrapy-Splash-Tutorial hat Sie durch den gesamten Arbeitsablauf geführt: Einrichten eines Splash-Containers, Konfigurieren Ihres Scrapy-Projekts, Schreiben von Spidern mit SplashRequest, Erstellen von Lua-Skripten für das Scrollen und Klicken sowie Einrichten von Proxys. Die hier behandelten Muster zur Fehlerbehebung sollten Ihnen stundenlanges Debuggen ersparen.

Splash bewältigt einfache Rendering-Aufgaben gut, ist aber mittlerweile eine ältere Technologie. Wenn Ihre Ziele die Grenzen des modernen JavaScript ausreizen, sollten Sie Chromium-basierte Alternativen in Betracht ziehen. Unabhängig davon, für welches Rendering-Tool Sie sich entscheiden, ist der eigentliche Engpass beim produktiven Scraping selten der Browser; vielmehr geht es darum, Anti-Bot-Abwehrmechanismen zu umgehen und die Proxy-Infrastruktur in großem Maßstab zu verwalten.

Wenn Sie sich die Kopfschmerzen mit der Infrastruktur lieber ganz ersparen möchten, übernimmt WebScrapingAPI die Proxy-Rotation, das Lösen von CAPTCHAs und das JavaScript-Rendering hinter einem einzigen API-Endpunkt, sodass Sie sich auf das Parsen der Daten konzentrieren können, anstatt sich mit der Infrastruktur herumzuschlagen.