Estratégias para contornar a proteção do Cloudflare com o Puppeteer

CloudflareAs medidas de segurança do dificultam o acesso de bots aos sites. Mas com Marionetista, você pode contornar essas defesas se feito eticamente. Aqui está um guia rápido para começar:

• Técnicas básicas:
  • Use proxies residenciais e girá-los para evitar a detecção.
  • Imitar o comportamento humano com atrasos aleatórios e movimentos do mouse.
  • Handle Desafios do JavaScript e CAPTCHA usando plugins como puppeteer-extra-plugin-recaptcha.
  • Disfarce a automação com ajustes impressões digitais do navegador e agentes do usuário.
• Configuração do marionetista:
  • Instalar o Puppeteer e plugins:

    npm install puppeteer puppeteer-extra puppeteer-extra-plugin-stealth
    

  • Adicione configurações de stealth para evitar detecção:

    const puppeteer = require('puppeteer-extra');
    const StealthPlugin = require('puppeteer-extra-plugin-stealth');
    puppeteer.use(StealthPlugin());
    

• Lembrete legal: Respeite sempre os termos de serviço do site, evite sobrecarregar servidores e use a automação com responsabilidade.

Essas etapas podem melhorar sua taxa de sucesso contra as proteções da Cloudflare. Mergulhe no artigo para obter trechos de código detalhados e técnicas avançadas.

Nodejs Marionetista Tutorial nº 7 - Detecção de bypass usando ...

Guia de configuração do marionetista

Siga estas etapas para configurar o Puppeteer com configurações e plugins personalizados para navegar pelas proteções do Cloudflare.

Etapas básicas de instalação do Puppeteer

Primeiro, certifique-se de ter Node.js v18 ou mais recente instalado. Então, execute o seguinte comando para instalar o Puppeteer e seus plugins relacionados:

npm install puppeteer puppeteer-extra puppeteer-extra-plugin-stealth

Em seguida, crie um novo arquivo JavaScript e importe os módulos necessários:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
puppeteer.use(StealthPlugin());

Depois disso, você precisará ajustar as configurações de inicialização do navegador para evitar a detecção.

Configurações necessárias do marionetista

Configure sua instância do navegador com configurações que diminuam a chance de ser sinalizado:

const browser = await puppeteer.launch({
    headless: false,
    args: [
        '--no-sandbox',
        '--disable-setuid-sandbox',
        '--disable-infobars',
        '--window-position=0,0',
        '--ignore-certificate-errors',
        '--ignore-certificate-errors-spki-list'
    ]
});

Se você quiser usar um proxy para mascarar seu IP, inclua estas configurações adicionais:

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

await page.authenticate({
    username: 'proxy-username',
    password: 'proxy-password'
});

Complementos úteis para o Puppeteer

Aumente a funcionalidade do Puppeteer com estes plugins:

Para integrar esses complementos, use o seguinte código:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
const AdblockerPlugin = require('puppeteer-extra-plugin-adblocker');

puppeteer.use(StealthPlugin());
puppeteer.use(AdblockerPlugin({ blockTrackers: true }));

Por fim, para fazer com que suas ações pareçam mais naturais, introduza atrasos aleatórios entre elas:

const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
await delay(Math.random() * 1000 + 1000); // Random delay between 1-2 seconds

sbb-itb-23997f1

Métodos para lidar Cloudflare Segurança

Melhore sua configuração do Puppeteer com essas técnicas para navegar melhor pelas defesas do Cloudflare.

Gerenciamento de identidade do navegador

O sistema anti-bot da Cloudflare monitora as impressões digitais do navegador e os sinais de automação. Para disfarçar a atividade do Puppeteer, ajuste os identificadores e propriedades do navegador conforme mostrado abaixo:

const browser = await puppeteer.launch({
    args: [
        '--window-size=1920,1080',
        '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
    ],
    ignoreDefaultArgs: ['--enable-automation']
});

await page.evaluateOnNewDocument(() => {
    delete navigator.webdriver;
    Object.defineProperty(navigator, 'plugins', {
        get: () => [1, 2, 3, 4, 5]
    });
});

Essa configuração remove indicadores de automação e imita uma impressão digital padrão do navegador, ajudando a ignorar as verificações do Cloudflare.

Soluções de Desafios JavaScript

Lidar com os desafios de JavaScript do Cloudflare requer simular comportamento humano. Por exemplo, você pode esperar o formulário de desafio desaparecer e introduzir atrasos aleatórios entre as ações:

// Wait until the Cloudflare challenge form is gone
await page.waitForFunction(() => {
    return document.querySelector('#challenge-form') === null;
}, { timeout: 30000 });

// Add random delays to simulate human interaction
const randomDelay = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min);
};
await page.waitForTimeout(randomDelay(1000, 3000));

Você também pode criar manipuladores personalizados para imitar melhor o comportamento do usuário, conforme necessário. Em seguida, você precisará de uma estratégia para lidar com CAPTCHAs.

Opções de gerenciamento de CAPTCHA

Ao lidar com CAPTCHAs, usar um plugin de resolução de CAPTCHA pode simplificar o processo:

const RecaptchaPlugin = require('puppeteer-extra-plugin-recaptcha');
puppeteer.use(
    RecaptchaPlugin({
        provider: {
            id: '2captcha',
            token: 'your-api-key'
        }
    })
);

Se o plugin não resolver o CAPTCHA, você pode alternar para a rotação de proxy como alternativa:

try {
    await page.solveRecaptchas();
} catch (e) {
    // Rotate to a new proxy if CAPTCHA solving fails
    await page.setRequestInterception(true);
    await useNextProxy();
}

Esses métodos ajudam você a superar os desafios do CAPTCHA e manter o acesso, mesmo quando as ferramentas de automação encontram obstáculos.

Dicas e diretrizes de confiabilidade

Implementar técnicas confiáveis ​​é essencial para garantir o sucesso na automação.

Configuração e uso de proxy

Usar proxies bem gerenciados pode ajudar a reduzir significativamente os riscos de detecção. Por exemplo, proxies residenciais premium oferecem melhores capacidades de bypass. Aqui está um exemplo de configuração:

const browser = await puppeteer.launch({
    args: [
        `--proxy-server=${proxyAddress}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
    ]
});

// Handle proxy authentication
await page.setRequestInterception(true);
page.on('request', request => {
    request.continue({
        headers: {
            ...request.headers(),
            'Proxy-Authorization': `Basic ${Buffer.from(
                `${proxyUsername}:${proxyPassword}`
            ).toString('base64')}`
        }
    });
});

A rotação regular de proxies também ajuda a manter o acesso ininterrupto:

const proxyList = [
    'proxy1.example.com:8080',
    'proxy2.example.com:8080',
    'proxy3.example.com:8080'
];

function getNextProxy() {
    const proxy = proxyList.shift();
    proxyList.push(proxy);
    return proxy;
}

Solicitar controle de tempo

Simular comportamento semelhante ao humano pode minimizar riscos de detecção. Veja como você pode gerenciar o tempo de solicitação de forma eficaz:

const simulateHumanBehavior = async (page) => {
    // Add random mouse movements
    await page.mouse.move(100, 200);
    await page.mouse.move(150, 250, { steps: 10 });

    // Randomize typing speed
    await page.keyboard.type('Hello World', { 
        delay: Math.floor(Math.random() * (150 - 50) + 50) 
    });

    // Add pauses
    await page.waitForTimeout(
        Math.floor(Math.random() * (3000 - 1000) + 1000)
    );
};

Essas técnicas, combinadas com o tratamento adequado da sessão, tornam os esforços de automação mais confiáveis.

Gerenciamento de cookies e sessões

Gerenciar cookies de forma eficaz é crucial para manter a continuidade da sessão. Veja como você pode armazenar e restaurar sessões:

// Store successful session cookies
const storeCookies = async (page) => {
    const cookies = await page.cookies();
    await fs.writeFile(
        'cookies.json',
        JSON.stringify(cookies, null, 2)
    );
};

// Restore previous session
const loadCookies = async (page) => {
    try {
        const cookiesString = await fs.readFile('cookies.json');
        const cookies = JSON.parse(cookiesString);
        await page.setCookie(...cookies);
    } catch (error) {
        console.log('No stored cookies found');
    }
};

Se os cookies falharem na validação, você pode atualizá-los automaticamente:

const validateCookies = async (page) => {
    const response = await page.goto(targetUrl);
    if (response.status() === 403) {
        await clearCookies(page);
        await initializeNewSession(page);
    }
};

Conclusão

Vamos encerrar destacando as principais técnicas e etapas que abordamos.

Recapitulação das técnicas principais

Passar pela proteção do Cloudflare requer uma mistura de métodos trabalhando juntos. As estratégias mais importantes incluem:

• Usando proxies residenciais com rotação adequada
• Gerenciando impressões digitais do navegador e agentes do usuário
• Manipulando cookies e sessões de forma eficaz
• Imitando o comportamento humano com atrasos aleatórios
• Definindo cabeçalhos de solicitação precisos
• Gerenciando a autenticação corretamente

De acordo com dados do setor, a combinação dessas técnicas pode levar a taxas de sucesso de até 98.7% quando as condições são otimizadas.

Ao se concentrar nesses métodos principais, você pode criar um processo de automação confiável e compatível.

Etapas para implementação

Aqui estão algumas dicas finais para refinar sua configuração do Puppeteer e seus esforços para ignorar o Cloudflare:

• Comece com as configurações básicas do Puppeteer
• Gire os proxies cuidadosamente
• Estabeleça mecanismos fortes de tratamento de erros
• Verifique os termos de serviço do site de destino antes de começar
• Mantenha as taxas de solicitação moderadas para evitar o acionamento de defesas
• Documente seus fluxos de trabalho de automação

O Puppeteer requer configuração cuidadosa e ajustes regulares para permanecer eficaz contra as defesas em evolução do Cloudflare. À medida que as medidas de segurança se tornam mais avançadas, o sucesso dependerá de atualizações contínuas em sua estratégia e adesão estrita às práticas éticas. Embora as configurações iniciais possam funcionar bem, manter o desempenho a longo prazo significa permanecer flexível e seguir diretrizes claras.

Artigos Relacionados

• Como funciona a detecção de navegador sem cabeça e como ignorá-la
• Configuração de proxy no Puppeteer: técnicas de autenticação, rotação e bypass
• Gerenciando a impressão digital do navegador no Puppeteer para evitar a detecção
• Superando CAPTCHA em scripts de Puppeteer: do reCAPTCHA aos serviços de reconhecimento