Scrapy+proxies DI: uma dupla poderosa para web scraping eficaz

DI logo and Scrapy logo

A necessidade de acelerar o web scraping e, ao mesmo tempo, evitar acionar sistemas anti-bot exige ferramentas de scraping eficientes. O Scrapy é uma das mais usadas. Continue lendo para saber por que ele merece sua atenção e como usá-lo com eficácia.

O que é Scrapy e quais vantagens ele oferece?

O Scrapy é um framework de rastreamento web de código aberto em Python. Sua popularidade tem bons motivos, pois suas vantagens incluem:

  • capacidade de processar vários requests simultaneamente, para que o web scraping leve menos tempo
  • não há necessidade de manter código
  • adequado para projetos de grande escala
  • permite personalizar o tratamento de requests e responses, como adicionar rotação de user-agent, lidar com novas tentativas e gerenciar proxies
  • funciona bem com sites ricos em JavaScript e oferece recursos como request delay e auto-throttling para evitar sobrecarregar servidores 
  • tem um item pipeline integrado, permitindo extrair, armazenar e salvar dados em vários formatos, como JSON, CSV e XML
  • vem com seletores CSS e expressões XPath, permitindo extrair com precisão os elementos HTML necessários 

Para conhecer todos os recursos do Scrapy, visite sua documentação oficial. Neste artigo, vamos nos concentrar em como usar o Scrapy. Vamos visitar nosso blog e extrair todos os títulos dos artigos para mostrar como a ferramenta funciona. 

Como o web scraping traz risco de bloqueios, usar ferramentas de rastreamento junto com proxies não é novidade. Neste tutorial, mostraremos como instalar e personalizar o Scrapy e como implementar proxies. 

Preparação 

Antes de começar, confirme que você tem todos os programas e ferramentas necessários. Para este tutorial, precisamos de: 

  • Visual Studio Code (ou qualquer outra IDE compatível com Python) 
  • Python (versão 3.10.0 no nosso caso)
  • pip (usamos a versão 25.0.1)

Você pode baixar o VS Code aqui e instalar o Python a partir de seu site oficial. Se você não tiver pip (ele é incluído automaticamente no Python versão 3.4 e posteriores), abra o Bloco de Notas e salve este código em um arquivo get-pip.py:


import urllib.request
import os
import sys

try:
    # download get-pip.py
    url = "https://bootstrap.pypa.io/get-pip.py"
    urllib.request.urlretrieve(url, "get-pip.py")

    # install pip
    os.system(f"{sys.executable} get-pip.py")
finally:
    # remove the script
    if os.path.exists("get-pip.py"):
        os.remove("get-pip.py")

Em seguida, abra o prompt de comando e navegue até a pasta onde você salvou o arquivo:


cd path/to/your/file

Por exemplo, salvamos o arquivo na pasta Documents, então nosso comando ficaria como cd/Documents.

Em seguida, execute o seguinte comando:


python get-pip.py

Para verificar se o pip está funcionando bem, use este comando:


pip --version

Agora que você tem tudo pronto, vamos começar.

Instalando o Scrapy e iniciando um projeto

Primeiro, precisamos instalar o Scrapy. Para isso, abra o prompt de comando (ou faça isso no terminal do VS Code) e execute o seguinte comando:


pip install Scrapy

Observação: se você instalou todas as ferramentas necessárias, mas continua vendo o aviso “The term pip isn’t recognized as a name of cmdlet, function, script file, or operable program” ou outros erros no terminal do VS Code, tente ajustar as configurações do VS Code. Vá para Terminal>Integrated: Default Profile (você pode digitar terminal integrated na barra de pesquisa), altere o perfil padrão para o prompt de comando e reinicie o VS Code para ativar as novas configurações.

Para iniciar um projeto, navegue até a pasta do seu projeto no terminal do VS Code. No nosso caso, a pasta se chama Project S e fica na pasta Documents, então digitamos cd Documents/Project S.

Depois, digite este comando:


scrapy startproject your_project_name

Certifique-se de substituir your_project_name por um nome real. Por exemplo, usamos dataimpulse_blog.

Em seguida, navegue até a pasta do projeto:


cd your_project_name

Quando estiver lá, use este comando para criar um spider:


scrapy genspider your_spider_name url_domain

No nosso caso, o comando é este scrapy genspider blog_titles dataimpulse.com

Ajustando o código

Ao abrir a pasta do projeto no VS Code ou pelo Explorador de Arquivos, você verá vários arquivos Python ali. Precisamos modificá-los para extrair os dados necessários.

Primeiro, na pasta “spiders” abra blog_titles.py e substitua o código existente por este:


import scrapy


class BlogTitlesSpider(scrapy.Spider):
    name = 'blog_titles'
    allowed_domains = ['dataimpulse.com']
    start_urls = ['https://dataimpulse.com/blog/']
    def parse(self, response):
        self.logger.info(f"Visited {response.url}")

       
        titles = response.css('h3.blog-title a::text').getall()
        for title in titles:
            yield {'title': title.strip()}

       
        next_page = response.css('a.next::attr(href)').get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Aqui, você define a página que precisa extrair e os dados que deseja coletar (títulos, neste caso). Você também modifica o método parse.

Em seguida, abra middlewares.py e cole ali o seguinte trecho de código:


# Define here the models for your spider middleware
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/spider-middleware.html

from scrapy import signals

# useful for handling different item types with a single interface
from itemadapter import is_item, ItemAdapter


class BlogscraperSpiderMiddleware:
    # Not all methods need to be defined. If a method is not defined,
    # scrapy acts as if the spider middleware does not modify the
    # passed objects.

    @classmethod
    def from_crawler(cls, crawler):
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_spider_input(self, response, spider):
        # Called for each response that goes through the spider
        # middleware and into the spider.

        # Should return None or raise an exception.
        return None

    def process_spider_output(self, response, result, spider):
        # Called with the results returned from the Spider, after
        # it has processed the response.

        # Must return an iterable of Request, or item objects.
        for i in result:
            yield i

    def process_spider_exception(self, response, exception, spider):
        # Called when a spider or process_spider_input() method
        # (from other spider middleware) raises an exception.

        # Should return either None or an iterable of Request or item objects.
        pass
    
    def process_start_requests(self, start_requests, spider):
        # Called with the start requests of the spider, and works
        # similarly to the process_spider_output() method, except
        # that it doesn’t have a response associated.

        # Must return only requests (not items).
        for r in start_requests:
            yield r

    def spider_opened(self, spider):
        spider.logger.info("Spider opened: %s" % spider.name)


class BlogscraperDownloaderMiddleware:
    # Not all methods need to be defined. If a method is not defined,
    # scrapy acts as if the downloader middleware does not modify the
    # passed objects.

    @classmethod
    def from_crawler(cls, crawler):
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)
        return s

    def process_request(self, request, spider):
        # Called for each request that goes through the downloader
        # middleware.

        # Must either:
        # - return None: continue processing this request
        # - or return a Response object
        # - or return a Request object
        # - or raise IgnoreRequest: process_exception() methods of
        #   installed downloader middleware will be called
        request.meta['proxy'] = spider.settings.get('http://login:password@hostname:port')

    def process_response(self, request, response, spider):
        # Called with the response returned from the downloader.

        # Must either;
        # - return a Response object
        # - return a Request object
        # - or raise IgnoreRequest
        return response

    def process_exception(self, request, exception, spider):
        # Called when a download handler or a process_request()
        # (from other downloader middleware) raises an exception.

        # Must either:
        # - return None: continue processing this exception
        # - return a Response object: stops process_exception() chain
        # - return a Request object: stops process_exception() chain
        pass

    def spider_opened(self, spider):
        spider.logger.info("Spider opened: %s" % spider.name)

Preste atenção à linha 81. Aqui, você precisa digitar suas credenciais reais no formato http://login:password@hostname:port Para obtê-las, vá até o plano de proxy necessário no painel da DataImpulse. Não se esqueça de alterar o formato do seu proxy no canto inferior direito. Se tiver dificuldades, use nossa guia sobre como gerenciar sua conta DataImpulse.

Por fim, vá para settings.py e confira se ele fica assim:


# Scrapy settings for blogscraper project
#
# For simplicity, this file contains only settings considered important or
# commonly used. You can find more settings consulting the documentation:
#
#     https://docs.scrapy.org/en/latest/topics/settings.html
#     https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
#     https://docs.scrapy.org/en/latest/topics/spider-middleware.html

BOT_NAME = "dataimpulse_blog"

SPIDER_MODULES = ["dataimpulse_blog.spiders"]
NEWSPIDER_MODULE = "dataimpulse_blog.spiders"


# Crawl responsibly by identifying yourself (and your website) on the user-agent
#USER_AGENT = "blogscraper (+http://www.yourdomain.com)"

# Obey robots.txt rules
ROBOTSTXT_OBEY = True

# Enable the downloader middlewares
DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 110,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'dataimpulse_blog.middlewares.BlogscraperSpiderMiddleware': 543,  # Add your ProxyMiddleware here
}

# Configure maximum concurrent requests performed by Scrapy (default: 16)
#CONCURRENT_REQUESTS = 32

# Configure a delay for requests for the same website (default: 0)
# See https://docs.scrapy.org/en/latest/topics/settings.html#download-delay
# See also autothrottle settings and docs
#DOWNLOAD_DELAY = 3
# The download delay setting will honor only one of:
#CONCURRENT_REQUESTS_PER_DOMAIN = 16
#CONCURRENT_REQUESTS_PER_IP = 16

# Disable cookies (enabled by default)
#COOKIES_ENABLED = False

# Disable Telnet Console (enabled by default)
#TELNETCONSOLE_ENABLED = False

# Override the default request headers:
#DEFAULT_REQUEST_HEADERS = {
#    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
#    "Accept-Language": "en",
#}

# Enable or disable spider middlewares
# See https://docs.scrapy.org/en/latest/topics/spider-middleware.html
#SPIDER_MIDDLEWARES = {
#    "blogscraper.middlewares.BlogscraperSpiderMiddleware": 543,
#}

# Enable or disable downloader middlewares
# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html
#DOWNLOADER_MIDDLEWARES = {
#    "blogscraper.middlewares.BlogscraperDownloaderMiddleware": 543,
#}

# Enable or disable extensions
# See https://docs.scrapy.org/en/latest/topics/extensions.html
#EXTENSIONS = {
#    "scrapy.extensions.telnet.TelnetConsole": None,
#}

# Configure item pipelines
# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html
#ITEM_PIPELINES = {
#    "blogscraper.pipelines.BlogscraperPipeline": 300,
#}

# Enable and configure the AutoThrottle extension (disabled by default)
# See https://docs.scrapy.org/en/latest/topics/autothrottle.html
#AUTOTHROTTLE_ENABLED = True
# The initial download delay
#AUTOTHROTTLE_START_DELAY = 5
# The maximum download delay to be set in case of high latencies
#AUTOTHROTTLE_MAX_DELAY = 60
# The average number of requests Scrapy should be sending in parallel to
# each remote server
#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0
# Enable showing throttling stats for every response received:
#AUTOTHROTTLE_DEBUG = False

# Enable and configure HTTP caching (disabled by default)
# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings
#HTTPCACHE_ENABLED = True
#HTTPCACHE_EXPIRATION_SECS = 0
#HTTPCACHE_DIR = "httpcache"
#HTTPCACHE_IGNORE_HTTP_CODES = []
#HTTPCACHE_STORAGE = "scrapy.extensions.httpcache.FilesystemCacheStorage"

# Set settings whose default value is deprecated to a future-proof value
REQUEST_FINGERPRINTER_IMPLEMENTATION = "2.7"
TWISTED_REACTOR = "twisted.internet.asyncioreactor.AsyncioSelectorReactor"
FEED_EXPORT_ENCODING = "utf-8"

Aqui, você habilita o middleware e ajusta outros parâmetros como cache, cookies, pipelines, etc.

Agora vem o passo mais importante. Abra o Terminal e digite cd para garantir que você está no diretório raiz do seu projeto (dataimpulse_blog no nosso caso; você precisa procurar uma pasta que contenha o arquivo scrapy.cfg , esse é o diretório raiz). Depois, use o seguinte comando:


scrapy crawl blog_titles -o titles.json

Isso executará seu spider e salvará todos os resultados em um arquivo chamado titles.json. Você pode conferir os resultados abrindo o arquivo diretamente no VS Code. Este foi o resultado que obtivemos:

Scraping results
Scraping results

Pronto! Como você pode ver, o Scrapy é fácil de usar. Você pode ajustar os detalhes necessários e aproveitar proxies para obter os melhores resultados. Claro, a escolha dos proxies também é essencial. A DataImpulse oferece proxies residenciais, de data center e móveis de origem legal em um modelo de preços pay-as-you-go. Você tem IPs em whitelist para necessidades universais sem estourar o orçamento. Comece conosco clicando no botão “Experimente agora” ou escrevendo para nós em [email protected].

Share article: