Como Construir um Scraper em Python com Proxies Rotativos e Boto3

Coletar dados de forma automatizada na web é um desafio que frequentemente esbarra em dois obstáculos críticos: políticas rígidas de taxa de requisições (rate limiting) e bloqueios geográficos ou de IP. À medida que os alvos de extração aumentam a segurança, a necessidade de distribuir requisições através de pools de proxies rotativos torna-se essencial.

No entanto, adicionar rotação de IPs e orquestração de nuvem com AWS Boto3 costuma gerar bases de código complexas e difíceis de manter. A solução não está em acumular bibliotecas externas pesadas, mas em desenhar um cliente enxuto, testável e de fácil transferência técnica (handoff).

Neste artigo, você aprenderá a estruturar um cliente de scraping em Python com proxies rotativos, integração Boto3 para nuvem e o padrão de execução dry-run usando apenas ferramentas nativas.

1. Arquitetura Modular e Código para Fácil Transferência

Em pipelines de engenharia de software, o conceito de “handoff limpo” significa que qualquer engenheiro deve ser capaz de clonar o repositório, ler o código e entender o fluxo em minutos.

Para isso, evite abstrações desnecessárias:

• Stdlib Logging: Utilize o módulo padrão logging em vez de bibliotecas terceiras de log. Ele permite modular níveis de severidade (DEBUG, INFO, ERROR) e redirecionar saídas para arquivos ou CloudWatch facilmente.
• Responsabilidade Única: Mantenha a rotação de proxies isolada da lógica de parsing do HTML/JSON.
• Testabilidade Pré-Deploy: O padrão dry-run garante que a lógica de orquestração e autenticação seja validada antes de disparar centenas de requisições que consomem banda e custos de proxy.

2. Implementando o Mecanismo de Rotação de Proxy

Um cliente resiliente deve iterar de maneira cíclica ou randômica sobre uma lista de proxies confiáveis e tratar falhas de conexão sem interromper o processo principal.

python
import itertools
import logging
import requests
from typing import Optional, List

logging.basicConfig(
level=logging.INFO,
format=”%(asctime)s [%(levelname)s] %(name)s: %(message)s”
)
logger = logging.getLogger(“ScraperClient”)

class RotatingProxyClient:
def init(self, proxypool: List[str], dryrun: bool = False):
self.proxypool = itertools.cycle(proxypool) if proxypool else None
self.dryrun = dry_run

def get_next_proxy(self) -> Optional[dict]:
    if not self.proxy_pool:
        return None
    proxy_url = next(self.proxy_pool)
    return {"http": proxy_url, "https": proxy_url}

def fetch(self, url: str) -> Optional[str]:
    proxy = self.get_next_proxy()

    if self.dry_run:
        logger.info(f"[DRY-RUN] Simulação de requisição para: {url} | Proxy: {proxy}")
        return "<html><body>Simulated Response</body></html>"

    try:
        logger.info(f"Executando GET em {url} via {proxy}")
        response = requests.get(url, proxies=proxy, timeout=10)
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        logger.error(f"Falha na requisição para {url} usando {proxy}: {e}")
        return None

O uso do modo dry_run permite que rotinas de CI/CD validem o fluxo sem realizar chamadas de rede externas nem onerar o provedor de proxy.

3. Integração com Nuvem via AWS Boto3

Em ambientes de produção, os proxies ou os dados resultantes da extração não devem ficar armazenados em arquivos locais estáticos. É aqui que entra o Boto3.

Como especialista em IA e engenharia de dados, costumo estruturar esses pipelines para buscar configurações seguras (como listas de credenciais de proxy) diretamente do AWS Systems Manager (SSM) Parameter Store ou Secrets Manager, salvando os resultados brutos no Amazon S3.

python
import boto3
from botocore.exceptions import ClientError

def loadproxiesfromssm(parametername: str, region: str = “us-east-1”) -> List[str]:
ssm = boto3.client(“ssm”, regionname=region)
try:
response = ssm.getparameter(Name=parametername, WithDecryption=True)
proxystring = response[“Parameter”][“Value”] return [p.strip() for p in proxy_string.split(“,”) if p.strip()] except ClientError as e:
logger.error(f”Erro ao obter proxies do SSM: {e}”)
return []

def savepayloadtos3(bucket: str, key: str, data: str, dryrun: bool = False):
if dry_run:
logger.info(f”[DRY-RUN] Salvamento em s3://{bucket}/{key} ignorado.”)
return

s3 = boto3.client("s3")
try:
    s3.put_object(Bucket=bucket, Key=key, Body=data.encode("utf-8"))
    logger.info(f"Objeto salvo com sucesso em s3://{bucket}/{key}")
except ClientError as e:
    logger.error(f"Erro ao gravar no S3: {e}")

4. Orquestrando o Fluxo de Execução com Parâmetros Limpos

A execução da ferramenta deve aceitar parâmetros diretos via linha de comando (argparse), viabilizando execuções pontuais ou agendadas via cron jobs, AWS Lambda ou ECS Tasks.

python
import argparse

def main():
parser = argparse.ArgumentParser(description=”Cliente de Coleta com Rotação de Proxy e Boto3″)
parser.addargument(“