Configuração de proxy no Puppeteer: técnicas de autenticação, rotação e bypass

Proxies são essenciais para Marionetista automação. Eles escondem seu IP, ignoram restrições geográficas e ajudam a evitar banimentos. Aqui está o que você aprenderá sobre o uso de proxies em Marionetista:

1. Configurar proxies: Adicione proxies ao seu navegador e autentique-os com facilidade.
2. Girar proxies: Distribua solicitações entre vários IPs para evitar detecção.
3. Lidar com erros: Repita solicitações, gerencie bloqueios e troque proxies quando necessário.
4. Otimizar velocidade: Bloqueie recursos desnecessários e gire os agentes de usuário para uma coleta mais rápida e furtiva.

Comparação rápida de tipos de proxy

Tipo de proxy	Velocidade	Anonimato	Custo	melhor para
Datacenter	pomposidade	Baixo	Acessível	Raspagem de alto volume
Residencial	Moderado	Alta	Caro	Tarefas sensíveis ou geoespecíficas
Mobile	Devagar	Muito alto	Muito caro	Verificação de anúncios, CAPTCHAs

Marionetista Integração de proxy com Dados brilhantes - Tutorial completo 2024

Configuração básica de proxy

Configurar um proxy é um passo fundamental para otimizar sua automação Puppeteer. Veja como você pode começar.

Adicionando um servidor proxy

Você pode configurar um servidor proxy durante a inicialização do navegador no Puppeteer assim:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://157.230.255.230:8118']
});
const page = await browser.newPage();

Também é importante lidar com erros ao navegar com um proxy:

try {
    await page.goto('https://books.toscrape.com/', {
        timeout: 70000,
        waitUntil: 'networkidle2'
    });
} catch (err) {
    console.log(err);
}

Em seguida, você precisará proteger sua conexão configurando a autenticação de proxy.

Etapas de autenticação de proxy

Se o seu proxy exigir autenticação, você pode usar o seguinte método:

await page.authenticate({
    username: 'your_proxy_username',
    password: 'your_proxy_password'
});

Aqui está uma rápida comparação de diferentes métodos de autenticação:

Método de autenticação	Melhor caso de uso	Complexidade de implementação
page.authenticate()	Autenticação de proxy padrão	Baixo
proxy-chain pacote	Roteamento avançado	Médio
Proxy-Authorization cabeçalho	Sites somente HTTP	Alta

Depois de configurar seu proxy e autenticação, é hora de testá-lo.

Testando configurações de proxy

Certifique-se de que seu proxy esteja funcionando seguindo estas etapas:

• Teste a conexão com um URL de exemplo.
• Confirme se o IP do proxy está sendo usado.
• Monitore o desempenho da configuração.

Aqui está um script de exemplo para testar seu proxy:

async function testProxy() {
    const browser = await puppeteer.launch({
        args: ['--proxy-server=http://157.230.255.230:8118']
    });
    const page = await browser.newPage();
    try {
        await page.goto('https://books.toscrape.com/', {
            timeout: 70000,
            waitUntil: 'networkidle2'
        });
        const content = await page.content();
        console.log('Proxy connection successful');
    } catch (err) {
        console.log('Proxy connection failed:', err);
    }
    await browser.close();
}

O teste garante que sua configuração de proxy esteja pronta para uso em suas tarefas de automação.

Métodos de rotação de proxy

Gerenciar a rotação de proxy é essencial para evitar proibições de IP e evitar limitações de taxa ao coletar ou automatizar tarefas on-line.

Construindo uma lista de proxy

Para começar, crie uma lista de proxies que podem ser rotacionados eficientemente. Aqui está um exemplo de como configurar e usar um pool de proxy:

const proxyList = [
    {
        host: '157.230.255.230',
        port: '8118',
        username: 'user1',
        password: 'pass1'
    },
    // Add more proxy configurations
];

function getRandomProxy() {
    return proxyList[Math.floor(Math.random() * proxyList.length)];
}

Ao configurar sua lista de proxy, é importante entender os diferentes tipos de proxies e suas vantagens e desvantagens:

Tipo de proxy	Tempo de Resposta	Taxa de sucesso	Faixa de custo
Datacenter	100-300ms	85-95%	US$ 0.50-US$ 2/PI
Residencial	500-1000ms	90-98%	US$ 2-US$ 8/PI
Mobile	800-1500ms	95-99%	US$ 5-US$ 15/PI

Cada tipo tem seus pontos fortes e fracos, então escolha com base em suas necessidades específicas, como velocidade, confiabilidade ou orçamento.

Alternando proxies entre solicitações

Para rotacionar proxies automaticamente, você pode usar a seguinte configuração:

const ProxyChain = require('proxy-chain');

const server = new ProxyChain.Server({
    port: 8080,
    prepareRequestFunction: ({ request }) => {
        const proxy = getRandomProxy();
        return {
            upstreamProxyUrl: `http://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`
        };
    }
});

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://localhost:8080']
});

Essa abordagem garante que cada solicitação seja roteada por meio de um proxy diferente sem reiniciar o navegador, tornando o processo mais eficiente.

Diretrizes de rotação de proxy

Aqui estão algumas práticas importantes para melhorar sua estratégia de rotação de proxy:

1. Estratégia de tempo

Introduzir atrasos aleatórios entre solicitações para simular o comportamento natural de navegação:

function getRotationDelay() {
    // Random delay between 2-5 seconds
    return Math.floor(Math.random() * 3000) + 2000;
}

async function rotateProxy() {
    await new Promise(resolve => setTimeout(resolve, getRotationDelay()));
    const proxy = getRandomProxy();
    // Apply new proxy configuration
}

2. Tratamento de erros

Se um proxy falhar, trate o erro com elegância, alternando para um novo e tentando a solicitação novamente:

async function handleProxyError(error, page) {
    console.log(`Proxy error: ${error.message}`);
    await rotateProxy();
    return page.reload({ waitUntil: 'networkidle2' });
}

3. Gerenciamento de Sessões

Para tarefas que exigem consistência de sessão, use o mesmo proxy para solicitações relacionadas:

const sessionMap = new Map();

function getProxyForSession(sessionId) {
    if (!sessionMap.has(sessionId)) {
        sessionMap.set(sessionId, getRandomProxy());
    }
    return sessionMap.get(sessionId);
}

Com essas estratégias, você pode gerenciar proxies com eficiência e se preparar para desafios mais avançados, como lidar com blocos, CAPTCHAs e outros obstáculos.

sbb-itb-23997f1

Técnicas Avançadas de Proxy

Proxies residenciais vs. datacenter

Selecionar o proxy certo é essencial ao trabalhar com automação do Puppeteer. Aqui está uma comparação para ajudar você a decidir:

Característica	Proxies residenciais	Proxies de Datacenter
fonte	Fornecido por ISPs para propriedades residenciais	Obtido de data centers
Velocidade	Mais lento devido ao roteamento do ISP	Mais rápido com infraestrutura dedicada
Risco de detecção	Inferior - imita o tráfego real do usuário	Mais alto - mais fácil de detectar
Custo	Mais caro	Custo-beneficio
Cobertura Geográfica	Amplo, em vários locais	Muitas vezes limitado
Melhores casos de uso	Tarefas de alto anonimato, raspagem sensível, verificação de anúncios	Mineração de dados de alto volume, processamento em lote

Proxies residenciais são uma escolha sólida para tarefas que exigem alto anonimato, pois se assemelham muito à atividade real do usuário.

Manipulando blocos e CAPTCHAs

Para lidar com bloqueios de site e desafios de CAPTCHA, use mecanismos de rotação e repetição de proxy. Aqui está um exemplo de como gerenciar esses problemas:

const proxyManager = {
    rotationDelay: 2000,
    async handleBlock(page) {
        await page.waitForTimeout(this.rotationDelay);
        const newProxy = await this.getNextProxy();
        await page.authenticate(newProxy);
        return page.reload({ waitUntil: 'networkidle0' });
    },
    async detectBlock(response) {
        return response.status() === 403 || response.status() === 429;
    }
};

Quando um bloqueio é detectado, tentar novamente com um novo proxy pode manter sua automação funcionando sem problemas:

page.on('response', async (response) => {
    if (await proxyManager.detectBlock(response)) {
        await proxyManager.handleBlock(page);
    }
});

Essas estratégias ajudam a manter a continuidade do fluxo de trabalho, mesmo diante de desafios.

Gerenciando erros de proxy

Lidar com erros de proxy de forma eficaz requer ajustes de tempo limite, verificações de validação e proxies de backup. Por exemplo:

async function handleProxyError(error, page) {
    if (error.message.includes('net::ERR_PROXY_CONNECTION_FAILED')) {
        const newProxy = await getBackupProxy();
        await page.authenticate(newProxy);
        await page.setExtraHTTPHeaders({
            'User-Agent': generateRandomUserAgent()
        });
        return page.reload({ waitUntil: 'networkidle2' });
    }
}

Siga estas diretrizes para um melhor gerenciamento de erros:

• Defina tempos limite de conexão para evitar esperas prolongadas.
• Monitore continuamente o desempenho do proxy.
• Mantenha um pool de proxies de backup prontos.

Configurar seu navegador corretamente também desempenha um papel importante para garantir um desempenho perfeito:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://proxy-server:port'],
    timeout: 60000,
    waitUntil: 'networkidle0'
});

Por fim, sempre valide seus proxies para garantir que eles estejam funcionais:

async function validateProxy(proxyConfig) {
    try {
        const response = await fetch('https://api.ipify.org?format=json', {
            proxy: `http://${proxyConfig.host}:${proxyConfig.port}`
        });
        return response.ok;
    } catch (error) {
        console.error(`Proxy validation failed: ${error.message}`);
        return false;
    }
}

Dicas de desempenho de proxy

Quer aproveitar ao máximo o Puppeteer? Essas dicas podem ajudar a ajustar sua configuração de proxy e melhorar o desempenho geral.

Teste de velocidade e otimização

Reduza o tempo de carregamento bloqueando solicitações desnecessárias, como imagens, fontes e folhas de estilo:

await page.setRequestInterception(true);
page.on('request', (req) => {
    if (req.resourceType() === 'stylesheet' || req.resourceType() === 'font' || req.resourceType() === 'image') {
        req.abort();
    } else {
        req.continue();
    }
});

Par page.goto com page.waitForSelector para uma navegação mais rápida:

await page.goto(url, {
    timeout: 30000,
    waitUntil: 'domcontentloaded'
});
await page.waitForSelector('.main-content');

"Ao otimizar o Puppeteer, lembre-se de que há apenas algumas maneiras de acelerar o desempenho de inicialização/desligamento do próprio Puppeteer. Provavelmente, os maiores ganhos virão de fazer com que suas páginas de destino sejam renderizadas mais rapidamente."
– Jon Yongfook, Fundador, bannerbear

Distribuição de carga proxy

Distribua o tráfego entre vários proxies usando o Puppeteer Cluster:

const proxyCluster = {
    async distributeLoad(urls, proxyList) {
        const cluster = await Cluster.launch({
            concurrency: Cluster.CONCURRENCY_CONTEXT,
            maxConcurrency: 5
        });

        await cluster.task(async ({ page, data: url }) => {
            const proxy = proxyList.getNext();
            await page.authenticate(proxy);
            await page.goto(url);
        });
    }
};

Essa abordagem equilibra o tráfego entre proxies, complementando métodos de rotação anteriores para evitar sobrecarregar qualquer proxy.

Problemas e soluções comuns

Aqui estão alguns desafios comuns e como lidar com eles de forma eficaz:

• Latência da rede Use o código a seguir para gerenciar tempos limite e evitar atrasos desnecessários:

  const performRequest = async (page, url) => {
      try {
          await page.goto(url, {
              timeout: 30000,
              waitUntil: 'networkidle2'
          });
      } catch (error) {
          if (error.name === 'TimeoutError') {
              await page.evaluate(() => window.stop());
              return handleTimeout();
          }
          throw error;
      }
  };
  

• Limitação de taxa Detecte e responda aos limites de taxa com este snippet:

  const checkRateLimit = async (response) => {
      if (response.status() === 429 || response.headers()['retry-after']) {
          await handleRateLimit(response.headers()['retry-after']);
      }
  };
  

• Falhas de autenticação Lide com erros de autenticação de proxy tentando novamente com novas credenciais:

  const handleAuthError = async (response, page, proxy) => {
      if (response.status() === 407) {
          await retryWithNewCredentials(page, proxy);
          return true;
      }
      return false;
  };
  

"Ao otimizar seu script do Puppeteer, você pode garantir uma operação suave e eficiente com resultados precisos e consistentes."
- ScrapeOps

Fique de olho nos tempos de resposta e nas taxas de sucesso para garantir que seus proxies permaneçam eficientes e indetectáveis.

Conclusão

Métodos de configuração de chaves

Configurar o Puppeteer com proxies envolve algumas etapas importantes. Para proxies privados, use o authenticate função para fornecer credenciais:

await page.authenticate({
    username: 'proxyUser',
    password: 'proxyPass'
});

Para garantir que a página carregue completamente, use o waitUntil opção (por exemplo, 'networkidle2') e defina um tempo limite (por exemplo, 30 segundos):

await page.goto(url, {
    waitUntil: 'networkidle2',
    timeout: 30000
});

Essas configurações formam a base de uma configuração de proxy confiável.

Melhores Práticas

Para manter operações de proxy seguras e eficientes, siga estas estratégias:

Gerenciamento de Conexão

• Ajuste os tempos limite com base na velocidade do proxy.
• Lide com erros de autenticação de forma eficaz.
• Monitore métricas de desempenho para identificar gargalos.

Otimização de Segurança

• Gire os agentes de usuário junto com os proxies para evitar a detecção.
• Adicione uma camada VPN para proteção extra.
• Intercepte e filtre solicitações desnecessárias para economizar largura de banda.

Aqui está um rápido resumo de considerações importantes para implementação de proxy:

Aspecto	Implementação	Beneficiar
Autenticação	Use authenticate função	Protege o acesso a proxies privados
Gerenciamento de Carga	Habilitar interceptação de solicitação	Reduz a largura de banda e acelera o carregamento
Tratamento de erros	Executar try-catch blocos	Gerencia problemas de conexão com elegância
Proteção de identidade	Gire proxies e agentes de usuário	Melhora as taxas de sucesso e evita bloqueios

Artigos Relacionados

• Como funciona a detecção de navegador sem cabeça e como ignorá-la
• Instalando e configurando o Puppeteer: resolvendo problemas comuns de dependência e Chromium
• Interceptando e modificando solicitações de rede no Puppeteer: um guia prático
• Gerenciamento de agente de usuário no Puppeteer para emulação de dispositivo