user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36"

wget --verbose --mirror --no-parent --continue --page-requisites \
     --adjust-extension --convert-links --no-clobber --timestamping \
     --server-response --limit-rate=10k --wait=10 --random-wait \
     --no-cache --user-agent="${user_agent}" --no-check-certificate <website.address>

Mas existe alguma maneira de se defender dessa prática quando a mesma se torna nociva para o servidor, aumentando a carga para um propósito realizado por não-humanos? Contratar um proxy que implemente desafios (CAPTCHA) pode ser uma solução.

Mas será que é possível criar uma solução independente de proxy? E se a página web fosse dinâmica, ou seja, montada em tempo de carga usando somente javascript e uma conexão via websocket seguro com o servidor (nos códigos seguintes é ws em vez de wss)? Por meio do websocket o Javascript obtém o conteúdo a ser montado na página no lado do cliente. Tais recursos dinâmicos ainda não são interpretados pelos crawlers burros.

Esta ideia é possível e o fluxo básico para realizar isso envolve os seguintes passos:

1. Conexão WebSocket com o Servidor

A primeira etapa é estabelecer uma conexão WebSocket com o servidor. O WebSocket permite uma comunicação bidirecional em tempo real, ideal para atualizar e carregar dados dinâmicos.

const socket = new WebSocket('ws://servidor.com:porta');

// Quando a conexão é aberta
socket.onopen = function(event) {
    console.log("Conectado ao servidor via WebSocket.");
    socket.send("Solicitando dados para a página");
};

// Quando uma mensagem é recebida do servidor
socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    montarPagina(data);
};

// Tratamento de erros
socket.onerror = function(error) {
    console.log("Erro na conexão WebSocket:", error);
};

// Quando a conexão é fechada
socket.onclose = function(event) {
    console.log("Conexão WebSocket fechada.");
};

2. Recebendo o Conteúdo

Quando o servidor envia os dados, eles podem estar no formato JSON (ou outro formato estruturado). Ao receber os dados, o JavaScript no lado do cliente pode processar e montar o conteúdo da página dinamicamente.

3. Construção da Página no Lado do Cliente

Uma vez que os dados são recebidos, você pode manipulá-los e gerar o conteúdo da página dinamicamente usando DOM (Document Object Model) ou técnicas como innerHTML.

Exemplo simples de código:

function montarPagina(data) {
    const body = document.body;

    // Criar elementos de acordo com os dados recebidos
    const titulo = document.createElement('h1');
    titulo.textContent = data.titulo;

    const conteudo = document.createElement('p');
    conteudo.textContent = data.conteudo;

    // Adicionar os elementos na página
    body.appendChild(titulo);
    body.appendChild(conteudo);
}

4. Servidor WebSocket

Do lado do servidor, você precisa configurar um serviço WebSocket que envie os dados requisitados ao cliente. O servidor deve manter a conexão aberta enquanto for necessário para enviar novos dados dinamicamente ou quando solicitado.

Um exemplo básico de servidor WebSocket em Node.js:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
    console.log('Cliente conectado');

    ws.on('message', (message) => {
        console.log('Mensagem recebida: %s', message);
        const dadosPagina = {
            titulo: "Bem-vindo à minha página!",
            conteudo: "Este conteúdo foi carregado dinamicamente via WebSocket."
        };
        ws.send(JSON.stringify(dadosPagina));
    });

    ws.on('close', () => {
        console.log('Cliente desconectado');
    });
});

Benefícios:

• Atualização em tempo real: O WebSocket permite que o servidor envie atualizações em tempo real ao cliente sem a necessidade de recarregar a página.
• Eficiência: Reduz a sobrecarga de requisições HTTP/HTTPS repetidas, já que a conexão WebSocket permanece aberta.
• Experiência do usuário: O conteúdo pode ser carregado e atualizado dinamicamente conforme necessário.

Desafios:

• Gestão de estados e reconexão: É necessário garantir que o cliente possa lidar com a desconexão e reconectar caso a comunicação falhe.
• Segurança: A comunicação via WebSocket deve ser protegida para evitar ataques como Man-in-the-Middle (usando WSS em vez de WS).

Essa abordagem é útil para aplicações em tempo real ou dinâmicas, como sistemas de votação, chat ou dashboards de monitoramento em tempo real. Por ser um conteúdo dinâmico, os crawlers burros não conseguirão baixar o conteúdo, mas apenas a página principal contendo o mínimo, básico para que o navegador (Chrome, Firefox, Opera etc.) consiga iniciar a carga e montagem da página dinamicamente.

[Keywords: crawler, defeat, dynamic page, javascript, websocket] // for [index|filter]ing purposes