So verwenden Sie den Crawlbase Crawlerasynchrones Scraping in großem Maßstab

Wenn Sie einige hundert Seiten scrapen, ist eine synchrone Schleife ausreichend: eine Anfrage senden, auf das HTML warten, es parsen, wiederholen. Dieses Modell versagt, sobald Sie Tausende oder Millionen von Seiten benötigen, weil jede Anfrage Ihren Code blockiert, während ein Remote-Browser eine Seite rendert und ein Proxy Wiederholungsversuche durchführt. Der Crawlbase Crawler beseitigt genau diese Wartezeit. Sie übergeben ihm URLs, er stellt sie in eine Warteschlange und crawlt sie im Hintergrund, und er liefert jedes fertige Ergebnis an einen Webhook, den Sie kontrollieren.

Dieses Tutorial zeigt Ihnen, wie Sie den Crawler in Python von Anfang bis Ende nutzen: Sie richten einen Webhook-Endpunkt ein, der Ergebnisse empfängt, erstellen einen Crawler, der darauf verweist, senden einen URL-Stapel über die Crawling API, und lesen das gecrawlte HTML beim Eintreffen aus. Dabei sehen Sie die Funktionen, die den Crawler für große Mengen geeignet machen: asynchrone Verarbeitung, normale versus JavaScript-Anfragen, Bezahlung nur für erfolgreiche Anfragen und automatische Wiederholungsversuche. Die Beispielziele sind neutrale öffentliche Seiten, und gegen Ende gibt es einen kurzen Hinweis zum verantwortungsvollen Scraping.

Was Sie erstellen werden

Eine kleine, aber vollständige asynchrone Pipeline. Auf einer Seite befindet sich ein Webhook-Server, der POST-Callbacks vom Crawler empfängt und jedes Ergebnis speichert. Auf der anderen Seite gibt es ein Push-Skript, das URLs über die Crawling API an Ihren benannten Crawler übergibt. Die Bestandteile, die Sie am Ende haben:

• Webhook-Empfänger. Ein Flask-Endpunkt, der den POST-Callback des Crawlers akzeptiert, den gzip-komprimierten Body dekomprimiert und das gecrawlte HTML auf der Festplatte speichert.
• Crawler-Definition. Ein benannter Crawler in Ihrem Dashboard, entweder ein normaler (TCP-)Crawler für statische Seiten oder ein JavaScript-Crawler für clientseitig gerenderte Seiten, der auf Ihre Webhook-URL zeigt.
• Push-Skript. Ein Python-Skript, das eine Liste von URLs mit callback=true und crawler=YourCrawlerName an den Crawler sendet und die für jede zurückgegebene Anfrage-ID (RID) ausgibt.
• Ergebnisverarbeitung. Die Felder, die bei jedem Callback ankommen, einschließlich RID, Original-URL, Statuscodes und Seiteninhalt.

Wie sich der asynchrone Crawler von einer direkten Anfrage unterscheidet

Ein direkter Crawling-API-Aufruf ist synchron: Sie rufen api.get(url) auf, Ihr Code blockiert, bis die Seite abgerufen und gerendert wurde, und Sie erhalten das HTML in derselben Antwort zurück. Das ist das richtige Werkzeug für eine Handvoll Seiten oder für interaktive Arbeit, bei der Sie das Ergebnis sofort brauchen.

Der Crawler kehrt diesen Ablauf um. Sie übergeben eine URL, erhalten sofort eine kurze Anfrage-ID zurück und fahren mit dem Senden der restlichen URLs fort. Der Crawler crawlt jede Seite im Hintergrund, übernimmt Rendering, IP-Rotation und Wiederholungsversuche nach seinem eigenen Plan und sendet das fertige Ergebnis an Ihren Webhook, sobald es bereit ist. Ihr Code hält nie eine Verbindung für die Dauer eines Crawls offen. Diese Entkopplung ermöglicht es, dass ein Stapel Tausende von URLs umfasst, ohne dass Ihr Prozess im Leerlauf sitzt. Das ist der Grund, warum die asynchrone Produktseite ihn für große Aufgaben empfiehlt. Der Kompromiss: Sie benötigen einen öffentlich erreichbaren Endpunkt, um die Callbacks zu empfangen, und den erstellen Sie als Erstes.

Voraussetzungen

Einige Dinge sollten vorab eingerichtet sein. Keines davon nimmt viel Zeit in Anspruch.

Grundlegendes Python. Sie sollten in der Lage sein, ein Skript auszuführen und Pakete mit pip zu installieren. Wenn Sie neu im Umgang mit HTML nach dem Empfang sind, ergänzt der BeautifulSoup-Leitfaden diesen gut.

Python 3.8 oder höher. Überprüfen Sie dies mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org und stellen Sie sicher, dass es in Ihrem PATH verfügbar ist.

Ein Crawlbase-Konto und ein Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Kontodokumentationsseite. Sie erhalten ein normales Token und ein JavaScript-Token; verwenden Sie dasjenige, das zum von Ihnen erstellten Crawler-Typ passt. Crawlbase enthält bis zu 20.000 kostenlose Anfragen zum Start, was ausreicht, um diesen Leitfaden durchzuarbeiten. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionskontrolle heraus.

Eine Möglichkeit, localhost zugänglich zu machen. Der Crawler liefert Ergebnisse über das öffentliche Internet, daher muss Ihr Webhook von außerhalb Ihres Rechners erreichbar sein. Für die lokale Entwicklung leitet ein Tunnel-Tool wie ngrok eine öffentliche URL zu Ihrem lokalen Port weiter. In der Produktion würden Sie den Endpunkt auf einem echten Server hosten.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Abhängigkeiten isoliert bleiben, und installieren Sie dann die zwei benötigten Bibliotheken: Flask für den Webhook-Server und den offiziellen Crawlbase-Client für das Push-Skript.

python --version

python -m venv crawler_env
source crawler_env/bin/activate

pip install crawlbase flask

Unter Windows aktivieren Sie die Umgebung mit crawler_env\Scripts\activate anstelle der source-Zeile. Das Paket crawlbase ist der offizielle Client zum Senden von URLs über die Crawling API, und flask gibt Ihnen einen minimalen Webserver für den Callback-Endpunkt. Das zum Dekomprimieren des Callback-Bodys verwendete Modul gzip ist in der Standardbibliothek enthalten, es muss also nichts weiter installiert werden.

Schritt 1: Den Webhook-Empfänger erstellen

Der Crawler liefert jedes Ergebnis als POST an Ihre Callback-URL. Um ein gültiger Endpunkt zu sein, muss Ihr Webhook drei Dinge tun: vom öffentlichen Internet erreichbar sein, POST-Aufrufe akzeptieren und schnell mit einem Status 200, 201 oder 204 und ohne Body antworten. Der Crawler sendet den Seiteninhalt gzip-komprimiert, daher dekomprimieren Sie ihn vor dem Speichern. Hier ist ein vollständiger Flask-Empfänger.

# webhook.py
import gzip
from flask import Flask, request, Response

app = Flask(__name__)

@app.route("/webhook/crawlbase", methods=["POST"])
def webhook():
    rid = request.headers.get("rid")
    url = request.headers.get("url")
    cb_status = request.headers.get("cb_status")

    try:
        body = gzip.decompress(request.data).decode("latin1")
    except OSError:
        body = request.data.decode("latin1", errors="replace")

    with open(f"result_{rid}.html", "w", encoding="latin1") as f:
        f.write(body)

    print(f"Received {rid} for {url} (status {cb_status})")
    return Response(status=204)

if __name__ == "__main__":
    app.run(port=8000)

Der Endpunkt liest die RID, die gecrawlte URL und den Crawlbase-Status aus den Anfrage-Headern, dekomprimiert den gzip-Body in HTML und schreibt ihn in eine nach der RID benannte Datei, sodass jedes Ergebnis separat landet. Er gibt 204 No Content zurück, genau das, was der Crawler erwartet: eine schnelle, leere Bestätigung. Starten Sie ihn mit python webhook.py, und der Server lauscht auf Port 8000.

Jetzt machen Sie ihn öffentlich. Starten Sie bei laufendem Server einen Tunnel auf demselben Port:

ngrok http 8000

ngrok gibt eine öffentliche Weiterleitungs-URL wie https://abc123.ngrok-free.app aus. Ihre vollständige Callback-URL ist dieser Host plus die Route, zum Beispiel https://abc123.ngrok-free.app/webhook/crawlbase. Halten Sie diese bereit; Sie benötigen sie im nächsten Schritt. Mit dem kostenlosen Tarif von ngrok ändert sich die URL bei jedem Neustart, lesen Sie sie also nach jedem Neustart erneut aus.

Schritt 2: Den Crawler erstellen

Mit einer öffentlichen Callback-URL erstellen Sie den Crawler über Ihr Dashboard. Öffnen Sie den Crawler-Bereich und wählen Sie Neuen Crawler erstellen. Sie geben ihm drei Dinge:

• Einen Namen. Ein eindeutiger Bezeichner, den Sie beim Senden von URLs referenzieren, zum Beispiel test-crawler.
• Einen Typ. Normal (TCP) für statische Seiten oder JavaScript für clientseitig gerenderte Seiten, wie oben beschrieben.
• Eine Callback-URL. Die öffentliche Webhook-URL aus Schritt 1, einschließlich der Route: https://abc123.ngrok-free.app/webhook/crawlbase.

Wenn Sie keinen eigenen Endpunkt betreiben möchten, kann Crawlbase Cloud Storage als Callback-Ziel fungieren und Ergebnisse für Sie aufbewahren, die Sie später abrufen können. In diesem Tutorial verwenden wir den von Ihnen erstellten Webhook, da er den vollständigen Callback-Ablauf zeigt. Sobald der Crawler gespeichert ist, ist er bereit, gepushte URLs zu akzeptieren.

Schritt 3: URLs an den Crawler senden

Das Senden ist der Punkt, an dem die Crawling API ins Spiel kommt. Sie rufen sie genauso auf wie bei einem synchronen Crawl, fügen aber zwei Optionen hinzu: callback=true, um anzugeben, dass es sich um eine asynchrone Anfrage handelt, und crawler=test-crawler, um den Crawler zu benennen, der sie verarbeiten soll. Jeder Push gibt sofort eine Anfrage-ID zurück, nicht die Seite selbst. Hier ist das Push-Skript.

# push.py
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

urls = [
    "https://httpbin.org/html",
    "https://example.com/",
    "https://books.toscrape.com/",
]

OPTIONS = {"callback": "true", "crawler": "test-crawler"}

for url in urls:
    response = api.get(url, OPTIONS)
    print(response["body"])

Jeder Aufruf gibt sofort einen kleinen JSON-Body zurück, der die RID enthält, und der Crawler stellt die URL für das Crawlen im Hintergrund in die Warteschlange. Standardmäßig können Sie bis zu 30 URLs pro Sekunde senden; wenn Sie mehr benötigen, kann der Crawlbase-Support das Limit erhöhen. Beachten Sie, dass ein normales Token mit einem normalen Crawler und ein JavaScript-Token mit einem JavaScript-Crawler kombiniert werden, verwenden Sie also das Token, das zum erstellten Typ passt.

Was der Push zurückgibt

Führen Sie python push.py aus, und Sie erhalten eine RID pro URL in der Reihenfolge, in der Sie sie gesendet haben:

{"rid": "d756c32b0999b1c0507e364f"}
{"rid": "455ee207f6907fbd6168ac1e"}
{"rid": "e9eb6ce579dec207e8973615"}

Die RID ist Ihr Bezeichner für jede Anfrage. Sie können sie verwenden, um eine Anfrage später über die Verwaltungsendpunkte des Crawlers nachzuschlagen, und sie kommt beim Callback zurück, sodass Sie jedes Ergebnis der gesendeten URL zuordnen können. Da der Push asynchron ist, kehrt der gesamte Stapel in deutlich unter einer Sekunde zurück; das eigentliche Crawlen findet danach im Hintergrund statt.

Schritt 4: Ergebnisse am Webhook empfangen

Sobald eine Seite gecrawlt wurde, sendet der Crawler das Ergebnis per POST an Ihre Callback-URL. Der Body ist die gzip-komprimierte Seite, und die Metadaten reisen in den Headern. Die Standardantwort ist HTML, mit Headern dieser Form:

Content-Type:     text/plain
Content-Encoding: gzip
Original-Status:  200
PC-Status:        200
rid:              the RID you received in the push call
url:              the URL which was crawled

Body: the gzip-compressed HTML of the page

Original-Status ist der Status, den die Zielseite zurückgegeben hat, und PC-Status ist der eigene Status von Crawlbase für den Crawl. So können Sie einen erfolgreichen Abruf von einem fehlgeschlagenen unterscheiden und entsprechend reagieren. Wenn Sie strukturierte Ausgabe statt rohem HTML bevorzugen, übergeben Sie format=json beim Senden, und der Body kommt als JSON-Objekt an:

{
  "cb_status": 200,
  "original_status": 200,
  "rid": "the RID you received in the push call",
  "url": "the URL which was crawled",
  "body": "the HTML of the page"
}

Da wir drei URLs gesendet haben, empfängt der Webhook drei POSTs, von denen jeder seine eigene result_<rid>.html-Datei schreibt. Mit dem HTML auf der Festplatte können Sie es nach Belieben parsen; hier ist der Punkt, an dem Sie es in BeautifulSoup laden und die gewünschten Felder herausziehen würden, genau wie nach einem synchronen Crawl.

Wesentliche Funktionen für große Mengen

Der obige Vier-Schritte-Ablauf ist das vollständige Muster. Was ihn bei Millionen von URLs tragfähig hält, sind einige Crawler-Verhaltensweisen, die es wert sind, hervorgehoben zu werden.

• Asynchrone Verarbeitung. Das Senden gibt sofort eine RID zurück, und der Crawl läuft im Hintergrund, sodass Ihr Code nie auf eine langsame Seite wartet. Ein einzelner Prozess kann einen sehr großen Stapel senden und dann einfach Ergebnisse empfangen, wenn sie eintreffen.
• Normale versus JavaScript-Anfragen. Ein normaler Crawler ruft statisches HTML günstig ab; ein JavaScript-Crawler rendert die Seite für clientseitige Inhalte in einem Browser. Sie wählen pro Crawler, und JavaScript-Anfragen verbrauchen mehr Credits als normale, sodass Sie nur für Rendering bezahlen, wenn Sie es benötigen.
• Bezahlung pro erfolgreicher Anfrage. Sie werden für Anfragen belastet, die erfolgreich sind, nicht für jeden Versuch, was die Kosten eines großen Crawls an Ergebnisse statt an Aufwand knüpft.
• Automatische Wiederholungsversuche. Wenn der Crawler an Ihren Webhook liefert, Ihr Server aber keinen Erfolgsstatus zurückgibt, wiederholt er den Crawl und liefert erneut. Diese Wiederholungsversuche zählen als erfolgreiche Anfragen, sobald sie ankommen, halten Sie also Ihren Endpunkt schnell und mit 204 antwortend.

Ein operativer Detail: Wenn Ihr Webhook offline geht, erkennt die Überwachung von Crawlbase dies und pausiert den Crawler, bevor er fortgesetzt wird, sobald der Endpunkt wieder erreichbar ist. Die kombinierten Warteschlangen über Ihre Crawler hinweg sind begrenzt; ein Push pausiert mit einer E-Mail-Benachrichtigung, wenn Sie die Obergrenze erreichen, und setzt fort, wenn sich die Warteschlange leert. Sie befassen sich selten direkt damit, aber das ist der Grund, warum ein lang laufender asynchroner Job keine Ergebnisse still verliert.

Die Pipeline skalieren

Bei einem Produktionslauf bleibt die Form dieselbe; Sie ändern die Eingaben und die Empfangsseite. Einige Gewohnheiten halten große Jobs gesund:

• URLs stapelweise senden. Lesen Sie URLs aus einer Datei oder einer Warteschlange und senden Sie sie in einer Schleife, dabei innerhalb des Standardlimits von 30 pro Sekunde bleiben, sofern Sie kein höheres Limit beantragt haben. Speichern Sie jede zurückgegebene RID, damit Sie Ergebnisse später abgleichen können.
• Den Webhook robust machen. Bestätigen Sie schnell mit 204, dann verarbeiten Sie den Body außerhalb der Anfrage (schreiben Sie ihn in einen Speicher oder übergeben Sie ihn an eine Worker-Warteschlange), anstatt ihn innerhalb der Anfrage zu parsen. Ein langsamer Webhook löst kostenpflichtige Wiederholungsversuche aus.
• Statuscodes beobachten. Verfolgen Sie PC-Status und Original-Status bei jedem Callback, damit Sie echte Seitenfehler von vorübergehenden unterscheiden und diejenigen, die es erfordern, wieder in die Warteschlange einspeisen können.

Wenn Sie den Callback-Speicher gar nicht verwalten möchten, richten Sie den Crawler auf Crawlbase Cloud Storage und rufen Sie Ergebnisse nach Ihrem eigenen Zeitplan ab. Für eine ausführlichere Behandlung des Aufbaus eines Callback-Dienstes und der Persistierung von Ergebnissen lesen Sie Daten mit dem Crawlbase Crawler extrahieren und den Leitfaden zum Aufbau einer skalierbaren Web-Datenpipeline. Wenn Ihre Ziele stark clientseitig gerendert werden, behandelt der Leitfaden zum Crawlen von JavaScript-Websites die Rendering-Seite ausführlicher.

Verantwortungsvolles Scraping

Der Crawler macht groß angelegte Datensammlung unkompliziert, was verantwortungsvolle Nutzung zu einer Frage der Disziplin statt der Fähigkeit macht. Scrapen Sie nur öffentliche Daten, also Seiten, die jeder ohne Account erreichen kann, und bleiben Sie von allem hinter einem Login oder einer Bezahlschranke fern. Prüfen Sie die Nutzungsbedingungen jeder Zielseite und ihre robots.txt, und betrachten Sie beides als Grenze dessen, was Sie sammeln.

Halten Sie Ihre Anfragerate angemessen. Das asynchrone Modell kann stark belasten, setzen Sie also Volumina, die die von Ihnen gecrawlten Seiten nicht überfordern. Wenn die von Ihnen gesammelten Daten etwas enthalten, das mit identifizierbaren Personen zusammenhängt, behandeln Sie es als personenbezogene Daten und gehen Sie damit in Übereinstimmung mit Vorschriften wie DSGVO und CCPA um: minimieren Sie, was Sie aufbewahren, aggregieren Sie wo möglich, und erstellen Sie keine Profile von Personen. Die neutralen Beispiel-URLs in diesem Leitfaden (httpbin, example.com und ein Sandbox-Buchshop) existieren genau dafür, damit Sie den Ablauf testen können, ohne ihn auf die Produktionsseite von jemandem zu richten.

Häufig gestellte Fragen

Wie unterscheidet sich der Crawler von einem normalen Crawling-API-Aufruf?

Ein normaler Crawling-API-Aufruf ist synchron: Sie warten auf die Antwort und erhalten das HTML in derselben Anfrage zurück. Der Crawler ist asynchron: Sie senden eine URL, erhalten sofort eine Anfrage-ID, und das fertige Ergebnis wird später an Ihren Webhook gesendet. Verwenden Sie einen direkten Aufruf für wenige Seiten oder interaktive Arbeit, und den Crawler, wenn Sie Tausende oder Millionen von URLs verarbeiten müssen, ohne Ihren Code zu blockieren.

Was muss mein Webhook tun, um gültig zu sein?

Er muss vom öffentlichen Internet erreichbar sein, POST-Anfragen akzeptieren und schnell mit einem Status 200, 201 oder 204 und ohne Body antworten. Der Crawler sendet die Seite gzip-komprimiert, daher den Body vor der Verwendung dekomprimieren. Schnell bestätigen und schwerere Verarbeitung danach durchführen, denn ein langsamer Webhook kann Wiederholungsversuche auslösen.

Muss ich Python verwenden?

Nein. Python ist hier wegen des offiziellen Crawlbase-Clients und Flask praktisch, aber der Crawler ist sprachunabhängig. Die Push-Seite ist ein Crawling-API-Aufruf mit callback=true und crawler=YourCrawlerName, und der Webhook ist jeder HTTP-Endpunkt, der einen POST akzeptiert. Sie können beide Seiten in JavaScript, Ruby, Go oder jeder anderen Sprache bauen, die HTTP spricht.

Was ist die RID und wie verwende ich sie?

Die RID (Anfrage-ID) wird zurückgegeben, wenn Sie eine URL senden, und kommt beim Callback zurück. Sie ermöglicht es Ihnen, jedes eingehende Ergebnis der gesendeten URL zuzuordnen, und Sie können sie verwenden, um eine Anfrage über die Verwaltungsendpunkte des Crawlers nachzuschlagen. Die RID für jeden Push zu speichern, ist der einfachste Weg, einen großen Stapel abzugleichen, während Ergebnisse eintreffen.

Wann sollte ich einen JavaScript-Crawler statt eines normalen verwenden?

Verwenden Sie einen JavaScript-Crawler, wenn der benötigte Inhalt clientseitig gerendert wird, zum Beispiel eine React- oder Angular-App, oder eine Seite, die sich nach dem Laden füllt. Ein normaler (TCP-)Crawler reicht für serverseitig gerenderte, statische HTML-Seiten aus und kostet weniger Credits pro Anfrage. Passen Sie den Crawler-Typ an Ihr Ziel an und verwenden Sie das Token (normal oder JavaScript), das dazu passt.

Wie funktioniert die Abrechnung bei Wiederholungsversuchen?

Sie bezahlen nur für erfolgreiche Anfragen, nicht für jeden Versuch, und JavaScript-Anfragen verbrauchen mehr Credits als normale. Wenn der Crawler versucht, ein Ergebnis zu liefern, Ihr Webhook aber keinen Erfolgsstatus zurückgibt, werden Wiederholungsversuche durchgeführt; diese zählen als erfolgreiche Anfragen, sobald sie ankommen. Einen schnellen Endpunkt zu betreiben, der 204 zurückgibt, vermeidet das Bezahlen für vermeidbare Wiederholungsversuche.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.