Proxies são endereços IP de um servidor que se conectam à internet em seu nome. Em vez de transmitir suas requisições diretamente aos sites, os proxies as roteiam por meio de um servidor, ocultando seu endereço IP e localização originais. Isso protege sua privacidade, evita rastreamento e bloqueios. Os proxies também criptografam seus dados para maior segurança.

Neste artigo, você aprenderá sobre o uso de proxies com Python requests, especialmente para scraping de dados. O scraping de dados envolve a extração de dados de sites, mas muitos sites têm restrições. Os proxies ajudam a contornar essas restrições alterando seu IP e localização, dificultando a detecção e o bloqueio por parte dos sites. Você também pode usar múltiplos proxies para distribuir as requisições e acelerar o processo.

Em seguida, você aprenderá como implementar um proxy em seu projeto usando o pacote Python Requests.

Como Usar um Proxy com uma Python Request

Para usar um proxy com uma Python request, você precisa estabelecer um novo projeto Python em seu computador para escrever e executar os scripts Python para scraping de dados. Crie um diretório (ex web_scrape_project) onde você armazenará seus arquivos de código-fonte.

Todos os códigos deste tutorial estão disponíveis neste repositório do GitHub.

Instalar Pacotes

Após criar seu diretório, você precisa instalar os seguintes pacotes Python para enviar requisições à página web e coletar os links:

Página web da Bright Data

Componentes do Endereço IP do Proxy

Antes de usar um proxy, é importante entender seus componentes. A seguir estão os três componentes principais de um servidor proxy:

Protocolo indica o tipo de conteúdo que você pode acessar na internet. Os protocolos mais comuns são HTTP e HTTPS.
Endereço indica onde o servidor proxy está localizado. O endereço pode ser um IP (ex 192.167.0.1) ou um hostname DNS (ex proxyprovider.com).
Porta usada para direcionar o tráfego ao processo de servidor correto quando múltiplos serviços são executados em uma única máquina (ex número de porta 2000).

Usando esses três componentes, um endereço IP de proxy ficaria assim: 192.167.0.1:2000 ou proxyprovider.com:2000.

Como Definir Proxies Diretamente nas Requests

Existem várias formas de definir proxies em Python requests e, neste artigo, você verá três cenários diferentes. Neste primeiro exemplo, você aprenderá como definir proxies diretamente no módulo requests.

Para começar, você precisa importar os pacotes Requests e Beautiful Soup em seu arquivo Python para scraping de dados. Em seguida, crie um diretório chamado proxies que contém informações do servidor proxy para ocultar seu endereço IP ao fazer scraping da página web. Aqui, você deve definir tanto as conexões HTTP quanto HTTPS para a URL do proxy.

Você também precisa definir a variável Python para definir a URL da página web da qual deseja extrair dados. Para este tutorial, a URL é https://brightdata.com/

Em seguida, você precisa enviar uma requisição GET para a página web usando o método request.get(). O método recebe dois argumentos: a URL do site e os proxies. A resposta da página web é então armazenada na variável response.

Para coletar os links, use o pacote Beautiful Soup para fazer parsing do conteúdo HTML da página web, passando response.content e html.parser como argumentos para o método BeautifulSoup().

Em seguida, use o método find_all() com a como argumento para encontrar todos os links na página web. Por fim, extraia o atributo href de cada link usando o método get().

A seguir está o código-fonte completo para definir proxies diretamente nas requests:

# import packages.  
import requests  
from bs4 import BeautifulSoup  
  
# Define proxies to use.  
proxies = {  
    'http': 'http://proxyprovider.com:2000',  
    'https': 'http://proxyprovider.com:2000',  
}  
  
# Define a link to the web page.  
url = "https://brightdata.com/"  
  
# Send a GET request to the website.  
response = requests.get(url, proxies=proxies)  
  
# Use BeautifulSoup to parse the HTML content of the website.  
soup = BeautifulSoup(response.content, "html.parser")  
  
# Find all the links on the website.  
links = soup.find_all("a")  
  
# Print all the links.  
for link in links:  
    print(link.get("href"))

Quando você executa este bloco de código, ele envia uma requisição para a página web definida usando o endereço IP do proxy e retorna a resposta que contém todos os links daquela página web:

Como Definir Proxies via Variáveis de Ambiente

Às vezes, você precisa usar o mesmo proxy para todas as suas requisições a diferentes páginas web. Nesse caso, faz sentido definir variáveis de ambiente para o seu proxy.

Para tornar as variáveis de ambiente do proxy disponíveis sempre que você executar scripts no shell, execute o seguinte comando no seu terminal:

export HTTP_PROXY='http://proxyprovider.com:2000'  
export HTTPS_PROXY='https://proxyprovider.com:2000'

Aqui, a variável HTTP_PROXY define o servidor proxy para requisições HTTP, e a variável HTTPS_PROXY define o servidor proxy para requisições HTTPS.

Neste ponto, seu código Python tem poucas linhas de código e usa as variáveis de ambiente sempre que você faz uma requisição à página web:

# import packages.  
import requests  
from bs4 import BeautifulSoup  
  
# Define a link to the web page.  
url = "https://brightdata.com/"  
  
# Send a GET request to the website.  
response = requests.get(url)  
  
# Use BeautifulSoup to parse the HTML content of the website.  
soup = BeautifulSoup(response.content, "html.parser")  
  
# Find all the links on the website.  
links = soup.find_all("a")  
  
# Print all the links.  
for link in links:  
    print(link.get("href"))

Como Rotacionar Proxies Usando um Método Personalizado e um Array de Proxies

Rotacionar proxies é fundamental porque os sites frequentemente bloqueiam ou restringem o acesso a bots e scrapers quando recebem um grande número de requisições do mesmo endereço IP. Quando isso acontece, os sites podem suspeitar de atividade maliciosa de scraping e, consequentemente, implementar medidas para bloquear ou limitar o acesso.

Ao rotacionar entre diferentes endereços IP de proxy, você pode evitar ser detectado, aparecer como múltiplos usuários orgânicos e contornar a maioria das medidas anti-scraping implementadas no site.

Para rotacionar proxies, você precisa importar algumas bibliotecas Python: Requests, Beautiful Soup e Random.

Em seguida, crie uma lista de proxies para usar durante o processo de rotação. Esta lista deve conter as URLs dos servidores proxy neste formato: http://proxyserver.com:porta:

# List of proxies  
proxies = [  
    "http://proxyprovider1.com:2010", "http://proxyprovider1.com:2020",  
    "http://proxyprovider1.com:2030", "http://proxyprovider2.com:2040",  
    "http://proxyprovider2.com:2050", "http://proxyprovider2.com:2060",  
    "http://proxyprovider3.com:2070", "http://proxyprovider3.com:2080",  
    "http://proxyprovider3.com:2090"  
]

Em seguida, crie um método personalizado chamado get_proxy(). Este método seleciona aleatoriamente um proxy da lista de proxies usando o método random.choice() e retorna o proxy selecionado em formato de dicionário (com as chaves HTTP e HTTPS). Você usará este método sempre que enviar uma nova requisição:

# Custom method to rotate proxies  
def get_proxy():  
    # Choose a random proxy from the list  
    proxy = random.choice(proxies)  
    # Return a dictionary with the proxy for both http and https protocols  
    return {'http': proxy, 'https': proxy}

Depois de criar o método get_proxy(), você precisa criar um loop que envia um certo número de requisições GET usando os proxies rotacionados. Em cada requisição, o método get() usa um proxy escolhido aleatoriamente especificado pelo método get_proxy().

Em seguida, você precisa coletar os links do conteúdo HTML da página web usando o pacote Beautiful Soup, conforme explicado no primeiro exemplo.

Por fim, o código Python captura quaisquer exceções que ocorram durante o processo de requisição e imprime a mensagem de erro no console.

Aqui está o código-fonte completo para este exemplo:

# import packages  
import requests  
from bs4 import BeautifulSoup  
import random  
  
# List of proxies  
proxies = [  
    "http://proxyprovider1.com:2010", "http://proxyprovider1.com:2020",  
    "http://proxyprovider1.com:2030", "http://proxyprovider2.com:2040",  
    "http://proxyprovider2.com:2050", "http://proxyprovider2.com:2060",  
    "http://proxyprovider3.com:2070", "http://proxyprovider3.com:2080",  
    "http://proxyprovider3.com:2090"  
]

  
# Custom method to rotate proxies  
def get_proxy():  
    # Choose a random proxy from the list  
    proxy = random.choice(proxies)  
    # Return a dictionary with the proxy for both http and https protocols  
    return {'http': proxy, 'https': proxy}  
  
  
# Send requests using rotated proxies  
for i in range(10):  
    # Set the URL to scrape  
    url = 'https://brightdata.com/'  
    try:  
        # Send a GET request with a randomly chosen proxy  
        response = requests.get(url, proxies=get_proxy())  
  
        # Use BeautifulSoup to parse the HTML content of the website.  
        soup = BeautifulSoup(response.content, "html.parser")  
  
        # Find all the links on the website.  
        links = soup.find_all("a")  
  
        # Print all the links.  
        for link in links:  
            print(link.get("href"))  
    except requests.exceptions.RequestException as e:  
        # Handle any exceptions that may occur during the request  
        print(e)

Usando o Serviço de Proxy da Bright Data com Python

Se você está procurando um proxy confiável, rápido e estável para suas tarefas de scraping de dados, não procure mais além da Bright Data, uma infraestrutura de dados web que oferece diferentes tipos de proxies para uma ampla variedade de casos de uso.

A Bright Data possui uma grande rede de mais de 400M+ monthly IPs de proxies residenciais e mais de 770.000 proxies de datacenter que ajudam a fornecer soluções de proxy confiáveis e rápidas. Suas ofertas de proxy são projetadas para ajudá-lo a superar os desafios de scraping de dados, verificação de anúncios e outras atividades online que exigem coleta de dados web anônima e eficiente.

Integrar os proxies da Bright Data em suas Python requests é fácil. Por exemplo, use os Proxies de datacenter para enviar uma requisição à URL usada nos exemplos anteriores.

Se você ainda não tem uma conta, cadastre-se para um teste gratuito da Bright Data e adicione seus dados para registrar sua conta.

Depois de concluir, siga estas etapas para criar seu primeiro proxy:

Clique em Ver produto proxy na página de boas-vindas para visualizar os diferentes tipos de proxy oferecidos pela Bright Data:

Selecione Proxies de Datacenter para criar um novo proxy e, na página seguinte, adicione seus dados e salve:

Depois que seu proxy for criado, você pode visualizar os parâmetros importantes (ex host, porta, nome de usuário e senha) para começar a acessá-lo e utilizá-lo:

Tela de Parâmetros de Acesso do Datacenter para configuração de proxy.

Depois de acessar seu proxy, você pode usar as informações dos parâmetros para configurar a URL do proxy e enviar uma requisição usando o pacote Python Requests. O formato da URL do proxy é username-(session-id)-password@host:port.

Nota: O session-id é um número aleatório criado usando um pacote Python chamado random.

A seguir está como ficaria seu exemplo de código para definir seu proxy da Bright Data em uma Python request:

import requests  
from bs4 import BeautifulSoup  
import random  
  
# Define parameters provided by Brightdata  
host = 'brd.superproxy.io'  
port = 33335  
username = 'username'  
password = 'password'  
session_id = random.random()  
  
# format your proxy  
proxy_url = ('http://{}-session-{}:{}@{}:{}'.format(username, session_id,  
                                                     password, host, port))  
  
# define your proxies in dictionary  
proxies = {'http': proxy_url, 'https': proxy_url}  
  
# Send a GET request to the website  
url = "https://brightdata.com/"  
response = requests.get(url, proxies=proxies)  
  
# Use BeautifulSoup to parse the HTML content of the website  
soup = BeautifulSoup(response.content, "html.parser")  
  
# Find all the links on the website  
links = soup.find_all("a")  
  
# Print all the links  
for link in links:  
    print(link.get("href"))

Aqui, você importa os pacotes e define as variáveis de host, porta, nome de usuário, senha e session_id do proxy. Em seguida, cria um dicionário proxies com as chaves http e https e as credenciais do proxy. Por fim, você passa o parâmetro proxies para a função requests.get() para fazer a requisição HTTP e coletar os links da URL.

E é isso! Você acabou de fazer uma requisição bem-sucedida usando o serviço de proxy da Bright Data.

Conclusão

Neste artigo, você aprendeu por que precisa de proxies, bem como as diferentes formas de usá-los para enviar uma requisição a uma página web usando o pacote Python Requests.

Com a infraestrutura web da Bright Data, você pode obter proxies confiáveis para seu projeto que cobrem qualquer país ou cidade do mundo. Eles oferecem múltiplas formas de obter os dados necessários por meio de vários tipos de proxies e ferramentas para scraping de dados para atender às suas necessidades específicas.

Seja para coletar dados de pesquisa de mercado, monitorar avaliações online ou rastrear preços de concorrentes, a Bright Data tem os recursos necessários para realizar o trabalho de forma rápida e eficiente.

Teste grátis Registro no Google