Tutoriel Scrapy Splash : Maîtriser l'art du scraping de sites web rendus en JavaScript avec Scrapy et Splash

Ștefan Răcila le 10 août 2023

Dans le paysage complexe du web d'aujourd'hui, où le contenu est souvent généré dynamiquement à l'aide de JavaScript, d'appels AJAX ou d'autres scripts côté client, l'extraction d'informations devient une tâche difficile. Les techniques de scraping traditionnelles peuvent échouer à extraire des données qui sont chargées de manière asynchrone, ce qui nécessite une approche plus sophistiquée. C'est là que Scrapy Splash entre en scène.

Scrapy Splash est un navigateur simplifié doté d'une API HTTP. Contrairement aux navigateurs plus encombrants, il est léger mais puissant, conçu pour gratter les sites web qui rendent leur contenu avec JavaScript ou par le biais de procédures AJAX. En simulant le comportement d'un véritable navigateur, Scrapy Splash peut interagir avec des éléments dynamiques, ce qui en fait un outil précieux pour tous les besoins d'extraction de données liés au contenu rendu par JavaScript.

Dans ce guide complet, nous allons explorer les capacités uniques de Scrapy Splash, en illustrant étape par étape comment tirer parti de cet outil de manière efficace pour extraire des données de sites Web qui utilisent JavaScript pour le rendu. Que vous soyez un data miner expérimenté ou que vous débutiez, la compréhension des fonctionnalités de Scrapy Splash vous permettra d'obtenir les informations dont vous avez besoin à partir d'un web de plus en plus dynamique.

Restez avec nous pour découvrir les tenants et les aboutissants de l'utilisation de Scrapy Splash pour le scraping du web moderne et interactif, en commençant par son installation et en terminant par des exemples concrets.

Comment configurer Splash : Guide d'installation et de configuration étape par étape

Scrapy Splash est un outil extrêmement puissant qui peut ouvrir de nouvelles perspectives en matière de récupération de données à partir de sites web dynamiques. Cependant, avant de commencer à récolter les bénéfices de Scrapy Splash, nous devons d'abord configurer nos systèmes. Cela implique plusieurs étapes essentielles, notamment l'installation de Docker, Splash, Scrapy et les configurations nécessaires pour que tout fonctionne parfaitement.

1) Configuration et installation de Docker

Docker est une technologie de conteneurisation de pointe qui nous permet d'isoler et d'exécuter l'instance Splash dans un conteneur virtuel, garantissant ainsi un fonctionnement fluide et cohérent.

Pour les utilisateurs de Linux :

Exécutez la commande suivante dans le terminal :

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

Pour les autres systèmes d'exploitation :

Les utilisateurs de Windows, macOS et d'autres systèmes d'exploitation peuvent trouver des guides d'installation détaillés sur le site web de Docker.

2) Téléchargement et installation de Splash via Docker

Une fois Docker installé, vous pouvez télécharger l'image Docker Splash, un élément essentiel de notre infrastructure de scraping.

Exécuter la commande :

docker pull scrapinghub/splash

Ceci téléchargera l'image. Exécutez-la maintenant avec :

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

Nous vous félicitons ! Votre instance Splash est maintenant prête sur localhost:8050. Vous devriez voir la page Splash par défaut lorsque vous visitez cette URL dans votre navigateur.

3) Installation de Scrapy et du plugin Scrapy-Splash

Scrapy est un framework de scraping flexible, et le plugin scrapy-splash fait le lien entre Scrapy et Splash. Vous pouvez installer les deux avec :

pip install scrapy scrapy-splash

La commande ci-dessus télécharge toutes les dépendances nécessaires et les installe.

4) Créer votre premier projet Scrapy

Commencez votre voyage de scraping avec la commande suivante :

scrapy startproject splashscraper

Cela crée un projet Scrapy nommé splashscraper avec une structure similaire à :

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

5) Intégrer Scrapy à Splash

Maintenant vient la partie essentielle - configurer Scrapy pour qu'il fonctionne avec Splash. Cela nécessite de modifier le fichier settings.py dans votre projet Scrapy.

Configuration de l'URL Splash :

Définissez une variable pour votre instance Splash :

SPLASH_URL = 'http://localhost:8050'

Downloader Middlewares :

Ces paramètres permettent d'interagir avec 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'

Les autres paramètres peuvent rester à leur valeur par défaut.

Écrire un Splash Spider Scrapy

L'extraction de données à partir de pages web dynamiques peut nécessiter une interaction avec JavaScript. C'est là que Scrapy Splash entre en jeu. À la fin de ce guide, vous saurez comment créer un spider à l'aide de Scrapy Splash pour extraire des citations de quotes.toscrape.com.

Étape 1 : Création de l'araignée

Nous allons utiliser la commande intégrée de Scrapy pour générer une araignée. La commande est la suivante :

scrapy genspider quotes quotes.toscrape.com

Lors de l'exécution, un nouveau fichier nommé quotes.py sera créé dans le répertoire spiders.

Étape 2 : Comprendre les principes de base d'une araignée Scrapy

En ouvrant quotes.py, vous trouverez :

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 : Le nom de l'araignée
• allowed_domains : Limite le spider aux domaines listés
• start_urls : Les URL à scraper
• parse : La méthode invoquée pour chaque URL

Étape 3 : Récupérer des données à partir d'une seule page

Maintenant, rendons l'araignée fonctionnelle.

a) Inspecter les éléments à l'aide d'un navigateur web

Utilisez les outils de développement pour analyser la structure HTML. Vous trouverez chaque citation enfermée dans une balise div avec un nom de classe quote.

b) Préparer la classe SplashscraperItem

Dans items.py, modifiez-le pour inclure trois champs : auteur, texte et tags :

import scrapy

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

c) Mettre en œuvre la méthode parse()

Importez la classe SplashscraperItem et mettez à jour la méthode parse dans 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

Étape 4 : Gestion de la pagination

Ajouter du code pour naviguer dans toutes les pages :

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

Étape 5 : Ajout de demandes d'éclaboussures pour le contenu dynamique

Pour utiliser SplashRequest, vous devez apporter des modifications à l'araignée actuelle :

from scrapy_splash import SplashRequest

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

Mettre à jour la méthode d'analyse pour utiliser également SplashRequest :

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

Félicitations ! Vous venez d'écrire un spider Scrapy entièrement fonctionnel qui utilise Splash pour récupérer du contenu dynamique. Vous pouvez maintenant lancer le spider et extraire toutes les citations, auteurs et tags de quotes.toscrape.com.

Ce code constitue un excellent modèle pour le scraping d'autres sites web dynamiques présentant des structures similaires. Bon scraping !

Gérer les réponses aux éclaboussures dans Scrapy

Les réponses Splash dans Scrapy contiennent des caractéristiques uniques qui diffèrent des réponses Scrapy standard. Elles sont traitées d'une manière spécifique, basée sur le type de réponse, mais le processus d'extraction peut être effectué en utilisant des méthodes Scrapy familières. Voyons cela de plus près.

Comprendre comment Splash répond aux requêtes et son objet de réponse

Lorsque Scrapy Splash traite une demande, il renvoie différentes sous-classes de réponses en fonction du type de demande :

• SplashResponse : Pour les réponses binaires Splash qui comprennent des fichiers multimédias tels que des images, des vidéos, des fichiers audio, etc.
• SplashTextResponse : Lorsque le résultat est textuel.
• SplashJsonResponse : Lorsque le résultat est un objet JSON.

Analyse des données à partir des réponses Splash

Les classes d'analyseur et de sélecteur intégrées à Scrapy peuvent être utilisées pour analyser les réponses Splash. Cela signifie que, bien que les types de réponses soient différents, les méthodes utilisées pour en extraire des données restent les mêmes.

Voici un exemple d'extraction de données à partir d'une réponse Splash :

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

Explication :

• .css("span.text::text") : Cette méthode utilise les sélecteurs CSS pour localiser l'élément span avec la classe text, et ::text indique à Scrapy d'extraire la propriété text de cet élément.
• .css("meta.keywords::attr(content)") : Ici, ::attr(content) est utilisé pour obtenir l'attribut content de la balise meta avec la classe keywords.

Conclusion

La gestion des réponses Splash dans Scrapy ne nécessite pas de traitement particulier. Vous pouvez toujours utiliser les méthodes et la syntaxe habituelles pour extraire des données. La principale différence réside dans la compréhension du type de réponse Splash renvoyée, qui peut être un texte standard, binaire ou JSON. Ces types peuvent être traités de la même manière que les réponses Scrapy ordinaires, ce qui permet une transition en douceur si vous ajoutez Splash à un projet Scrapy existant.

Bon scraping avec Splash !