Wenn Sie Ihre Web-Scraping-Prozesse skalieren, müssen Sie den Einsatz einer zuverlässigen, effizienten und verwaltbaren Lösung in Betracht ziehen, unabhängig von der Menge der zu scrapenden Daten.

Die meisten Entwickler empfinden umfangreiches Scraping aufgrund der enormen Datenmenge als Herausforderung. Ihr Code, der für kleine Projekte perfekt funktionierte, bricht plötzlich zusammen, wird blockiert oder lässt sich nicht mehr warten.

Das ist wo Crawlbase Hier kommt es an. Unsere Lösung ist speziell auf einen reibungslosen Übergang ausgelegt. Sie müssen nicht mehr alles von Grund auf neu schreiben oder Ihren Workflow komplett umstellen. Wie? Wir zeigen es Ihnen im Detail.

Inhaltsverzeichnis

  1. Warum Skalierung beim Web Scraping wichtig ist

  2. So wählen Sie zwischen synchronem und asynchronem Web Scraping

  1. So richten Sie Ihr Scalable ein Crawler
  1. So bewältigen Sie die Verarbeitung großer Datenmengen
  1. Crawler Wartung und Überwachung

  1. Skalieren Sie Ihr Web Scraping mit Crawlbase

  2. Häufig gestellte Fragen

Warum Skalierung beim Web Scraping wichtig ist

Im kleinen Maßstab ist der Web Scraping-Prozess einfach. Sie schreiben das Skript, senden die Anfrage an eine Handvoll Webseiten, und Ihr Scraper erledigt die Arbeit nacheinander. Sobald Sie jedoch versuchen, den Umfang Ihres Projekts zu erhöhen und Tausende oder sogar Millionen von Seiten zu scrapen, geraten die Dinge ins Wanken.

Beim Skalieren geht es nicht nur darum, dasselbe zu tun, sondern mehr. Es geht darum, es intelligent zu tun. Sie müssen häufige Skalierungsprobleme im Auge behalten, wie zum Beispiel:

  • Ratenbegrenzung
  • Probleme mit der Parallelität
  • Herausforderungen wiederholen
  • Probleme mit der Codeeffizienz
  • Speicherbeschränkungen

Wenn Sie diese Probleme ignorieren, funktioniert Ihr Scraper möglicherweise heute, stürzt jedoch morgen ab, wenn Ihr Datenbedarf steigt oder sich die Zielsite ändert.

Eine der ersten Entscheidungen, die Sie treffen müssen, ist die Wahl des synchronen oder asynchronen Scrapings. Allein diese Entscheidung kann die meisten Skalierungsprobleme drastisch lösen und die Geschwindigkeit und Effizienz Ihrer Skalierung beeinflussen.

So wählen Sie zwischen synchronem und asynchronem Web Scraping

Beim Erstellen eines skalierbaren Scrapers ist es wichtig, wie Sie Anfragen senden und verarbeiten. In kleinen Projekten kann synchrones Scraping ausreichend sein. Bei der Skalierung kann jedoch die Wahl des richtigen Ansatzes den Unterschied zwischen einem schnellen und effizienten Scraper und einem Scraper ausmachen, der ins Stocken gerät oder blockiert.

Synchrones Web Scraping

Synchrones Scraping ist ein sehr unkomplizierter Prozess. Sie senden eine Anfrage, warten auf die Antwort, verarbeiten die Daten und fahren dann mit der nächsten fort. Alles geschieht Schritt für Schritt, wie wenn Sie in einer Schlange stehen und warten, bis Sie an der Reihe sind.

Dieser Ansatz lässt sich leicht implementieren und eignet sich hervorragend für kleinere Aufträge oder Tests, weil:

  • Der Code ist einfach zu lesen und zu debuggen
  • Es ist einfacher, Fehler zu verwalten, da Anfragen in der richtigen Reihenfolge erfolgen
  • Sie müssen sich nicht viele Gedanken über Parallelität oder Aufgabenkoordination machen

Crawlbase Crawling API ist ein überzeugendes Beispiel für einen synchronen Crawler, der seine Aufgabe erfüllt. Bei der Skalierung kann synchrones Crawling jedoch zum Engpass werden. Ihr Scraper verbringt viel Zeit damit, auf Serverantworten, Timeouts und Wiederholungsversuche zu warten. Und all diese Wartezeiten summieren sich.

Asynchrones Web Scraping

Asynchrones Scraping bedeutet, dass Sie mehrere Anfragen senden können und das System diese gleichzeitig verarbeitet oder ausführt, anstatt auf die Bearbeitung jeder einzelnen Anfrage zu warten, bevor die nächste ausgeführt wird. Dieser Ansatz ist für die Skalierung unerlässlich, da er die Wartezeiten beim Warten auf Netzwerkantworten vermeidet.

In der Praxis bedeutet dies einen höheren Durchsatz, eine bessere Ressourcenauslastung und die Möglichkeit, große Datenmengen schneller zu scrapen.

Crawlbase bietet ein speziell entwickeltes, asynchrones Crawling- und Scraping-System, das einfach als The bekannt ist. CrawlerEs ist für die Verarbeitung von Scraping in großen Mengen konzipiert, indem Sie mehrere URLs gleichzeitig crawlen können, ohne eine komplexe Infrastruktur verwalten zu müssen.

Und so funktionierts:

  • Der Crawler ist ein Push-System, das auf Rückrufen basiert.
  • Sie senden URLs zum Scrapen an die Crawler Verwendung der Crawling API.
  • Jeder Anfrage wird eine RID (Anfrage-ID) zugewiesen, damit Sie sie während des gesamten Prozesses verfolgen können.
  • Alle fehlgeschlagenen Anfragen werden automatisch wiederholt, bis eine gültige Antwort eingeht.
  • Der Crawler sendet die Ergebnisse per POST an eine Webhook-URL auf Ihrem Server zurück.

Der Crawler bietet Ihnen eine leistungsstarke Möglichkeit, asynchrones Scraping zu implementieren. Mehrere Seiten werden parallel verarbeitet und fehlgeschlagene Anfragen werden automatisch wiederholt. Dadurch werden Probleme mit Ratenbegrenzung, Parallelität und Wiederholungen gleichzeitig gelöst.

Was sollten Sie tun, um Web Scraping zu skalieren?

Crawlbase Crawling API ist ein hervorragendes Tool, das Millionen von Anfragen zuverlässig bearbeitet. Es ist für groß angelegtes Scraping konzipiert und eignet sich hervorragend, wenn Sie direkte, sofortige Antworten auf jede Anfrage benötigen. Es ist einfach zu implementieren und ideal für kleinere bis mittelgroße Aufträge, schnelle Skripte und Integrationen, bei denen Echtzeitergebnisse entscheidend sind.

Wenn Sie jedoch mit Scraping auf Unternehmensebene, Millionen von URLs, hohen Anforderungen an die Parallelität und der Notwendigkeit robuster Warteschlangen zu tun haben, verwenden Sie die Crawler macht viel mehr Sinn.

Der Crawler ist für das Scraping großer Datenmengen konzipiert. Es ist skalierbar, unterstützt gleichzeitige Verarbeitung und automatische Wiederholungsversuche und wächst mit Ihren Anforderungen.

So sollten Sie skalieren:

Erstellen Sie einen skalierbaren Scraper mit dem Crawling API wenn du:

  • Benötigen Sie Echtzeitergebnisse
  • Führen Sie kleinere Aufträge aus
  • Bevorzugen Sie ein einfacheres Anfrage-Antwort-Modell

Wechseln Sie dann zum Crawler wenn du:

  • Sie müssen Tausende oder Millionen von URLs verarbeiten
  • Möchten Sie mehrere Anfragen gleichzeitig bearbeiten
  • Möchten Sie den Wiederholungsprozess von Ihrem Ende auslagern
  • Bauen Sie eine skalierbare, produktionsreife Datenpipeline auf?

Kurz gesagt: Wenn Ihr Ziel echte Skalierbarkeit ist, dann ist der Wechsel vom synchronen zum asynchronen Scraping mit dem Crawler ist die beste Wahl.

So richten Sie Ihr Scalable ein Crawler

In diesem Abschnitt erhalten Sie eine Schritt-für-Schritt-Anleitung mit Best Practices zum Erstellen eines skalierbaren Web Scrapers. Beachten Sie, dass wir dies anhand von Python demonstriert haben. Flasche und Kellnerin, da diese Methode sowohl leichtgewichtig als auch einfacher zu implementieren ist.

Lass uns anfangen.

Python-Anforderungen

  • Richten Sie eine grundlegende Python-Umgebung ein. Installieren Sie Python 3 auf deinem system
  • Installieren Sie die erforderlichen Abhängigkeiten. Sie können diese Datei herunterladen und den folgenden Befehl in Ihrem Terminal ausführen:
1
python -m pip install fordert Flask-Kellnerin an

Webhook-Integration

Schritt 1: Erstellen Sie eine Datei und benennen Sie sie webhook_http_server.py, kopieren Sie dann den folgenden Code und fügen Sie ihn ein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
von Flasche importieren Flasche
von Flasche importieren Anforderung
von Pfadlib importieren Path
importieren gzip
importieren JSON
importieren os
importieren einfädeln

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

App = Flasche("webhook_http_server")

def handle_webhook_request(Anfrageinhalt):
    # Die Umsetzung wird später besprochen
    passieren

@app.route("/webhook", Methoden=["POST"])
def Webhook†
    if 'loswerden' nicht in Anfrageheader or 'Original-Status' nicht in Anfrageheader or 'PC-Status' nicht in Anfrageheader:
        Rückkehr ("", 404)

    crawlbase_rid = Anfrage.headers.get("loswerden")

    if crawlbase_rid == "Dummy-Anfrage":
        drucken("- Dummy-Anfrage erhalten von Crawlbase.")
        Rückkehr ("", 204)

    if Anfrage.Header.get("Meine ID") != REQUEST_SECURITY_ID:
        Rückkehr ("", 404)

    Anfrageinhalt = (
        crawlbase_rid,
        Anfrage.Header.get("URL"),
        Anfrage.Header.get("Original-Status"),
        Anfrage.Header.get("PC-Status"),
        Anfrage.Header.get("Inhaltskodierung"),
        Anfragedaten
    )

    Thread = Threading.Thread(Ziel=Handle_Webhook_Request, Argumente=(Anforderungsinhalt,))
    thread.start()

    Rückkehr ("", 204)

Wenn Sie sich den obigen Code ansehen, sehen Sie hier einige bewährte Vorgehensweisen, die wir für einen Webhook befolgen:

  • Wir akzeptieren nur HTTP POST Anfragen, was der Standard für Webhooks ist.
  • Wir prüfen auf wichtige Header wie rid, Original-Statusund PC-Status von Crawlbase Antwort um sicherzustellen, dass die Anfrage die richtigen Informationen enthält.
  • Wir ignorieren Dummy-Anfragen von Crawlbase. Dies sind lediglich „Heartbeat“-Nachrichten, die gesendet werden, um zu überprüfen, ob Ihr Webhook aktiv und betriebsbereit ist.
  • Wir suchen auch nach einem benutzerdefinierten Header My-Id mit einem Wert von konstant REQUEST_SECURITY_IDDieser Wert ist nur eine Zeichenfolge. Sie können für zusätzliche Sicherheit beliebig viele Werte festlegen. Die Verwendung dieses Headers ist eine bewährte Methode für Schützen Sie Ihren Webhook, da dadurch überprüft wird, ob eingehende Antworten echt und für Sie bestimmt sind.
  • Schließlich werden die eigentlichen Aufträge in einem separaten Thread bearbeitet, sodass wir innerhalb von 200 ms schnell antworten können. Dieses Setup sollte problemlos etwa 200 Anfragen pro Sekunde verarbeiten können.

Schritt 2: Fügen Sie den restlichen Code unten ein. Hier werden die eigentlichen Daten aus Crawlbase verarbeitet und gespeichert. Der Einfachheit halber verwenden wir das Dateisystem, um gecrawlte Anfragen zu verfolgen. Alternativ können Sie verwenden Datenbank oder Redis.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def handle_webhook_request(Anfrageinhalt):
    crawlbase_rid = Anfrageinhalt[0]
    angeforderte_URL = Anforderungsinhalt[1]
    Originalstatus = Anfrageinhalt[2]
    crawlbase_status = Anfrageinhalt[3]
    Inhaltskodierung = Anforderungsinhalt[4]
    body = Anfrageinhalt[5]

    if Inhaltskodierung == "gzip":
        versuchen:
            body = gzip.decompress(body)
        ausgeschlossen Ausnahme:
            passieren

    versuchen:
        data_dir = os.path.join(Pfad.cwd(), "Daten")
        if nicht os.path.isdir(Datenverzeichnis):
            Pfad(Datenverzeichnis).mkdir(Eltern=Wahre, exist_ok=Wahre)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if nicht os.path.isdir(rid_dir):
            Pfad(rid_dir).mkdir(Eltern=Wahre, exist_ok=Wahre)

        meta = {"loswerden": crawlbase_rid, "angeforderte_URL": angeforderte URL, "ursprünglicher_Status": Originalstatus, "crawlbase_status": crawlbase_status}
        Metadatei = os.Pfad.join(rid_dir, f"{crawlbase_rid}.meta.json")
        mit XNUMXh geöffnet(Metadatei, "w") as f:
            pretty_json = json.dumps(Meta, Einzug=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        mit XNUMXh geöffnet(Body_Datei, "wb") as f:
            f.write(body)

        drucken(f"- RID erfolgreich verarbeitet {crawlbase_rid}. Ausgabe gespeichert unter '{rid_dir}'. ")
    ausgeschlossen Exception as e:
        drucken(f"- Beim Verarbeiten ist ein Fehler aufgetreten {crawlbase_rid}:\N{e}")

Dieser Teil des Codes entpackt einen abgeschlossenen Crawl-Job aus Crawlbase, organisiert die Dateien in einem eigenen Ordner, speichert sowohl die Notizen als auch die eigentlichen Website-Daten und benachrichtigt Sie, wenn etwas schief geht.

Schritt 3: Vervollständigen Sie den Code durch Konfigurieren Kellnerinnenpaket um den Server zu betreiben. Hier verwenden wir Port 5768 um auf eingehende Anfragen zu hören, aber Sie können dies auf jeden beliebigen Wert ändern.

1
2
3
4
5
6
if __name__ == "__hauptsächlich__":
    von Kellnerin importieren brauchen
    Gastgeber = "0.0.0.0"
    Port = 5768
    drucken(f"\n\n- Der Webhook-HTTP-Server läuft unter {Gastgeber}:{Hafen}.\n\n")
    dienen(Anwendung, Host=Host, Port=Port)

Hier ist das komplette Skript für unsere webhook_http_server.py sieht aus wie:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
von Flasche importieren Flasche
von Flasche importieren Anforderung
von Pfadlib importieren Path
importieren gzip
importieren JSON
importieren os
importieren einfädeln

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

App = Flasche("webhook_http_server")

def handle_webhook_request(Anfrageinhalt):
    crawlbase_rid = Anfrageinhalt[0]
    angeforderte_URL = Anforderungsinhalt[1]
    Originalstatus = Anfrageinhalt[2]
    crawlbase_status = Anfrageinhalt[3]
    Inhaltskodierung = Anforderungsinhalt[4]
    body = Anfrageinhalt[5]

    if Inhaltskodierung == "gzip":
        versuchen:
            body = gzip.decompress(body)
        ausgeschlossen Ausnahme:
            passieren

    versuchen:
        data_dir = os.path.join(Pfad.cwd(), "Daten")
        if nicht os.path.isdir(Datenverzeichnis):
            Pfad(Datenverzeichnis).mkdir(Eltern=Wahre, exist_ok=Wahre)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if nicht os.path.isdir(rid_dir):
            Pfad(rid_dir).mkdir(Eltern=Wahre, exist_ok=Wahre)

        meta = {"loswerden": crawlbase_rid, "angeforderte_URL": angeforderte URL, "ursprünglicher_Status": Originalstatus, "crawlbase_status": crawlbase_status}
        Metadatei = os.Pfad.join(rid_dir, f"{crawlbase_rid}.meta.json")
        mit XNUMXh geöffnet(Metadatei, "w") as f:
            pretty_json = json.dumps(Meta, Einzug=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        mit XNUMXh geöffnet(Body_Datei, "wb") as f:
            f.write(body)

        drucken(f"- RID erfolgreich verarbeitet {crawlbase_rid}. Ausgabe gespeichert unter '{rid_dir}'. ")
    ausgeschlossen Exception as e:
        drucken(f"- Beim Verarbeiten ist ein Fehler aufgetreten {crawlbase_rid}:\N{e}")

@app.route("/webhook", Methoden=["POST"])
def Webhook†
    if 'Original-Status' nicht in Anfrageheader or 'PC-Status' nicht in Anfrageheader or 'loswerden' nicht in Anfrageheader:
        Rückkehr ("", 404)

    crawlbase_rid = Anfrage.headers.get("loswerden")

    if crawlbase_rid == "Dummy-Anfrage":
        drucken("- Dummy-Anfrage erhalten von Crawlbase.")
        Rückkehr ("", 204)

    if Anfrage.Header.get("Meine ID") != REQUEST_SECURITY_ID:
        Rückkehr ("", 404)

    Anfrageinhalt = (
        crawlbase_rid,
        Anfrage.Header.get("URL"),
        Anfrage.Header.get("Original-Status"),
        Anfrage.Header.get("PC-Status"),
        Anfrage.Header.get("Inhaltskodierung"),
        Anfragedaten
    )

    Thread = Threading.Thread(Ziel=Handle_Webhook_Request, Argumente=(Anforderungsinhalt,))
    thread.start()

    Rückkehr ("", 204)


if __name__ == "__hauptsächlich__":

    von Kellnerin importieren brauchen
    Gastgeber = "0.0.0.0"
    Port = 5768
    drucken(f"\n\n- Der Webhook-HTTP-Server läuft unter {Gastgeber}:{Hafen}.\n\n")
    dienen(Anwendung, Host=Host, Port=Port)

Schritt 4: Verwenden Sie den folgenden Befehl, um unseren temporären öffentlichen Server auszuführen.

1
ngrok http5768

ngrok gibt Ihnen einen Link oder eine „Weiterleitungs-URL“ Sie können teilen mit Crawlbase damit es weiß, wohin die Ergebnisse gesendet werden sollen.

Screenshot der ngrok-Ausgabe

TIPP: Wenn Sie dies in der Produktion verwenden möchten (nicht nur zum Testen), ist es besser, Ihren Webhook auf einem öffentlichen Server auszuführen und ein Tool wie für Sicherheit und Zuverlässigkeit.

Schritt 5: Führen Sie den Webhook-HTTP-Server aus.

1
python webhook_http_server.py

Damit starten wir nun unsere Webhook-HTTP-Server, bereit zum Empfang von Daten von Crawlbase.

Screenshot der Webhook-HTTP-Server-Ausgabe

Schritt 6: Konfigurieren Sie Ihre Crawlbase Konto.

  • Registrieren für eine Crawlbase Konto und Fügen Sie Ihre Rechnungsdetails hinzu um das zu aktivieren Crawler.
  • Erstelle eine neue Crawler hier. Kopieren Sie die Weiterleitungs-URL, die Sie zuvor in Schritt 4 von ngrok erhalten haben, und fügen Sie sie in das Feld „Rückruf-URL“ ein.
  • Tag auswählen Normale Anfragen (TCP) für den Zweck dieses Handbuchs.
Screenshot zum Erstellen eines neuen Crawler

So bewältigen Sie die Verarbeitung großer Datenmengen

Nachdem unser Webhook online ist, können wir das Web in großem Umfang durchsuchen. Wir schreiben ein Skript, mit dem Sie schnell eine Liste von Websites an Crawlbase. Außerdem werden Anfragen automatisch wiederholt, wenn ein vorübergehendes Problem vorliegt.

Schritt 1: Einfache Crawl-Anfrage

Erstellen Sie eine neue Python-Datei und benennen Sie sie als crawl.py

Kopieren Sie diesen Code und fügen Sie ihn ein:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
von Pfadlib importieren Path
importieren JSON
importieren os
importieren Zugriffe
importieren urllib.parse

def kriechen(URL):
    url = url.strip()
    codierte_URL = urllib.parse.quote(URL, sicher="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, sicher="")
    encoded_callback_headers = urllib.parse.quote(f"MEINE-ID:{REQUEST_SECURITY_ID}", sicher="")

    api_url = CRAWLBASE_CRAWLING_API_URL.Format(CRAWLBASE_TOKEN, codierte URL, codierter Crawlbase-Crawlername, codierte Callback-Header)

    versuchen:
        Antwort = Anfragen.get(API-URL)
        Response.raise_for_status()
        json_response = json.loads(Antwort.text)
        crawlbase_rid = json_antwort["loswerden"]

        data_dir = os.path.join(Pfad.cwd(), "Daten")
        Pfad(Datenverzeichnis).mkdir(Eltern=Wahre, exist_ok=Wahre)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Pfad(rid_dir).mkdir(Eltern=Wahre, exist_ok=Wahre)

        drucken(f"- Crawl-Anfrage für '{URL}' wurde erfolgreich gesendet.")

    ausgeschlossen Exception as e:
        drucken(f"- Fehler beim Verarbeiten von '{URL}':\N{e}")

Was passiert in diesem Teil des Skripts?

Nach jeder Crawl-Anfrage wird an Crawlbaseerstellt es einen dedizierten Ordner, der nach dem ridMit diesem Ansatz behalten Sie den Überblick über Ihre Crawling-Anfragen und können die Ergebnisse später problemlos den ursprünglichen URLs zuordnen.

Zusätzlich fügen wir beim Senden der Anfrage einen benutzerdefinierten Header mit dem Namen My-Id mit einem Wert von REQUEST_SECURITY_ID.

Schritt 2: Fehlerbehandlung und Wiederholungslogik

Achten Sie beim Schreiben eines skalierbaren Scrapers stets darauf, dass er Fehler verarbeiten kann und eine Logik zur Wiederholung fehlgeschlagener Anfragen enthält. Wenn Sie diese Probleme nicht beheben, könnte Ihr gesamter Prozess aufgrund einer kleinen Störung zum Stillstand kommen.

Hier ist ein Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importieren Zeit

BATCH_SIZE = 100
DELAY_SECONDS = 1

def Wiederholungsvorgang(Vorgang, max_retries=3, Verzögerung=2):
    für  Versuch in Angebot(1, max_retries + 1):
        versuchen:
            Rückkehr Betrieb()
        ausgeschlossen Exception as e:
            drucken(f"- Beim Wiederholungsversuch ist ein Fehler aufgetreten '{versuchen}':\N{e}")

        if Versuch < max_retries:
            drucken(f"- Erneuter Versuch in {Verzögerung} Sekunden...")
            Zeit.Schlaf(Verzögerung)

    erhöhen Ausnahme(„Maximale Anzahl erneuter Versuche überschritten.“)

Verpacken Sie Ihre Web-Anfrage mit dem retry_operation Funktion, um sicherzustellen, dass es automatisch erneut versucht, bis max_retries Zeiten im Fehlerfall.

1
2
3
4
5
6
def Anfrage durchführen†
    Antwort = Anfragen.get(API-URL)
    Response.raise_for_status()
    Rückkehr Antwort

Antwort = Wiederholungsvorgang(Lambda: Anfrage durchführen())

Schritt 3: Stapelverarbeitungstechnik

Beim Senden von Tausenden von URLs empfiehlt es sich, diese in kleineren Gruppen zu bündeln und nur eine bestimmte Anzahl von Anfragen gleichzeitig zu senden. Wir steuern dies über die BATCH_SIZE Wert pro Sekunde.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def batch_crawl(urls):
    Threads = []

    für  URL in URLs:
        t = Threading.Thread(Ziel=Crawlen, Argumente=(URL,))
        threads.append(t)
        t.start()

    für  t in Themen:
        t.join()

def Crawl-URLs(urls):
    für  i in Angebot(0, len(URLs), BATCH_SIZE):
        batched_urls = urls[i:i + BATCH_SIZE]
        drucken(batched_urls)
        batch_crawl(gebündelte URLs)
        Zeit.Schlaf(DELAY_SECONDS)

In diesem Abschnitt werden mehrere Anfragen in einem Batch gleichzeitig verarbeitet, um den Prozess zu beschleunigen. Sobald ein Batch abgeschlossen ist, wartet das Skript einen kurzen Moment (DELAY_SECONDS), bevor mit dem nächsten Batch begonnen wird. Dies ist eine effiziente Methode für die Durchführung von Web Scraping im großen Maßstab.

Hier ist der komplette Code. Kopiere diesen und überschreibe den Code in deinem crawl.py Datei.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
von Pfadlib importieren Path
importieren JSON
importieren os
importieren Zugriffe
importieren einfädeln
importieren Zeit
importieren urllib.parse

CRAWLBASE_TOKEN = " "
CRAWLBASE_CRAWLER_NAME = "<Crawler Name>"

REQUEST_SECURITY_ID = '8e1c3efb29fcc59d3c61f86960ccc9f5'

CRAWLBASE_CRAWLING_API_URL = "https://api.crawlbase.com?token={0}&url={1}&crawler={2}&callback=true&callback_headers={3}"

BATCH_SIZE = 100
DELAY_SECONDS = 1

def Wiederholungsvorgang(Vorgang, max_retries=3, Verzögerung=2):
    für  Versuch in Angebot(1, max_retries + 1):
        versuchen:
            Rückkehr Betrieb()
        ausgeschlossen Exception as e:
            drucken(f"- Beim Wiederholungsversuch ist ein Fehler aufgetreten '{versuchen}':\N{e}")

        if Versuch < max_retries:
            drucken(f"- Erneuter Versuch in {Verzögerung} Sekunden...")
            Zeit.Schlaf(Verzögerung)

    erhöhen Ausnahme(„Maximale Anzahl erneuter Versuche überschritten.“)

def kriechen(URL):
    url = url.strip()
    codierte_URL = urllib.parse.quote(URL, sicher="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, sicher="")
    encoded_callback_headers = urllib.parse.quote(f"MEINE-ID:{REQUEST_SECURITY_ID}", sicher="")

    api_url = CRAWLBASE_CRAWLING_API_URL.Format(CRAWLBASE_TOKEN, codierte URL, codierter Crawlbase-Crawlername, codierte Callback-Header)

    versuchen:
        def Anfrage durchführen†
            Antwort = Anfragen.get(API-URL)
            Response.raise_for_status()
            Rückkehr Antwort

        Antwort = Wiederholungsvorgang(Lambda: Anfrage durchführen())
        json_response = json.loads(Antwort.text)
        crawlbase_rid = json_antwort["loswerden"]

        data_dir = os.path.join(Pfad.cwd(), "Daten")
        Pfad(Datenverzeichnis).mkdir(Eltern=Wahre, exist_ok=Wahre)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Pfad(rid_dir).mkdir(Eltern=Wahre, exist_ok=Wahre)

        drucken(f"- Crawl-Anfrage für '{URL}' wurde erfolgreich gesendet.")

    ausgeschlossen Exception as e:
        drucken(f"- Fehler beim Verarbeiten von '{URL}':\N{e}")

def batch_crawl(urls):
    Threads = []

    für  URL in URLs:
        t = Threading.Thread(Ziel=Crawlen, Argumente=(URL,))
        threads.append(t)
        t.start()

    für  t in Themen:
        t.join()

def Crawl-URLs(urls):
    für  i in Angebot(0, len(URLs), BATCH_SIZE):
        batched_urls = urls[i:i + BATCH_SIZE]
        drucken(batched_urls)
        batch_crawl(gebündelte URLs)
        Zeit.Schlaf(DELAY_SECONDS)


if __name__ == "__hauptsächlich__":

    URLs = [
        "http://httpbin.org/",
        "https://github.com/crawlbase",
        „http://httpbin.org/ip“,
        "http://httpbin.org/html",
    ]
    crawl_urls(URLs)

Schritt 4: Führen Sie Ihr Web aus Crawler.

1
Python crawl.py

Beispielausgabe:

Screenshot der Crawl-Konsolenausgabe

Gehe zu Webhook-HTTP-Server Terminalkonsole, und Sie sollten unten eine ähnliche Ausgabe sehen:

Screenshot des Webhook-HTTP-Servers nach dem Crawlen

Dieser Prozess erzeugt eine data Verzeichnis, das ein Unterverzeichnis namens <rid> für jede Crawl-Anforderung:

Screenshot der Datenordnerausgabe

  1. Der <rid> Die Datei enthält die extrahierten Daten.

  2. Der <rid>.meta.json file enthält die zugehörigen Metadaten:

Ejemplo:

1
2
3
4
5
6
{
  "loswerden": " ",
  "angeforderte_URL": "http://httpbin.org/",
  "ursprünglicher_Status": "200",
  "crawlbase_status": "200"
}

Erleben Sie das Einfache. vollständiger Code auf Github.

Crawler Wartung und Überwachung

Sobald Ihr erweiterter Web Scraper einsatzbereit ist, sind eine ordnungsgemäße Überwachung und Wartung erforderlich, um die Skalierbarkeit und Effizienz zu gewährleisten. Folgendes sollten Sie beachten:

Verwalten Crawler Traffic

Crawlbase bietet einen vollständigen Satz von APIs, mit denen Sie Folgendes tun können:

  1. Einen Crawler anhalten oder die Pause fortsetzen
  2. Bereinigen oder Löschen von Jobs
  3. Überprüfen Sie aktive Jobs und die Warteschlangengröße

Weitere Einzelheiten finden Sie in der Crawler API-Dokumente.

Wenn Ihr Crawler verzögert ist oder unerwartet blockiert, können Sie außerdem seine Latenz oder die Zeitdifferenz überwachen, seit der älteste Job zur Warteschlange hinzugefügt wurde, vom Crawlers ArmaturenbrettBei Bedarf können Sie Ihren Crawler auch direkt von dieser Seite aus neu starten.

Überwachungstools

Verwenden Sie diese Tools, um den Überblick zu behalten Crawler Aktivität und erkennen Sie Probleme, bevor sie sich auf die Waage auswirken.

  1. Crawler Dashboard - Sehen Sie sich die aktuellen Kosten, Erfolge und Fehlerzahlen Ihres TCP oder JavaScript an Crawler.
  2. Live-Monitor - Sehen Sie sich die Aktivität in Echtzeit an, einschließlich erfolgreicher Crawls, Fehler, Warteschlangengröße und ausstehender Wiederholungsversuche.
  3. Wiederholungsmonitor - Zeigen Sie eine detaillierte Beschreibung der erneut versuchten Anfragen an.

Hinweis: Die im Dashboard angezeigten Fehlversuche stellen eine interne Wiederholungslogik dar. Sie müssen sich nicht um deren Bearbeitung kümmern, da das System so konzipiert ist, dass fehlgeschlagene Aufträge automatisch zur Wiederholung angefordert werden.

Crawler Limits

Hier sind die Standardwerte, die Sie beim Skalieren beachten sollten:

  • Push-Ratenbegrenzung: 30 Anfragen/Sekunde
  • Gleichzeitigkeit: 10 gleichzeitige Jobs
  • Anzahl der Wiederholungsversuche: 110 Versuche pro Anfrage
  • Der kombiniertes Warteschlangenlimit für alle Ihre Crawlers ist 1 Million SeitenWenn dieses Limit erreicht ist, unterbricht das System die Push-Anfragen vorübergehend und setzt sie automatisch fort, wenn die Warteschlange geleert ist.

Beachten Sie, dass diese Limits an Ihre spezifischen Anforderungen angepasst werden können. Kontaktieren Sie einfach Crawlbase Kundendienstleistung um ein Upgrade anzufordern.

Skalieren Sie Ihr Web Scraping mit Crawlbase

Web-Scraping-Projekte beschränken sich heute nicht mehr nur auf das Schreiben robuster Skripte und die Verwaltung von Proxys. Sie benötigen eine unternehmenstaugliche Infrastruktur, die sowohl gesetzeskonform als auch an die sich wandelnden Anforderungen der modernen Geschäftswelt anpassbar ist.

Crawlbase ist auf Leistung, Zuverlässigkeit und Skalierbarkeit ausgelegt. Dank seiner Lösungen haben Unternehmen und Entwickler wie Ihres umsetzbare Erkenntnisse für Wachstum gewonnen.

Jetzt kostenlos registrieren.

Häufig gestellte Fragen

F: Kann ich meine eigenen erstellen Crawler Webhook?

Ja, um Web Scraping zu skalieren, ist es immer eine gute Praxis, einen Webhook für Ihre CrawlerWir empfehlen Ihnen, unseren vollständigen Leitfaden zu lesen. So wird's genutzt Crawlbase Crawler zu lernen, wie.

F: Kann ich das testen? Crawler kostenlos?

Derzeit müssen Sie Fügen Sie Ihre Rechnungsdetails hinzu zuerst die Crawler. Crawlbase bietet standardmäßig keine kostenlosen Credits, wenn Sie sich für die Crawler, Sie können sich jedoch an den Kundensupport wenden, um eine kostenlose Testversion anzufordern.

F: Was sind die Best Practices für den Umgang mit dynamischen Inhalten beim Web Scraping?

Möchten Sie dynamische Inhalte beim Web Scraping bearbeiten? Hier sind einige wichtige Vorgehensweisen, die Sie beachten sollten:

  1. Hebel-API: Werfen Sie einen Blick auf die Netzwerkaktivität, um zu sehen, ob die Daten von einer internen API abgerufen werden. Diese Methode ist beim Scraping in der Regel schneller und zuverlässiger.

  2. Strategisch warten: Anstatt sich auf fest programmierte Timeouts zu verlassen, verwenden Sie intelligente Wartestrategien wie waitForSelector or waitForNetworkIdle um sicherzustellen, dass alle Elemente vollständig geladen sind, bevor Sie fortfahren.

  3. Verwenden Sie eine Scraping-API: Tools wie Crawlbase kann Ihnen das Leben erleichtern, indem es dynamische Inhalte für Sie verarbeitet, das Rendering und die JavaScript-Ausführung verwaltet und sogar Anti-Bot-Maßnahmen vornimmt.

F: Was sind die Best Practices für rotierende Proxys beim Web Scraping?

Wenn Sie nun neugierig auf die Best Practices für rotierende Proxys beim Web Scraping sind, sollten Sie Folgendes beachten:

  1. Verwenden Sie Residential- oder Datacenter-Proxys mit Bedacht: Wählen Sie den richtigen Typ basierend auf der Website, die Sie ansprechen möchten. Residential Proxies sind schwieriger zu erkennen, aber auch teurer.

  2. Automatische Rotation: Richten Sie eine automatische IP-Rotation nach einigen Anfragen oder nach einer bestimmten Anzahl von Sekunden ein, um die Dinge aktuell zu halten.

  3. Vermeiden Sie die Überlastung einer einzelnen IP: Verteilen Sie Ihre Anfragen gleichmäßig auf verschiedene Proxys, um Muster zu vermeiden, die Anti-Bot-Systeme alarmieren könnten.

  4. Proxy-Integrität überwachen: Behalten Sie Antwortzeiten, Statuscodes und Erfolgsraten im Auge, um fehlerhafte Proxys zu erkennen und zu ersetzen.

  5. Verwenden Sie eine verwaltete Proxy-Lösung: Dienstleistungen wie Crawlbase bieten integrierte Proxy-Verwaltung und -Rotation, sodass Sie sich nicht mit manuellen Setups herumschlagen müssen.

F: Was sind die Best Practices für die Handhabung großer Datensätze aus dem Web Scraping?

Beim Umgang mit großen Datensätzen aus Web Scraping gibt es verschiedene bewährte Methoden, die einen erheblichen Unterschied machen können. Hier sind einige Tipps, die Sie beachten sollten:

  1. Verwenden Sie Paginierung und Batching: Anstatt alles auf einmal zu scrapen, teilen Sie Ihre Aufgaben mithilfe von Seitenparametern oder Datumsbereichen in kleinere Abschnitte auf. So vermeiden Sie eine Serverüberlastung oder Speicherprobleme.

  2. Daten inkrementell speichern: Streamen Sie Ihre Scraped-Daten direkt in Datenbanken oder Cloud-Speicher. So vermeiden Sie Speicherüberlastung und behalten die Übersicht.

  3. Daten frühzeitig normalisieren und bereinigen: Nehmen Sie sich beim Scraping die Zeit, Ihre Daten zu bereinigen, zu deduplizieren und zu strukturieren. Dies verringert den Arbeitsaufwand für spätere Verarbeitungsschritte.

  4. Implementieren Sie Wiederholungs- und Protokollierungssysteme: Überwachen Sie alle URLs, deren Scraping fehlschlägt, und richten Sie ein System ein, um sie später erneut zu versuchen. Das Protokollieren Ihrer Scraping-Statistiken kann Ihnen außerdem helfen, Ihren Fortschritt zu verfolgen und Probleme zu erkennen.

  5. Verwenden Sie eine skalierbare Infrastruktur: Erwägen Sie die Verwendung von asynchronem Scraping, Job-Warteschlangen oder serverlosen Funktionen zur Bewältigung größerer Aufgaben. Tools wie Crawlbase kann Ihnen dabei helfen, Ihre Datenextraktion zu skalieren, ohne dass Sie sich mit der Verwaltung von Backend-Ressourcen herumschlagen müssen.