Usando proxy em Python com a biblioteca requests

Um proxy HTTP é um servidor intermediário que funciona como gateway entre você e a internet. Ao usar um proxy, suas requisições passam primeiro pelo servidor proxy antes de chegar ao servidor de destino. Isso oculta seu endereço IP e pode servir a diversos objetivos, como contornar restrições geográficas, fazer web scraping e reforçar a segurança. A biblioteca requests do Python torna simples o uso de proxies nas suas requisições HTTP.

Por que usar proxies com a biblioteca requests?

Há vários motivos importantes para usar proxies com a biblioteca requests:

• Anonimato: Os proxies mascaram seu endereço IP, dificultando o rastreamento das suas atividades online.
• Contornar restrições geográficas: Acesse conteúdo restrito a determinadas regiões usando um servidor proxy localizado nessa região.
• Web scraping: Evite ser bloqueado ao coletar dados de sites fazendo rotação entre diferentes servidores proxy. Muitos sites aplicam rate limiting ou bloqueio de IP para impedir o abuso dos seus dados.
• Balanceamento de carga: Distribua requisições entre vários servidores para melhorar desempenho e confiabilidade.
• Segurança: Os proxies acrescentam uma camada extra de segurança ao atuar como buffer entre seu computador e a internet. Também podem filtrar conteúdo malicioso.
• Testes: Simule o acesso de usuários de diferentes localizações para fins de teste.

Configurando proxies no requests

A biblioteca requests oferece uma forma simples de configurar proxies por meio do parâmetro proxies nas funções de requisição (get, post, put, delete etc.). O parâmetro proxies recebe um dicionário em que as chaves são os protocolos (por exemplo, 'http', 'https') e os valores são as URLs do proxy.

Configuração básica de proxy

Veja um exemplo básico de como usar um proxy com a biblioteca requests:

import requests

proxies = {
  'http': 'http://your_proxy_address:port',
  'https': 'https://your_proxy_address:port',
}

try:
    response = requests.get('https://www.example.com', proxies=proxies)
    response.raise_for_status() # Levanta HTTPError em respostas com erro (4xx ou 5xx)
    print(response.status_code)
    print(response.text)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Substitua your_proxy_address e port pelo endereço e pela porta reais do seu servidor proxy. O método raise_for_status() é essencial para o tratamento de erros: ele lança uma exceção se o código de status HTTP indicar erro (por exemplo, 404 Not Found, 500 Internal Server Error).

Usando proxies diferentes para HTTP e HTTPS

Você também pode especificar proxies diferentes para tráfego HTTP e HTTPS:

import requests

proxies = {
  'http': 'http://http_proxy_address:port',
  'https': 'https://https_proxy_address:port',
}

try:
    response = requests.get('https://www.example.com', proxies=proxies)
    response.raise_for_status()
    print(response.status_code)
    print(response.text)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Autenticação no proxy

Muitos servidores proxy exigem autenticação. Você pode incluir usuário e senha na URL do proxy:

import requests

proxies = {
  'http': 'http://username:password@your_proxy_address:port',
  'https': 'https://username:password@your_proxy_address:port',
}

try:
    response = requests.get('https://www.example.com', proxies=proxies)
    response.raise_for_status()
    print(response.status_code)
    print(response.text)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Como alternativa, você pode usar o módulo requests.auth para esquemas de autenticação mais complexos. Porém, para autenticação básica com usuário e senha, embutir as credenciais na URL costuma ser suficiente.

Proxies SOCKS

A biblioteca requests suporta proxies SOCKS, mas é preciso instalar o extra requests[socks].

pip install requests[socks]

Depois de instalado, você pode usar proxies SOCKS assim:

import requests

proxies = {
  'http': 'socks5://user:pass@host:port',
  'https': 'socks5://user:pass@host:port'
}

try:
    response = requests.get('https://www.example.com', proxies=proxies)
    response.raise_for_status()
    print(response.status_code)
    print(response.text)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

Você pode usar os esquemas socks4 ou socks5. Se o seu proxy SOCKS não exigir usuário/senha, basta omiti-los da URL (por exemplo, 'socks5://host:port').

Comparação de tipos de proxy

Veja uma comparação entre os diferentes tipos de proxy:

Rotação de proxies para web scraping

Em web scraping, fazer rotação entre vários proxies é essencial para não ter seu endereço IP bloqueado. Veja como implementar a rotação de proxies:

import requests
import random

proxy_list = [
  'http://user1:[email protected]:8000',
  'http://user2:[email protected]:8001',
  'http://user3:[email protected]:8002',
]

def get_page(url):
    proxy = random.choice(proxy_list)
    proxies = {'http': proxy, 'https': proxy}
    try:
        response = requests.get(url, proxies=proxies, timeout=10)  # Adiciona timeout
        response.raise_for_status()
        return response.text
    except requests.exceptions.RequestException as e:
        print(f"Error using proxy {proxy}: {e}")
        return None

url = 'https://www.example.com'
content = get_page(url)

if content:
    print("Successfully retrieved content.")
    # Processe o conteúdo aqui
else:
    print("Failed to retrieve content.")

Neste exemplo:

• Mantém-se uma lista de servidores proxy.
• A função random.choice() escolhe um proxy aleatório da lista a cada requisição.
• Um timeout é adicionado à função requests.get() para evitar que o script fique travado indefinidamente se um proxy não responder.
• O tratamento de erros é implementado para capturar exceções e tentar novamente com um proxy diferente.

Lembre-se de tratar os erros com cuidado e implementar lógica de retry com proxies diferentes quando uma requisição falhar. Para projetos de scraping em larga escala, considere usar uma biblioteca mais robusta de gerenciamento de proxies.

Problemas comuns e troubleshooting

• Erros de autenticação no proxy: Confira usuário e senha. Certifique-se de que estão corretamente codificados na URL do proxy.
• Erros de conexão: Verifique se o servidor proxy está ativo e acessível a partir da sua rede. Cheque as configurações de firewall.
• Timeouts: Aumente o valor de timeout na função requests.get(). O timeout padrão pode ser curto demais para alguns servidores proxy.
• Requisições bloqueadas: O site de destino pode estar bloqueando o IP do servidor proxy. Tente outro proxy ou uma lista de proxies rotativos.
• Erros de proxy SOCKS: Confirme que você instalou o extra requests[socks]. Verifique se o servidor proxy SOCKS está configurado corretamente.

Conclusão

Usar proxies com a biblioteca requests do Python é uma técnica poderosa para diversas tarefas, incluindo web scraping, acesso a conteúdo com restrição geográfica e reforço de segurança. Entendendo como configurar proxies, tratar autenticação e implementar rotação, você aproveita os proxies de forma eficaz nas suas aplicações Python. Lembre-se de tratar os erros com cuidado e escolher o tipo de proxy adequado às suas necessidades.