Comment gratter la recherche Algolia - Site de scraping Web

Voici un article de blog de plus de 2000 mots sur « Comment supprimer la recherche Algolia » :

Introduction

Algolia est une API de recherche populaire qui alimente la fonctionnalité de recherche de nombreux sites Web sur Internet. Il permet aux sites Web de mettre en œuvre une recherche rapide et pertinente sans avoir besoin de gérer eux-mêmes une infrastructure de recherche complexe.

Voici quelques exemples de sites Web populaires utilisant Algolia :

Reddit
Moyenne
GitHub
StackOverflow
HackerNews

Le but de cet article est d'expliquer :

Qu'est-ce qu'Algolia et comment ça marche
Comment récupérer les résultats de recherche Algolia à l'aide de Python
Techniques pour gratter Algolia efficacement à grande échelle
Comment éviter de se bloquer en grattant Algolia

À la fin, vous comprendrez comment créer un scraper Web Algolia évolutif pour tout site Web qui l'utilise.

Qu’est-ce qu’Algolia ?

Algolia est une API de recherche hébergée qui fournit des services tels que l'indexation, la recherche et les recommandations. Il est souvent appelé fournisseur de recherche en tant que service (SaaS).

Les principales propositions de valeur d'Algolia comprennent :

Recherche rapide – Algolia prétend être capable de rechercher des milliards d’enregistrements en moins de 100 ms. C'est un ordre de grandeur plus rapide que d'effectuer une recherche sur votre propre infrastructure.
Recherche pertinente – Algolia gère des éléments tels que la tolérance aux fautes de frappe, les synonymes et l'apprentissage basé sur le comportement de l'utilisateur pour renvoyer les résultats les plus pertinents.
Service hébergé – Algolia s'occupe de choses comme la mise à l'échelle et la redondance. Vous n’avez aucune infrastructure à gérer.
Accès API – La fonctionnalité de recherche est accessible via API, ce qui permet une intégration facile dans les sites Web, les applications mobiles, etc.

Algolia fournit des bibliothèques client pour la plupart des principaux langages et frameworks qui gèrent la communication API. Sur le front-end, les développeurs ajoutent du code JavaScript pour s'interfacer avec l'API d'Algolia.

En résumé, Algolia propose une recherche hébergée et évolutive via API. Cela permet aux sites Web de créer rapidement des recherches de qualité sans avoir à créer eux-mêmes des systèmes complexes.

Supprimer la recherche Algolia avec Python

Maintenant que nous comprenons ce qu'est Algolia, voyons comment nous pouvons extraire les résultats de recherche Algolia à l'aide de Python.

Scraping Algolia est simple puisque l’API est publique et documentée. Il nous faut simplement :

Identifiez le point de terminaison et les paramètres de l'API
Extraire toutes les clés d'accès
Envoyer des requêtes de recherche et analyser la réponse JSON

Passons en revue un exemple complet de scraping d'un site Web propulsé par Algolia.

Trouver le point de terminaison de l'API

Tout d’abord, nous devons trouver le point de terminaison de l’API utilisé par le site Web pour la recherche. Le moyen le plus simple consiste à ouvrir le site dans votre navigateur, à exécuter une requête de recherche et à vérifier les requêtes réseau dans les outils de développement.

Par exemple, sur HackerNews nous voyons une demande faite à :

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

Les /api/v1/search path indique qu'il s'agit de l'API de recherche Algolia. Nous voyons également le terme de recherche python passé en paramètre de requête.

En vérifiant la réponse, nous pouvons voir qu'elle renvoie du JSON avec les résultats. Nous connaissons désormais le point de terminaison de l'API et le paramètre de recherche à utiliser.

Obtenir les clés API

Ensuite, nous devons obtenir la clé API nécessaire à l’authentification. En vérifiant à nouveau la requête réseau, nous pouvons la voir transmise via le X-Algolia-API-Key en-tête.

Nous pouvons extraire cette clé API et l'ajouter à nos requêtes. Une ingénierie inverse supplémentaire peut être nécessaire si la clé est obscurcie en JavaScript.

Faire des demandes de recherche

Avec le point de terminaison et la clé API, nous pouvons désormais faire des requêtes de recherche en Python :

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‘])

Nous envoyons une requête GET au point de terminaison de l'API en transmettant notre terme de recherche, les accès par page et l'en-tête de la clé API. Le résultat contient les résultats de recherche au format JSON que nous pouvons analyser et traiter selon nos besoins.

Et nous avons maintenant un grattoir Algolia de base !

Gratter des pages supplémentaires

Une limitation est que l'API ne renvoie que la première page de résultats. Pour obtenir des pages supplémentaires, nous devons passer le page paramètre incrémenté de 0 :

# First page
params[‘page‘] = 0 

# Second page
params[‘page‘] = 1 

# Third page
params[‘page‘] = 2

Pour gratter toutes les pages, nous pouvons effectuer une boucle sur les requêtes en incrémentant le numéro de page jusqu'à ce qu'aucun résultat ne soit renvoyé.

En mettant cela ensemble:

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

Cela parcourt les pages et donne tous les résultats.

Pour collecter tous les résultats :

results = []

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

print(len(results))

Et nous disposons désormais d’un paginateur complet pour récupérer tous les résultats de recherche Algolia !

Gratter Algolia à grande échelle

Le grattoir de base ci-dessus fonctionne mais n'est pas optimisé pour le grattage à grande échelle. Problèmes que vous pouvez rencontrer :

Lent – Les requêtes synchrones ralentissent le grattage de centaines de pages.
Fragile – Un échec interrompt tout le processus de grattage.
Banni – Le grattage d’une adresse IP risque d’être bloqué.

Voyons comment résoudre ces problèmes pour un scraping robuste à grande échelle.

Requêtes asynchrones

Pour accélérer le scraping, nous pouvons exploiter les requêtes asynchrones. Cela nous permet d’avoir plusieurs demandes en vol simultanément.

Par exemple avec le asyncio module:

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()

Cela récupère 10 pages simultanément à chaque itération. Avec les requêtes asynchrones, le scraper est un ordre de grandeur plus rapide.

Nouvelles tentatives et tolérance aux pannes

Les requêtes réseau sont sujettes à des pannes intermittentes. Nous pouvons ajouter des tentatives pour gérer les erreurs avec élégance :

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

Cela réessaye simplement jusqu'à 3 fois en cas d'échec. D'autres améliorations telles que le recul exponentiel pourraient également être ajoutées.

Pour plus de résilience, nous pouvons envelopper la boucle de scraping globale dans un essai/sauf et réessayer en cas de crash inattendu.

Avec des tentatives à plusieurs niveaux, le scraper peut récupérer de diverses erreurs et continuer à fonctionner.

Proxies rotatives

En extraire trop d’informations sur une seule adresse IP risque d’être bloqué. Pour éviter cela, nous pouvons acheminer les requêtes via différents proxys en utilisant des modules comme 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

En acheminant chaque requête via une adresse IP proxy différente, nous pouvons effectuer du scraping à grande échelle sans nous soucier des blocages.

Les étapes ci-dessus nous permettent de créer un grattoir Algolia robuste, hautes performances et à grande échelle en Python. Les mêmes principes s’appliquent à n’importe quelle langue.

Éviter les blocages lors du grattage d'Algolia

Le dernier problème à résoudre est d'éviter les blocages du service Algolia lui-même. Si vous faites trop de demandes agressives, Algolia peut bloquer votre adresse IP ou limiter les demandes.

Voici quelques conseils pour gratter poliment et minimiser les blocages :

Taux limite : Ne surchargez pas l'API avec des centaines de requêtes simultanées. Commencez petit et augmentez progressivement.
Utiliser des proxys: faites pivoter différentes adresses IP pour répartir la charge et éviter les requêtes concentrées.
Randomiser les agents utilisateurs : variez l'en-tête de l'agent utilisateur entre les requêtes.
Suivre robots.txt: Assurez-vous que votre scraper obéit aux règles robots.txt.
Utiliser la logique de nouvelle tentative : Interruption exponentielle si votre débit est limité ou bloqué.
Grattez pendant les périodes de faible trafic: Ciblez les nuits de semaine lorsque la charge est moindre.
Surveiller attentivement : Vérifiez l'augmentation des échecs ou la limitation.

Avec des soins appropriés, vous pouvez construire des grattoirs Algolia durables et durables. Mais veillez à surveiller de près et à adapter votre approche au fil du temps.

Bibliothèques d'aide au grattage

Gérer manuellement toute la complexité de la mise à l’échelle et de la résilience peut s’avérer fastidieux. Divers outils commerciaux existent pour simplifier le web scraping.

Par exemple :

GrattageBee – Gère les proxys, les CAPTCHA et les navigateurs.
GrattoirAPI – API du navigateur avec rotation automatique du proxy.
Exploration des proxys – Proxys résidentiels avec navigateur sans tête.

Ces outils facilitent la création de scrapers robustes sans avoir à coder vous-même une logique complexe. Voir mon guide sur comment et quand utiliser une API de scraping.

Récapitulation

Voici les principaux points à retenir:

Algolia propose une recherche hébergée via API pour une intégration facile dans les sites.
L'API de recherche est publique et peut être récupérée en extrayant le point de terminaison et les clés.
Le scraping à grande échelle nécessite des requêtes asynchrones et une rotation de proxy.
Surveillez attentivement et grattez poliment pour éviter les blocages.
Les services de grattage commerciaux peuvent simplifier les gros travaux de grattage.

J'espère que cet article fournit un bon aperçu de la façon de supprimer efficacement l'API de recherche Algolia à grande échelle avec Python. Les mêmes principes s'appliquent également à d'autres langues.

Faites-moi savoir si vous avez d'autres questions!

Comment supprimer la recherche Algolia