Scrapy-Splash-Tutorial: Die Kunst des Scrapings von JavaScript-gerenderten Websites mit Scrapy und Splash

Scrapy Splash ist ein äußerst leistungsstarkes Tool, das neue Möglichkeiten für das Scraping von Daten aus dynamischen Websites eröffnet. Bevor wir jedoch die Vorteile von Scrapy Splash nutzen können, müssen wir zunächst unsere Systeme einrichten. Dies umfasst mehrere wichtige Schritte, darunter die Installation von Docker, Splash und Scrapy sowie die notwendigen Konfigurationen, damit alles nahtlos zusammenarbeitet.

1) Einrichten und Installieren von Docker

Docker ist eine hochmoderne Containerisierungstechnologie, die es uns ermöglicht, die Splash-Instanz in einem virtuellen Container zu isolieren und auszuführen, wodurch ein reibungsloser und konsistenter Betrieb gewährleistet wird.

Für Linux-Benutzer:

Führen Sie den folgenden Befehl im Terminal aus:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Für andere Betriebssysteme:

Benutzer von Windows, macOS und anderen Betriebssystemen finden detaillierte Installationsanleitungen auf der Docker-Website.

2) Herunterladen und Installieren von Splash über Docker

Sobald Docker installiert ist, können Sie mit dem Herunterladen des Splash-Docker-Images fortfahren, einem wesentlichen Bestandteil unserer Scraping-Infrastruktur.

Führen Sie den folgenden Befehl aus:

docker pull scrapinghub/splash

Dadurch wird das Image heruntergeladen. Führen Sie es nun mit folgendem Befehl aus:

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

Herzlichen Glückwunsch! Ihre Splash-Instanz ist nun unter localhost:8050 bereit. Wenn Sie diese URL in Ihrem Browser aufrufen, sollte die Standard-Splash-Seite angezeigt werden.

3) Installation von Scrapy und dem Scrapy-Splash-Plugin

Scrapy ist ein flexibles Scraping-Framework, und das Scrapy-Splash-Plugin verbindet Scrapy mit Splash. Sie können beides mit folgendem Befehl installieren:

pip install scrapy scrapy-splash

Der obige Befehl lädt alle erforderlichen Abhängigkeiten herunter und installiert sie.

4) Erstellen Ihres ersten Scrapy-Projekts

Starten Sie Ihre Scraping-Reise mit dem folgenden Befehl:

scrapy startproject splashscraper

Dadurch wird ein Scrapy-Projekt namens splashscraper mit einer Struktur ähnlich der folgenden erstellt:

splashscraper
├── scrapy.cfg
└── splashscraper
    ├── __init__.py
    ├── items.py
    ├── middlewares.py
    ├── pipelines.py
    ├── settings.py
    └── spiders
        └── __init__.py

5) Scrapy mit Splash integrieren

Nun kommt der entscheidende Teil – die Konfiguration von Scrapy für die Zusammenarbeit mit Splash. Dazu müssen Sie die Datei settings.py in Ihrem Scrapy-Projekt ändern.

Konfiguration der Splash-URL:

Definieren Sie eine Variable für Ihre Splash-Instanz:

SPLASH_URL = 'http://localhost:8050'

Downloader-Middlewares:

Diese Einstellungen ermöglichen die Interaktion mit Splash:

DOWNLOADER_MIDDLEWARES = {
   'scrapy_splash.SplashCookiesMiddleware': 723,
   'scrapy_splash.SplashMiddleware': 725,

}

Spider Middlewares and Duplicate Filters:
Further, include the necessary Splash middleware for deduplication:
SPIDER_MIDDLEWARES = {
   'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,

}

DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'

Die übrigen Einstellungen können auf ihren Standardwerten belassen werden.

Das Scrapen von Daten aus dynamischen Webseiten erfordert möglicherweise die Interaktion mit JavaScript. Hier kommt Scrapy Splash ins Spiel. Am Ende dieses Leitfadens wissen Sie, wie Sie mit Scrapy Splash einen Spider erstellen, um Angebote von quotes.toscrape.com zu scrapen.

Schritt 1: Erstellen des Spiders

Wir verwenden den in Scrapy integrierten Befehl, um einen Spider zu generieren. Der Befehl lautet:

scrapy genspider quotes quotes.toscrape.com

Nach der Ausführung wird im Verzeichnis „spiders“ eine neue Datei namens „quotes.py“ erstellt.

Schritt 2: Die Grundlagen eines Scrapy-Spiders verstehen

Wenn Sie quotes.py öffnen, finden Sie Folgendes:

import scrapy

class QuotesSpider(scrapy.Spider):
   name = 'quotes'
   allowed_domains = ['quotes.toscrape.com']
   start_urls = ['http://quotes.toscrape.com/']
   def parse(self, response):
       pass

• name: Der Name des Spiders
• allowed_domains: Beschränkt den Spider auf die aufgeführten Domains
• start_urls: Die zu scrapenden URLs
• parse: Die für jede URL aufgerufene Methode

Schritt 3: Daten von einer einzelnen Seite scrapen

Nun machen wir den Spider funktionsfähig.

a) Elemente mit einem Webbrowser untersuchen

Verwenden Sie die Entwicklertools, um die HTML-Struktur zu analysieren. Sie werden feststellen, dass jedes Zitat in einem div-Tag mit dem Klassennamen „quote“ eingeschlossen ist.

b) Die Klasse SplashscraperItem vorbereiten

Ändere die Datei „items.py“ so, dass sie drei Felder enthält: „author“, „text“ und „tags“:

import scrapy

class SplashscraperItem(scrapy.Item):
   author = scrapy.Field()
   text = scrapy.Field()
   tags = scrapy.Field()

c) Implementiere die Methode parse()

Importieren Sie die SplashscraperItem-Klasse und aktualisieren Sie die parse-Methode in quotes.py:

from items import SplashscraperItem

def parse(self, response):
   for quote in response.css("div.quote"):
       text = quote.css("span.text::text").extract_first("")
       author = quote.css("small.author::text").extract_first("")
       tags = quote.css("meta.keywords::attr(content)").extract_first("")
       item = SplashscraperItem()
       item['text'] = text
       item['author'] = author
       item['tags'] = tags
       yield item

Schritt 4: Umgang mit der Paginierung

Fügen Sie Code hinzu, um durch alle Seiten zu navigieren:

next_url = response.css("li.next>a::attr(href)").extract_first("")
if next_url:
    yield scrapy.Request(next_url, self.parse)

Schritt 5: Hinzufügen von Splash-Anfragen für dynamische Inhalte

Um SplashRequest zu verwenden, müssen Sie Änderungen am aktuellen Spider vornehmen:

from scrapy_splash import SplashRequest

def start_requests(self):
   url = 'https://quotes.toscrape.com/'
   yield SplashRequest(url, self.parse, args={'wait': 1})

Aktualisieren Sie die parse-Methode, damit sie ebenfalls SplashRequest verwendet:

if next_url:
yield scrapy.SplashRequest(next_url, self.parse, args={'wait': 1})

Herzlichen Glückwunsch! Du hast soeben einen voll funktionsfähigen Scrapy-Spider geschrieben, der Splash nutzt, um dynamische Inhalte zu scrapen. Du kannst den Spider nun ausführen und alle Zitate, Autoren und Tags von quotes.toscrape.com extrahieren.

Der Code bietet eine hervorragende Vorlage für das Scraping anderer dynamischer Websites mit ähnlichen Strukturen. Viel Spaß beim Scraping!

Splash-Antworten in Scrapy weisen einige einzigartige Merkmale auf, die sich von Standard-Scrapy-Antworten unterscheiden. Sie werden je nach Art der Antwort auf eine bestimmte Weise behandelt, aber der Extraktionsprozess kann mit den bekannten Scrapy-Methoden durchgeführt werden. Schauen wir uns das genauer an.

Verstehen, wie Splash auf Anfragen reagiert und wie sein Antwortobjekt funktioniert

Wenn Scrapy Splash eine Anfrage verarbeitet, gibt es je nach Anfragetyp unterschiedliche Antwort-Unterklassen zurück:

• SplashResponse: Für binäre Splash-Antworten, die Mediendateien wie Bilder, Videos, Audiodateien usw. enthalten.
• SplashTextResponse: Wenn das Ergebnis textuell ist.
• SplashJsonResponse: Wenn das Ergebnis ein JSON-Objekt ist.

Parsen von Daten aus Splash-Antworten

Die in Scrapy integrierten Parser- und Selector-Klassen können zum Parsen von Splash-Antworten verwendet werden. Das bedeutet, dass die Methoden zum Extrahieren von Daten zwar unabhängig vom Antworttyp gleich bleiben, die Antworttypen selbst jedoch unterschiedlich sind.

Hier ist ein Beispiel dafür, wie man Daten aus einer Splash-Antwort extrahiert:

text = quote.css("span.text::text").extract_first("")
author = quote.css("small.author::text").extract_first("")
tags = quote.css("meta.keywords::attr(content)").extract_first("")

Erklärung:

• .css("span.text::text"): Hier werden CSS-Selektoren verwendet, um das span-Element mit der Klasse „text“ zu finden, und ::text weist Scrapy an, die Eigenschaft „text“ aus diesem Element zu extrahieren.
• .css("meta.keywords::attr(content)"): Hier wird ::attr(content) verwendet, um das content-Attribut des Meta-Tags mit der Klasse keywords abzurufen.

Die Verarbeitung von Splash-Antworten in Scrapy erfordert keine spezielle Behandlung. Du kannst weiterhin die gewohnten Methoden und die gewohnte Syntax zum Extrahieren von Daten verwenden. Der Hauptunterschied liegt im Verständnis des Typs der zurückgegebenen Splash-Antwort, die Standardtext, Binärdaten oder JSON sein kann. Diese Typen lassen sich ähnlich wie reguläre Scrapy-Antworten behandeln, was einen reibungslosen Übergang ermöglicht, wenn du Splash zu einem bestehenden Scrapy-Projekt hinzufügst.

Viel Spaß beim Scraping mit Splash!