Como executar o script Java com o Scrapy

Mihai Maxim em Jan 30 2023

Introdução

Bem-vindo ao excitante mundo da recolha dinâmica de dados de sítios Web! Como deve saber dos nossos artigos anteriores, este tipo de sítios Web pode ser um pouco complicado de navegar com as ferramentas tradicionais de extração de dados da Web. Mas não se preocupe! O Scrapy, o fiel assistente de raspagem da Web, está ao seu dispor com uma variedade de plug-ins e bibliotecas que tornam a raspagem dinâmica de sítios Web muito fácil.

Neste artigo, vamos mergulhar em algumas das opções mais populares para raspar esses sites alimentados por JavaScript com o Scrapy. E para tornar as coisas ainda mais fáceis, forneceremos exemplos de como usar cada uma delas para que possa enfrentar com confiança qualquer site que apareça no seu caminho.

Se é novo no Scrapy, não se preocupe. Pode consultar o nosso guia para uma introdução ao webscraping com o Scrapy

Navegadores sem cabeça?

Se não está familiarizado com os browsers sem cabeça, deixe-me pô-lo ao corrente. Essencialmente, estes são navegadores Web que funcionam sem uma interface visível. Sim, eu sei que parece estranho não poder ver a janela do navegador quando o está a utilizar. Mas acredite em mim, os navegadores headless podem ser um verdadeiro divisor de águas quando se trata de raspagem da Web.

Eis a razão: ao contrário dos navegadores normais que se limitam a apresentar páginas Web, os navegadores sem cabeça podem executar JavaScript. Isto significa que, se estiver a tentar extrair um sítio Web que depende do JavaScript para gerar o seu conteúdo, um navegador sem cabeça pode ajudá-lo executando o JavaScript e permitindo-lhe extrair o HTML resultante.

Explorar diferentes soluções

A melhor estratégia para renderizar JavaScript com o Scrapy depende das suas necessidades e recursos específicos. Se estiver com um orçamento apertado, vai querer escolher uma solução que seja económica. Usar um navegador sem cabeça ou uma biblioteca de renderização JavaScript pode ser a opção mais barata, mas você ainda terá que lidar com a possibilidade de bloqueios de IP e o custo de manutenção e execução da solução.

É sempre melhor experimentar algumas opções diferentes e ver qual delas funciona melhor para o seu caso de utilização.

Como executar Javascript com Scrapy usando Splash

O Splash é um navegador leve e sem cabeça concebido especificamente para a recolha de dados da Web. Ele é baseado no motor WebKit, que é o mesmo motor que alimenta o navegador Safari. A grande vantagem do Splash é que ele é fácil de configurar, especialmente se você usa Docker. Também está integrado com o Scrapy através do middleware scrapy-splash.

Para utilizar o middleware, primeiro é necessário instalar este pacote com o pip:

$ pip install scrapy-splash

Configurar o Splash com o Docker é fácil. Tudo o que precisa de fazer é executar uma instância do Splash na sua máquina local usando o Docker (https://docs.docker.com/get-docker/).

$ docker run -p 8050:8050 scrapinghub/splash

Depois disso, deverá ser possível aceder à instância local do Splash em http://localhost:8050/

O Splash tem uma API REST que facilita o uso com o Scrapy ou qualquer outra ferramenta de raspagem da Web. É possível testar o servidor fazendo um pedido de busca dentro do shell do Scrapy:

fetch('http://localhost:8050/render.html?url=<target_url>')

Para configurar o Middleware, adicione as seguintes linhas ao seu ficheiro settings.py.

SPLASH_URL = 'http://localhost:8050'

DOWNLOADER_MIDDLEWARES = {

    'scrapy_splash.SplashCookiesMiddleware': 723,

    'scrapy_splash.SplashMiddleware': 725,

    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,

}

SPIDER_MIDDLEWARES = {

    'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,

}

DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'

HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'

Visite https://github.com/scrapy-plugins/scrapy-splash para saber mais sobre cada ambiente.

A maneira mais fácil de renderizar pedidos com Splash é usar scrapy_splash.SplashRequest dentro do seu spider:

import scrapy

from scrapy_splash import SplashRequest

class RandomSpider(scrapy.Spider):

    name = 'random_spider'

    def start_requests(self):

        start_urls = [

        '<first_url',

        '<second_url>'

       ]

        for url in start_urls:

           yield SplashRequest(url=url, callback=self.parse, args={'wait': 5})

    def parse(self, response):

       

            result = response.css("h3::text").extract()

         

            yield result

Pode adicionar um parâmetro "wait" para especificar o período de tempo que pretende que o Splash aguarde antes de devolver o seu pedido.

Uma potencial desvantagem da utilização do Splash é que requer a utilização da linguagem de script Lua para executar acções como clicar em botões, preencher formulários e navegar em páginas.

Como executar Javascript com Scrapy usando Selenium

Você pode usar o Scrapy com o Selenium webdriver. O middleware scrapy-selenium funciona injetando o Selenium webdriver no processo de solicitação, de modo que o HTML resultante seja retornado ao spider para análise.

Antes de implementar esta solução, é importante notar que terá de instalar um controlador Web para interagir com um browser. Por exemplo, você precisará instalar o geckodriver para usar o Firefox com o Selenium. Assim que tiver um web driver instalado, pode então configurar o Selenium nas definições do seu projeto Scrapy:

SELENIUM_DRIVER_NAME = 'firefox'

SELENIUM_DRIVER_EXECUTABLE_PATH = which('geckodriver')

SELENIUM_DRIVER_ARGUMENTS=['-headless']  # '--headless' if using chrome instead of firefox

DOWNLOADER_MIDDLEWARES = {

    'scrapy_selenium.SeleniumMiddleware': 800

}

ITEM_PIPELINES = {

    'myproject.pipelines.SanitizePipeline': 1,

}

Em seguida, pode configurar a sua aranha:

import scrapy

from scrapy_selenium import SeleniumRequest

class RandomSpider(scrapy.Spider):

    name = 'random_spider'

    def start_requests(self):

        start_urls = [

        '<first_url',

        '<second_url>'

       ]

        for url in start_urls:

            yield SeleniumRequest(url=url, callback=self.parse)

    def parse(self, response):

            print(response.request.meta['driver'].title)

            #The request will be handled by selenium, and the request will have an additional meta key, named driver containing the selenium driver with the request processed.

       

            result = response.selector.css("#result::text").extract()

            #The selector response attribute work as usual (but contains the  html processed by the selenium driver).

         

            yield result

Para mais informações sobre os métodos e atributos do controlador disponíveis, consulte a documentação do selenium python:

http://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.remote.webdriver

O Selenium exige que um navegador da Web seja instalado na máquina em que está sendo executado, pois não é um navegador autônomo sem cabeça. Isso dificulta a implantação e a execução em várias máquinas ou em um ambiente de nuvem.

Como executar Javascript com Scrapy usando WebScrapingApi

A WebScrapingAPI fornece uma API que tratará de todo o trabalho pesado para si. Ela pode executar JavaScript, girar proxies e até mesmo lidar com CAPTCHAs, garantindo que você possa fazer scraping de sites com facilidade. Além disso, nunca terá de se preocupar com o facto de o seu IP ser banido por enviar demasiados pedidos. Para configurar o Scrappy para trabalhar com o WebScrapingAPI, vamos configurar um middleware proxy que encapsulará todas as solicitações de busca através do WSA.

Para conseguir isso, vamos configurar o Scrapy para se conectar ao servidor proxy WSA:

import base64

# add this to your middlewares.py file

class WSAProxyMiddleware:

    def process_request(self, request, spider):

        # Set the proxy for the request

        request.meta['proxy'] = "http://proxy.webscrapingapi.com:80"

        request.meta['verify'] = False

        # Set the proxy authentication for the request

        proxy_user_pass = "webscrapingapi.render_js=1:<API_KEY>"

        encoded_user_pass = base64.b64encode(proxy_user_pass.encode()).decode()

        request.headers['Proxy-Authorization'] = f'Basic {encoded_user_pass}'

E ativar o middleware:

DOWNLOADER_MIDDLEWARES = {

    'myproject.middlewares.WSAProxyMiddleware': 1,

}

webscrapingapi.render_js=1 is the proxy authentication username, <API_KEY> the password.

Pode obter uma API_KEY gratuita criando uma nova conta em https://www.webscrapingapi.com/

Ao especificar o parâmetro render_js=1, activará a capacidade do WebScrapingAPI de aceder à página Web visada utilizando um browser sem cabeça que permite que os elementos da página JavaScript sejam processados antes de lhe entregar o resultado final da recolha de dados.

Também pode dizer ao WSA para executar uma ação específica ao processar o seu URL. Para o efeito, pode especificar o parâmetro js_instructions:

js_instructions=[

{"action":"click","selector":"button#log-in-button"}

]

// this sequence could be used to click on a button

E já está, a WSA fará automaticamente todos os pedidos por si.

Concluir

A raspagem de sites dinâmicos pode ser uma tarefa difícil, mas com as ferramentas certas, torna-se muito mais fácil de gerir. Neste artigo, vimos três opções diferentes para raspar sites dinâmicos com o Scrapy. Navegadores sem cabeça, como o Splash e o Selenium, permitem executar JavaScript e renderizar páginas da Web como um navegador normal. No entanto, se quiser seguir o caminho mais fácil, usar uma API como WebScrapingApi também pode ser uma ótima solução. Esta trata de todas as tarefas complexas por si e permite-lhe extrair facilmente dados até dos sítios Web mais difíceis. Independentemente da opção que escolher, é importante ter em conta as suas necessidades específicas e escolher a solução que melhor se adapta ao seu projeto. Obrigado pela leitura e boa raspagem!