So kratzen Sie die Algolia-Suche

Hier ist ein Blogbeitrag mit mehr als 2000 Wörtern zum Thema „How to Scrape Algolia Search“:

Einleitung

Algolia ist eine beliebte Such-API, die die Suchfunktion für viele Websites im Internet unterstützt. Es ermöglicht Websites, eine schnelle und relevante Suche zu implementieren, ohne selbst eine komplexe Suchinfrastruktur betreiben zu müssen.

Einige Beispiele beliebter Websites, die Algolia verwenden, sind:

Reddit
Medium
GitHub
StackOverflow
Hacker News

Das Ziel dieses Beitrags ist es zu erklären:

Was ist Algolia und wie funktioniert es?
So durchsuchen Sie Algolia-Suchergebnisse mit Python
Techniken zum effizienten Scrapen von Algolia im großen Maßstab
So vermeiden Sie Blockaden beim Schaben von Algolia

Am Ende werden Sie verstehen, wie Sie einen skalierbaren Algolia-Web-Scraper für jede Website erstellen, die ihn verwendet.

Was ist Algolia?

Algolia ist eine gehostete Such-API, die Dienste wie Indizierung, Suche und Empfehlungen bereitstellt. Es wird oft als Search-as-a-Service (SaaS)-Anbieter bezeichnet.

Zu den wichtigsten Wertversprechen von Algolia gehören:

Schnelle Suche – Algolia gibt an, in weniger als 100 ms über Milliarden Datensätze durchsuchen zu können. Dies ist um Größenordnungen schneller als die Suche in Ihrer eigenen Infrastruktur.
Relevante Suche – Algolia kümmert sich um Dinge wie Tippfehlertoleranz, Synonyme und Lernen basierend auf dem Benutzerverhalten, um die relevantesten Ergebnisse zu liefern.
Gehosteter Dienst – Algolia kümmert sich um Dinge wie Skalierung und Redundanz. Sie müssen keine Infrastruktur verwalten.
API-Zugriff – Auf die Suchfunktion kann über eine API zugegriffen werden, was eine einfache Integration in Websites, mobile Apps usw. ermöglicht.

Algolia bietet Client-Bibliotheken für die meisten wichtigen Sprachen und Frameworks, die die API-Kommunikation abwickeln. Im Frontend fügen Entwickler JavaScript-Code hinzu, um eine Schnittstelle zur Algolia-API herzustellen.

Zusammenfassend bietet Algolia eine gehostete und skalierbare Suche über API. Dadurch können Websites schnell eine großartige Suche erstellen, ohne selbst komplexe Systeme aufbauen zu müssen.

Scraping Algolia Search mit Python

Nachdem wir nun verstanden haben, was Algolia ist, schauen wir uns an, wie wir Algolia-Suchergebnisse mit Python durchsuchen können.

Das Scraping von Algolia ist unkompliziert, da die API öffentlich und dokumentiert ist. Wir müssen einfach:

Identifizieren Sie den API-Endpunkt und die Parameter
Extrahieren Sie alle Zugriffsschlüssel
Senden Sie Suchanfragen und analysieren Sie die JSON-Antwort

Sehen wir uns ein vollständiges Beispiel für das Scraping einer von Algolia betriebenen Website an.

Den API-Endpunkt finden

Zuerst müssen wir den API-Endpunkt finden, den die Website für die Suche verwendet. Am einfachsten ist es, die Website in Ihrem Browser zu öffnen, eine Suchabfrage auszuführen und die Netzwerkanfragen in den Entwicklertools zu überprüfen.

Zum Beispiel auf Hacker News Wir sehen eine Anfrage an:

https://hn.algolia.com/api/v1/search?query=python

Das /api/v1/search path verrät, dass es sich hierbei um die Algolia-Such-API handelt. Wir sehen auch den Suchbegriff python als Abfrageparameter übergeben.

Wenn wir die Antwort überprüfen, können wir sehen, dass sie JSON mit den Ergebnissen zurückgibt. Wir kennen jetzt den zu verwendenden API-Endpunkt und Suchparameter.

Abrufen der API-Schlüssel

Als nächstes müssen wir den API-Schlüssel erhalten, der zur Authentifizierung erforderlich ist. Wenn wir die Netzwerkanfrage noch einmal überprüfen, können wir sehen, dass sie über das weitergeleitet wurde X-Algolia-API-Key Header.

Wir können diesen API-Schlüssel extrahieren und ihn zu unseren Anfragen hinzufügen. Wenn der Schlüssel in JavaScript verschleiert ist, kann zusätzliches Reverse Engineering erforderlich sein.

Suchanfragen stellen

Mit dem Endpunkt und dem API-Schlüssel können wir nun Suchanfragen in Python stellen:

import requests 

api_key = "abc123" # Extracted key 

search_url = "https://hn.algolia.com/api/v1/search"

params = {
  ‘query‘: ‘python‘,
  ‘hitsPerPage‘: 100, 
  ‘attributesToSnippet‘: [‘title:10‘]
}

headers = {
  "X-Algolia-API-Key": api_key
}

response = requests.get(search_url, params=params, headers=headers)
data = response.json()

print(data[‘hits‘])

Wir stellen eine GET-Anfrage an den API-Endpunkt und übergeben dabei unseren Suchbegriff, Treffer pro Seite und den API-Schlüsselheader. Das Ergebnis enthält die Suchtreffer als JSON, die wir nach Bedarf analysieren und verarbeiten können.

Und wir haben jetzt einen einfachen Algolia-Schaber!

Scraping zusätzlicher Seiten

Eine Einschränkung besteht darin, dass die API nur die erste Ergebnisseite zurückgibt. Um zusätzliche Seiten zu erhalten, müssen wir das übergeben page Parameter-Inkrementierung von 0:

# First page
params[‘page‘] = 0 

# Second page
params[‘page‘] = 1 

# Third page
params[‘page‘] = 2

Um alle Seiten zu durchsuchen, können wir in einer Schleife Anfragen stellen und dabei die Seitenzahl erhöhen, bis keine Ergebnisse mehr zurückgegeben werden.

Zusammenfassend:

from typing import Iterator

def scrape_search(search_term: str) -> Iterator[dict]:

  params = {
    ‘query‘: search_term,
    ‘hitsPerPage‘: 100,
  }

  page = 0
  while True:
    params[‘page‘] = page
    resp = requests.get(search_url, params=params, headers=headers)
    data = resp.json()

    if not data[‘hits‘]:
      break

    yield from data[‘hits‘]

    page += 1

Dies iteriert über Seiten und liefert alle Ergebnisse.

Um alle Ergebnisse zu sammeln:

results = []

for result in scrape_search("python"):
  results.append(result)

print(len(results))

Und wir haben jetzt einen vollständigen Paginator zum Durchsuchen aller Algolia-Suchergebnisse!

Algolia im Maßstab kratzen

Der obige Basisschaber funktioniert, ist jedoch nicht für das Schaben in großem Maßstab optimiert. Mögliche Probleme:

Bremst – Synchrone Anfragen verlangsamen das Durchsuchen von Hunderten von Seiten.
Zerbrechlich – Ein Fehler unterbricht den gesamten Scrape-Prozess.
Verboten – Beim Scraping von einer IP besteht die Gefahr, dass es blockiert wird.

Sehen wir uns an, wie diese Probleme für ein robustes Scraping im großen Maßstab gelöst werden können.

Asynchrone Anfragen

Um das Scraping zu beschleunigen, können wir asynchrone Anfragen nutzen. Dadurch können wir viele Anfragen gleichzeitig bearbeiten.

Zum Beispiel mit dem asyncio Modul:

import asyncio

async def fetch_page(page):
  params[‘page‘] = page
  resp = await asyncio.to_thread(requests.get, search_url, params=params) 
  return resp.json()

async def async_scrape():
  page = 0 
  while True:
    tasks = [asyncio.create_task(fetch_page(page + i)) for i in range(10)]
    results = await asyncio.gather(*tasks)

    for data in results:
      if not data[‘hits‘]:
        return

      for hit in data[‘hits‘]:
        yield hit

    page += 10

pages = async_scrape()

Dadurch werden bei jeder Iteration 10 Seiten gleichzeitig abgerufen. Bei asynchronen Anfragen ist der Scraper um eine Größenordnung schneller.

Wiederholungsversuche und Fehlertoleranz

Netzwerkanfragen sind anfällig für zeitweilige Fehler. Wir können Wiederholungsversuche hinzufügen, um Fehler ordnungsgemäß zu behandeln:

from time import sleep

async def fetch_page(page):

  for retry in range(3):

    try:
      return await asyncio.to_thread(requests.get, search_url, params=params) 
    except Exception as e:
      print(f"Error: {e}, retrying")
      sleep(1)

  print(f"Failed to fetch page {page} after {retries} retries")
  return {‘hits‘: []} # Return empty result

Bei jedem Fehler wird der Vorgang einfach bis zu dreimal wiederholt. Weitere Verbesserungen wie exponentielles Backoff könnten ebenfalls hinzugefügt werden.

Für noch mehr Ausfallsicherheit können wir die gesamte Scraping-Schleife in einen Try/Exception-Vorgang einschließen und bei unerwarteten Abstürzen einen erneuten Versuch durchführen.

Durch Wiederholungsversuche auf mehreren Ebenen kann der Scraper verschiedene Fehler beheben und weiterlaufen.

Rotierende Proxies

Wenn Sie zu viel von einer einzelnen IP entfernen, besteht die Gefahr, dass sie blockiert wird. Um dies zu verhindern, können wir Anfragen mithilfe von Modulen wie über verschiedene Proxys weiterleiten requests-proxy-killer:

from proxy_killer import KillerScraper

scraper = KillerScraper(use_cache=False, max_retries=3)

async def fetch_page(page):

  for retry in range(3): 
    try:
      proxy = scraper.get_proxy() # Rotate proxy
      resp = scraper.get(search_url, proxies=proxy, params=params)
      return resp.json()
    except Exception as e:
      print(f"Error: {e}, retrying")
      sleep(1)

# Remainder same as above

Indem wir jede Anfrage über eine andere Proxy-IP weiterleiten, können wir skalieren, ohne uns Gedanken über Blockaden machen zu müssen.

Die oben genannten Schritte ermöglichen es uns, einen robusten, leistungsstarken Algolia-Scraper in großem Maßstab in Python zu erstellen. Die gleichen Prinzipien gelten für jede Sprache.

Vermeidung von Blöcken beim Kratzen von Algolia

Das letzte zu lösende Problem besteht darin, Blockaden durch den Algolia-Dienst selbst zu vermeiden. Wenn Sie zu viele aggressive Anfragen stellen, blockiert Algolia möglicherweise Ihre IP-Adresse oder drosselt Anfragen.

Hier sind einige Tipps, um höflich zu schaben und Blockaden zu minimieren:

Grenzrate: Überfordern Sie die API nicht mit Hunderten gleichzeitiger Anfragen. Fangen Sie klein an und steigern Sie sich schrittweise.
Verwenden Sie Proxys: Rotieren Sie verschiedene IPs, um die Last zu verteilen und konzentrierte Anfragen zu vermeiden.
Benutzeragenten randomisieren: Variieren Sie den User-Agent-Header zwischen Anfragen.
Folgen Sie robots.txt: Stellen Sie sicher, dass Ihr Scraper den robots.txt-Regeln entspricht.
Verwenden Sie Wiederholungslogik: Exponentieller Backoff, wenn die Rate begrenzt oder blockiert wird.
Kratzen Sie in verkehrsarmen Zeiten: Ziel ist die Nacht unter der Woche, wenn die Auslastung geringer ist.
Überwachen Sie sorgfältig: Auf zunehmende Fehler oder Drosselung prüfen.

Mit der richtigen Pflege können Sie nachhaltige, langlebige Algolia-Schaber bauen. Achten Sie jedoch darauf, Ihren Ansatz genau zu überwachen und im Laufe der Zeit anzupassen.

Scraping-Hilfsbibliotheken

Die manuelle Bewältigung der Komplexität von Skalierung und Ausfallsicherheit kann mühsam sein. Es gibt verschiedene kommerzielle Tools, die das Web-Scraping vereinfachen.

Beispielsweise:

SchabenBiene – Verwaltet Proxys, CAPTCHAs und Browser.
SchaberAPI – Browser-API mit automatischer Proxy-Rotation.
ProxyCrawl – Wohn-Proxys mit Headless-Browser.

Diese Tools erleichtern den Aufbau robuster Scraper, ohne selbst komplexe Logik programmieren zu müssen. Siehe meinen Leitfaden auf wie und wann man eine Scraping-API verwendet.

Fazit

Hier sind die wichtigsten Imbissbuden:

Algolia bietet eine gehostete Suche über eine API zur einfachen Integration in Websites.
Die Such-API ist öffentlich und kann durch Extrahieren des Endpunkts und der Schlüssel gelöscht werden.
Scraping im großen Maßstab erfordert asynchrone Anfragen und Proxy-Rotation.
Überwachen Sie sorgfältig und kratzen Sie höflich, um Blockaden zu vermeiden.
Kommerzielle Schabedienste können große Schabearbeiten vereinfachen.

Ich hoffe, dieser Beitrag bietet einen guten Überblick darüber, wie man die Algolia-Such-API mit Python effektiv im großen Maßstab durchsucht. Die gleichen Grundsätze gelten auch für andere Sprachen.

Lassen Sie mich wissen, wenn Sie weitere Fragen haben!