Tutorial de Scrapy Splash: Domina el arte de extraer datos de sitios web renderizados con JavaScript usando Scrapy y Splash

Scrapy Splash es una herramienta inmensamente potente que puede abrir nuevas oportunidades para extraer datos de sitios web dinámicos. Sin embargo, antes de empezar a aprovechar las ventajas de Scrapy Splash, debemos configurar primero nuestros sistemas. Esto implica varios pasos esenciales, incluida la instalación de Docker, Splash y Scrapy, así como las configuraciones necesarias para que todo funcione a la perfección.

1) Configuración e instalación de Docker

Docker es una tecnología de contenedorización de vanguardia que nos permite aislar y ejecutar la instancia de Splash en un contenedor virtual, garantizando un funcionamiento fluido y consistente.

Para usuarios de Linux:

Ejecute el siguiente comando en el terminal:

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

Para otros sistemas operativos:

Los usuarios de Windows, macOS y otros sistemas operativos pueden encontrar guías de instalación detalladas en el sitio web de Docker.

2) Descarga e instalación de Splash a través de Docker

Una vez instalado Docker, puedes proceder a descargar la imagen Docker de Splash, una parte esencial de nuestra infraestructura de scraping.

Ejecute el comando:

docker pull scrapinghub/splash

Esto descargará la imagen. Ahora ejecútala con:

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

¡Enhorabuena! Tu instancia de Splash ya está lista en localhost:8050. Deberías ver la página predeterminada de Splash cuando visites esta URL en tu navegador.

3) Instalación de Scrapy y el complemento Scrapy-Splash

Scrapy es un marco de trabajo de scraping flexible, y el complemento scrapy-splash conecta Scrapy con Splash. Puedes instalar ambos con:

pip install scrapy scrapy-splash

El comando anterior descarga todas las dependencias necesarias y las instala.

4) Creación de tu primer proyecto de Scrapy

Comienza tu aventura en el scraping con el siguiente comando:

scrapy startproject splashscraper

Esto crea un proyecto de Scrapy llamado splashscraper con una estructura similar a:

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

5) Integración de Scrapy con Splash

Ahora viene la parte esencial: configurar Scrapy para que funcione con Splash. Para ello, es necesario modificar el archivo settings.py de tu proyecto Scrapy.

Configuración de la URL de Splash:

Define una variable para tu instancia de Splash:

SPLASH_URL = 'http://localhost:8050'

Middlewares del descargador:

Estos ajustes permiten la interacción con 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'

El resto de los ajustes pueden mantenerse con sus valores predeterminados.

Extraer datos de páginas web dinámicas puede requerir la interacción con JavaScript. Ahí es donde entra en juego Scrapy Splash. Al final de esta guía, sabrás cómo crear una araña utilizando Scrapy Splash para extraer cotizaciones de quotes.toscrape.com.

Paso 1: Generar la araña

Utilizaremos el comando integrado de Scrapy para generar una araña. El comando es:

scrapy genspider quotes quotes.toscrape.com

Al ejecutarlo, se creará un nuevo archivo llamado quotes.py en el directorio spiders.

Paso 2: Comprender los conceptos básicos de una araña de Scrapy

Al abrir quotes.py, encontrarás:

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: El nombre de la araña
• allowed_domains: restringe la araña a los dominios de la lista
• start_urls: Las URL que se van a rastrear
• parse: El método invocado para cada URL

Paso 3: Recopilar datos de una sola página

Ahora, pongamos en marcha la araña.

a) Inspeccionar elementos con un navegador web

Utiliza las herramientas de desarrollo para analizar la estructura HTML. Verás que cada cita está encerrada en una etiqueta div con el nombre de clase quote.

b) Preparar la clase SplashscraperItem

En items.py, modifícalo para incluir tres campos: author, text y tags:

import scrapy

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

c) Implementar el método parse()

Importa la clase SplashscraperItem y actualiza el método parse en 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

Paso 4: Gestión de la paginación

Añade código para navegar por todas las páginas:

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

Paso 5: Añadir solicitudes Splash para contenido dinámico

Para utilizar SplashRequest, tendrás que realizar cambios en el spider actual:

from scrapy_splash import SplashRequest

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

Actualiza el método parse para que también utilice SplashRequest:

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

¡Enhorabuena! Acabas de escribir una araña de Scrapy totalmente funcional que utiliza Splash para extraer contenido dinámico. Ahora puedes ejecutar la araña y extraer todas las citas, autores y etiquetas de quotes.toscrape.com.

El código proporciona una excelente plantilla para extraer datos de otros sitios web dinámicos con estructuras similares. ¡Feliz scraping!

Las respuestas de Splash en Scrapy contienen algunas características únicas que difieren de las respuestas estándar de Scrapy. Se gestionan de una manera específica, según el tipo de respuesta, pero el proceso de extracción se puede realizar utilizando métodos habituales de Scrapy. Profundicemos en ello.

Comprender cómo responde Splash a las solicitudes y su objeto de respuesta

Cuando Scrapy Splash procesa una solicitud, devuelve diferentes subclases de respuesta dependiendo del tipo de solicitud:

• SplashResponse: Para respuestas Splash binarias que incluyen archivos multimedia como imágenes, vídeos, audios, etc.
• SplashTextResponse: cuando el resultado es textual.
• SplashJsonResponse: cuando el resultado es un objeto JSON.

Análisis de datos de las respuestas de Splash

Se pueden emplear el analizador integrado de Scrapy y las clases Selector para analizar las respuestas de Splash. Esto significa que, aunque los tipos de respuesta sean diferentes, los métodos utilizados para extraer datos de ellos siguen siendo los mismos.

A continuación se muestra un ejemplo de cómo extraer datos de una respuesta 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("")

Explicación:

• .css("span.text::text"): Esto utiliza selectores CSS para localizar el elemento span con la clase text, y ::text le indica a Scrapy que extraiga la propiedad text de ese elemento.
• .css("meta.keywords::attr(content)"): Aquí, ::attr(content) se utiliza para obtener el atributo content de la etiqueta meta con la clase keywords.

El manejo de respuestas Splash en Scrapy no requiere ningún tratamiento especializado. Puedes seguir utilizando los métodos y la sintaxis habituales para extraer datos. La principal diferencia radica en comprender el tipo de respuesta Splash devuelta, que puede ser texto estándar, binario o JSON. Estos tipos se pueden manejar de forma similar a las respuestas normales de Scrapy, lo que permite una transición fluida si estás añadiendo Splash a un proyecto de Scrapy ya existente.

¡Feliz scraping con Splash!