Configuração de proxy no Playwright

O Playwright permite configurar proxy em scripts Python e Node.js principalmente pelas opções de browserType.launch() ou browser.newContext(), possibilitando especificar endereço do servidor proxy, porta e credenciais de autenticação. Essa configuração direciona todas as requisições de rede subsequentes da instância de navegador ou do contexto lançado através do proxy especificado.

Visão geral da configuração de proxy no Playwright

O Playwright suporta configurações de proxy em dois níveis principais:

1. Nível de inicialização do navegador: aplica um proxy a toda a instância do navegador. Todos os contextos e páginas criados dentro desse navegador vão usar o proxy especificado. É adequado quando todas as tarefas de automação exigem o mesmo proxy.
2. Nível de contexto do navegador: aplica um proxy a um contexto específico. Isso permite que contextos diferentes na mesma instância usem proxies diferentes, ou que alguns contextos não usem proxy nenhum, o que é útil para gerenciar cenários variados de scraping ou de testes.

O objeto (ou dicionário) de configuração de proxy do Playwright normalmente inclui o endereço server (por exemplo, http://proxy.example.com:8080, socks5://localhost:9050) e, opcionalmente, username e password para proxies autenticados.

Tipos de proxy suportados

O Playwright suporta os protocolos de proxy padrão:

• Proxies HTTP: especificados com os esquemas http:// ou https://.
• Proxies SOCKS: especificados com os esquemas socks5:// ou socks4://.

Quando o esquema é omitido (por exemplo, proxy.example.com:8080), o Playwright assume um proxy HTTP por padrão. Especificar o esquema explicitamente é recomendado para maior clareza e para garantir que o protocolo correto seja usado.

Configuração de proxy no Playwright com Python

Em Python, a configuração de proxy é passada como um dicionário no argumento proxy de browser_type.launch() ou browser.new_context().

Configuração básica de proxy HTTP/HTTPS

Para usar um proxy HTTP ou HTTPS sem autenticação:

from playwright.sync_api import sync_playwright

# For browser-wide proxy
with sync_playwright() as p:
    browser = p.chromium.launch(proxy={"server": "http://your.proxy.server:8080"})
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

# For context-specific proxy
with sync_playwright() as p:
    browser = p.chromium.launch()
    context = browser.new_context(proxy={"server": "http://another.proxy.server:8080"})
    page = context.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    context.close()
    browser.close()

Configuração de proxy HTTP/HTTPS autenticado

Para proxies que exigem autenticação, inclua as chaves username e password no dicionário do proxy:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://user.proxy.server:8080",
            "username": "proxy_user",
            "password": "proxy_password"
        }
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

Configuração de proxy SOCKS

Especifique o protocolo SOCKS na string server:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={"server": "socks5://your.socks.proxy:9050"}
    )
    page = browser.new_page()
    page.goto("https://httpbin.org/ip")
    print(page.content())
    browser.close()

Proxies SOCKS também suportam autenticação por meio das chaves username e password no dicionário.

Ignorando o proxy para domínios específicos

A chave bypass no dicionário do proxy permite especificar uma lista de hosts ou domínios separados por vírgula que não devem usar o proxy. Curingas (*) são suportados.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={
            "server": "http://your.proxy.server:8080",
            "bypass": "*.local, .example.com, 192.168.1.1"
        }
    )
    page = browser.new_page()
    page.goto("http://example.com") # Vai ignorar o proxy se example.com estiver na lista de bypass
    page.goto("https://google.com") # Vai usar o proxy
    browser.close()

Configuração de proxy no Playwright com Node.js

Em Node.js, a configuração de proxy é passada como um objeto na propriedade proxy de browserType.launch() ou browser.newContext().

Configuração básica de proxy HTTP/HTTPS

Para usar um proxy HTTP ou HTTPS sem autenticação:

const { chromium } = require('playwright');

(async () => {
  // For browser-wide proxy
  const browser = await chromium.launch({
    proxy: {
      server: 'http://your.proxy.server:8080'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();

  // For context-specific proxy
  const browser2 = await chromium.launch();
  const context = await browser2.newContext({
    proxy: {
      server: 'http://another.proxy.server:8080'
    }
  });
  const page2 = await context.newPage();
  await page2.goto('https://httpbin.org/ip');
  console.log(await page2.content());
  await context.close();
  await browser2.close();
})();

Configuração de proxy HTTP/HTTPS autenticado

Para proxies que exigem autenticação, inclua as propriedades username e password no objeto do proxy:

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://user.proxy.server:8080',
      username: 'proxy_user',
      password: 'proxy_password'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();
})();

Configuração de proxy SOCKS

Especifique o protocolo SOCKS na string server:

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'socks5://your.socks.proxy:9050'
    }
  });
  const page = await browser.newPage();
  await page.goto('https://httpbin.org/ip');
  console.log(await page.content());
  await browser.close();
})();

Proxies SOCKS também suportam autenticação por meio das propriedades username e password no objeto.

Ignorando o proxy para domínios específicos

A propriedade bypass no objeto do proxy permite especificar uma lista de hosts ou domínios separados por vírgula que não devem usar o proxy. Curingas (*) são suportados.

const { chromium } = require('playwright');

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://your.proxy.server:8080',
      bypass: '*.local, .example.com, 192.168.1.1'
    }
  });
  const page = await browser.newPage();
  await page.goto('http://example.com'); // Vai ignorar o proxy se example.com estiver na lista de bypass
  await page.goto('https://google.com'); // Vai usar o proxy
  await browser.close();
})();

Comparação das configurações de proxy no Playwright

Considerações avançadas sobre proxy

Direcionando requisições específicas com page.route()

Para controle bem granular, page.route() pode interceptar requisições de rede e encaminhá-las para proxies diferentes conforme critérios específicos. Esse método oferece mais flexibilidade do que as configurações de proxy globais ou de contexto, mas exige tratamento manual das requisições.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()

    def handle_route(route):
        if "example.com" in route.request.url:
            route.fulfill(status=200, body="Blocked by route handler.")
        else:
            # Encaminha as outras requisições por um proxy específico
            # Isso exige configuração manual de cliente HTTP ou pode ser complexo para proxy direto
            # Para casos simples, prefira o proxy global/de contexto.
            # Para roteamento de proxy complexo, considere usar um gerenciador de proxy externo.
            route.continue_({"url": route.request.url}) # Exemplo: continua sem modificação

    page.route("**/*", handle_route)
    page.goto("https://www.google.com") # Será roteado
    page.goto("https://www.example.com") # Será respondido pelo handler
    browser.close()

page.route() geralmente é usado para mocking, modificação de requisições ou bloqueio, e não para redirecionar dinamicamente para proxies diferentes, a menos que seja integrado a uma lógica própria de gerenciamento de proxy.

Verificando o funcionamento do proxy

Depois de configurar um proxy, verifique seu funcionamento acessando um serviço de checagem de endereço IP, como https://httpbin.org/ip ou https://httpbin.org/ip. O endereço IP exibido deve corresponder ao servidor proxy, e não à máquina local.

Tratando erros e timeouts de proxy

Proxies introduzem pontos adicionais de falha. Implemente tratamento de erros robusto para requisições de rede ao usar proxies. Isso inclui:

• Retries: repetir a requisição se a conexão com o proxy falhar ou expirar.
• Timeouts: configurar timeouts de rede adequados para as operações do Playwright.
• Rotação de proxies: em operações de larga escala, faça rotação por um pool de proxies para mitigar rate limiting, banimentos de IP ou falhas de um único proxy. Isso normalmente envolve gerenciar uma lista de proxies e atualizar a configuração proxy dinamicamente para novos contextos ou novas tentativas.

Considerações de segurança

Ao usar proxies autenticados, evite deixar credenciais fixas no código-fonte. Em vez disso, use variáveis de ambiente ou um sistema seguro de gerenciamento de configuração para obter username e password. Isso evita a exposição de credenciais e simplifica seu gerenciamento entre diferentes ambientes.