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

Proxies são essenciais para a automação com Puppeteer. Eles ocultam seu IP, contornam restrições geográficas e ajudam a evitar bloqueios. Veja o que você aprenderá sobre o uso de proxies no Puppeteer:

1. Configurar proxies: adicione proxies ao navegador e autentique-os com facilidade.
2. Rotacionar proxies: distribua solicitações entre vários IPs para evitar detecção.
3. Lidar com erros: tente solicitações novamente, gerencie bloqueios e alterne proxies quando necessário.
4. Otimizar a velocidade: bloqueie recursos desnecessários e alterne agentes de usuário para uma coleta de dados mais rápida e discreta.

Comparação rápida dos tipos de proxy

Integração de proxy do Puppeteer com Bright Data - Tutorial completo 2024

Configuração básica de proxy

Configurar um proxy é uma etapa importante para otimizar sua automação com Puppeteer. Veja como começar.

Adicionando um servidor proxy

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

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 usando 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 do proxy.

Etapas de autenticação do 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'
});

Veja uma comparação rápida entre diferentes métodos de autenticação:

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

Testando as configurações de proxy

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

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

Veja 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();
}

Os testes garantem que a configuração do proxy esteja pronta para uso em suas tarefas de automação.

Métodos de rotação de proxies

Gerenciar a rotação de proxies é essencial para evitar bloqueios de IP e limitações de taxa durante a coleta de dados ou a automação de tarefas online.

Criando uma lista de proxies

Para começar, crie uma lista de proxies que possam ser rotacionados com eficiência. Veja um exemplo de como configurar e usar um pool de proxies:

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 proxies, é importante entender os diferentes tipos de proxy e seus trade-offs:

Cada tipo tem seus pontos fortes e fracos, então escolha com base nas 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 um proxy diferente sem reiniciar o navegador, tornando o processo mais eficiente.

Diretrizes para rotação de proxies

Confira algumas práticas importantes para aprimorar sua estratégia de rotação de proxies:

1. Estratégia de temporização

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

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 adequadamente alternando para outro e repetindo a solicitação:

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 bloqueios, CAPTCHAs e outros obstáculos.

sbb-itb-23997f1

Técnicas avançadas de proxy

Proxies residenciais vs. de datacenter

Escolher o proxy certo é fundamental ao trabalhar com automação no Puppeteer. Veja uma comparação para ajudar você a decidir:

Os proxies residenciais são uma escolha sólida para tarefas que exigem alto anonimato, pois se assemelham bastante à atividade de usuários reais [1].

Lidando com bloqueios e CAPTCHAs

Para enfrentar bloqueios de sites e desafios de CAPTCHA, use mecanismos de rotação de proxies e novas tentativas. Veja 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, mesmo diante de desafios.

Gerenciando erros de proxy

Lidar com erros de proxy de modo eficiente 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 melhorar o gerenciamento de erros:

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

Configurar seu navegador corretamente também ajuda a garantir um desempenho contínuo:

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 estejam funcionando:

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 para proxies

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

Testes e otimização de velocidade

Reduza os tempos 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();
    }
});

Combine 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 e encerramento do próprio Puppeteer. Provavelmente, os maiores ganhos virão de fazer com que suas páginas-alvo sejam renderizadas mais rapidamente."
– Jon Yongfook, Fundador, Bannerbear [3]

Distribuição de carga entre proxies

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 os proxies, complementando os métodos de rotação anteriores para evitar sobrecarregar um único proxy.

Problemas e soluções comuns

Veja alguns desafios comuns e como lidar com eles de forma eficaz:

• Latência de 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 às limitações de taxa com este trecho:

  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 fluida e eficiente, com resultados precisos e consistentes."
– ScrapeOps [2]

Acompanhe os tempos de resposta e as taxas de sucesso para garantir que seus proxies permaneçam eficientes e sem serem detectados.

Conclusão

Principais métodos de configuração

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

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

Para garantir que a página carregue completamente, use a opção waitUntil (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.

Práticas recomendadas

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

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

Veja um resumo rápido das considerações importantes para a implementação de proxies: