Os rastreadores web não se resumem apenas ao envio de solicitações HTTP – eles precisam lidar com renderização de JavaScript, defesas anti-bot, escalabilidade e tratamento de erros. Neste artigo, vamos abordar os erros comuns que os desenvolvedores enfrentam ao construir rastreadores e fornecer soluções práticas com trechos de código.

1. Ignorando Robots.txt e Políticas de Rastreamento

Se o seu rastreador ignora robots.txt, você corre o risco de enfrentar problemas legais ou bloqueios de IP.

Prática ruim:

import requests

html = requests.get("https://example.com").text
# Sem verificação de robots.txt

Abordagem melhor:

import urllib.robotparser

rp = urllib.robotparser.RobotFileParser()
rp.set_url("https://example.com/robots.txt")
rp.read()

if rp.can_fetch("*", "https://example.com/page"):
    print("Permitido rastrear")
else:
    print("Proibido por robots.txt")

✅ Sempre respeite as políticas de rastreamento e implemente limites de taxa.

2. Rastreamento Muito Agressivo

Enviar milhares de solicitações por segundo é uma maneira rápida de ser banido.

Solução:

• Adicione atrasos
• Use rastreamento assíncrono para eficiência

import asyncio, aiohttp, random

async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.text()

async def main():
    urls = ["https://example.com/page1", "https://example.com/page2"]
    async with aiohttp.ClientSession() as session:
        for url in urls:
            html = await fetch(session, url)
            print(len(html))
            await asyncio.sleep(random.uniform(1, 3))  # atraso educado

asyncio.run(main())

3. Manipulação de Conteúdo Renderizado em JavaScript

Rastreadores estáticos perdem páginas com muito JS (React, Vue, Angular).

Solução: Use um navegador sem cabeça (por exemplo, Playwright, Puppeteer).

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://quotes.toscrape.com/js/")
    print(page.content())  # agora inclui conteúdo renderizado em JS
    browser.close()

4. Extração de Dados Ineficiente

Codificar seletores frágeis leva a rastreadores quebrados.

Abordagem melhor com BeautifulSoup + alternativas:

from bs4 import BeautifulSoup

html = "<div><h1 class='title'>Olá</h1></div>"
soup = BeautifulSoup(html, "lxml")

# Seletor primário
title = soup.select_one("h1.title")

# Alternativa
if not title:
    title = soup.find("h1")

print(title.text)

5. Coleta de Conteúdo Duplicado

URLs como /page?id=123&session=abc podem causar duplicatas.

Solução: Normalizar URLs

from urllib.parse import urlparse, urlunparse

def normalize(url):
    parsed = urlparse(url)
    clean = parsed._replace(query="")
    return urlunparse(clean)

print(normalize("https://example.com/page?id=1&session=xyz"))
# -> https://example.com/page

6. Bloqueio de IP e Mecanismos Anti-Bot

Os sites detectam bots com anomalias de taxa, impressões digitais e CAPTCHAs.

Rotação básica com Scrapy:

class RotateUserAgentMiddleware:
    user_agents = [
        "Mozilla/5.0 ...",
        "Chrome/91.0 ...",
        "Safari/537.36 ..."
    ]

    def process_request(self, request, spider):
        import random
        request.headers['User-Agent'] = random.choice(self.user_agents)

Pilha de soluções:

• Rode proxies e agentes de usuário
• Use proxies residenciais/móveis
• Integre solucionadores de CAPTCHA quando necessário

7. Tratamento de Erros

Erros de rede são inevitáveis. Sem tentativas, os rastreadores falham silenciosamente.

Exemplo com tentativas:

import requests, time

def fetch(url, retries=3):
    for i in range(retries):
        try:
            return requests.get(url, timeout=5)
        except requests.exceptions.RequestException as e:
            print(f"Erro: {e}, tentando novamente {i+1}")
            time.sleep(2**i)
    return None

8. Desafios de Escalabilidade

Um rastreador que funciona para 1.000 páginas pode falhar em 10M.

Exemplo de rastreamento distribuído com Scrapy + Redis:

scrapy runspider crawler.py -s JOBDIR=crawls/job1

Use:

• Redis/Kafka para filas de tarefas distribuídas
• Scrapy Cluster / Nutch para escalabilidade
• Armazenamento em nuvem para resultados de rastreamento

9. Problemas de Qualidade de Dados

Os dados rastreados podem conter duplicatas, campos vazios ou formatos inválidos.

Solução: Validação de esquema

from pydantic import BaseModel, ValidationError

class Product(BaseModel):
    name: str
    price: float

try:
    item = Product(name="Laptop", price="not a number")
except ValidationError as e:
    print(e)

10. Segurança e Conformidade

Os rastreadores devem evitar a extração de PII ou dados restritos. Sempre verifique a conformidade com GDPR/CCPA antes de armazenar dados do usuário.

Conclusão

Construir um rastreador robusto requer precisão técnica e responsabilidade ética. Ao abordar erros como rastreamento agressivo, renderização de JavaScript, defesas anti-bot e escalabilidade, os desenvolvedores podem projetar rastreadores que são:

• Eficiente (uso otimizado de recursos)
• Resiliente (tolerante a erros)
• Conforme (legal e ético)