Sinalização em Tempo Real

A Sinalização em Tempo Real é um sistema avançado orientado a eventos para lidar com a comunicação assíncrona em fluxos de trabalho automatizados. Esta arquitetura baseada em sinais permite uma interação perfeita entre scripts de automação e sistemas externos, sendo o tratamento de Autenticação Multi-Fator (MFA) uma de suas aplicações mais críticas.

Visão Geral

O sistema de Sinalização em Tempo Real fornece uma estrutura robusta para gerenciar eventos assíncronos em fluxos de trabalho de automação. Embora a verificação de MFA represente um caso de uso primário, a arquitetura flexível do sistema suporta diversos cenários orientados a eventos.

A Autenticação Multi-Fator (MFA) é um recurso de segurança crítico que frequentemente se torna um gargalo para fluxos de trabalho automatizados, causando falhas ou bloqueios de conta.

Por que o Tratamento de MFA é Crítico para a Automação:

✅ Garanta acesso ininterrupto: Lide com códigos SMS inesperados, OTPs de e-mail ou autenticação TOTP sem interrupção do fluxo de trabalho

✅ Evite travamentos do fluxo de trabalho: A automação tradicional congela quando aparecem prompts de MFA, enquanto o Scraping Browser os lida sem problemas

✅ Mantenha sessões estáveis: Tarefas de longa duração permanecem logadas com gerenciamento seguro do estado de verificação

✅ Reduza o risco da conta: O comportamento de verificação semelhante ao humano diminui a probabilidade de acionamento de segurança

Além do MFA: Sistema Universal de Eventos

O sistema de sinalização se estende além da autenticação para lidar com:

• Envios de formulários e atualizações de status
• Notificações de progresso da tarefa
• Callbacks de API e webhooks
• Interações do usuário e mudanças de estado
• Coordenação de processos entre sistemas
• Monitoramento em tempo real e alertas

Solução completa de sinalização:

• Verificação de MFA confiável (caso de uso primário)
• Tratamento universal de eventos para necessidades de automação
• Múltiplos métodos de entrada para códigos e dados
• Processamento assíncrono (não bloqueante)
• Suporte completo a CDP e HTTP API
• Compatibilidade universal com fluxos de autenticação

APIs Suportadas

Scrapeless suporta interfaces CDP e HTTP para sinalização em tempo real:

APIs CDP

Signal.send

Envia dados de sinal para um canal de eventos especificado.

Formato da Requisição:

{
  "method": "Signal.send",
  "params": {
    "event": "string",
    "data": "object"
  }
}

Parâmetros:

Exemplo:

await client.send('Signal.send', {
  event: 'mfa_code',
  data: { code: '123456', type: 'sms' }
});

Signal.wait

Aguarda dados de sinal em um canal de eventos especificado.

Formato da Requisição:

{
  "method": "Signal.wait",
  "params": {
    "event": "string",
    "timeout": 60000
  }
}

Parâmetros:

Exemplo:

const result = await client.send('Signal.wait', {
  event: 'mfa_code',
  timeout: 60000
});
console.log('Received MFA code:', result.data);

Signal.list

Lista todos os nomes de eventos pendentes na fila.

Formato da Requisição:

const list = await client.send('Signal.list');
console.log('Pending events:', list.events);
// Output: ["mfa_code", "captcha_result", "order_status"]
 
// Check for specific event
if (list.events.includes('mfa_code')) {
  console.log('MFA code in queue');
}

Parâmetros: Nenhum obrigatório

Signal.stats

Recupera estatísticas da fila e informações do assinante.

Formato da Requisição:

const client = await page.target().createCDPSession();
 
// Get statistics
const stats = await client.send('Signal.stats');
console.log('Pending events:', stats.events);
console.log('Waiting subscribers:', stats.waiters);

Campos de Resposta:

Signal.clear

Limpa eventos específicos ou todos da fila.

Formato da Requisição:

{
  "method": "Signal.clear",
  "params": {
    "event": "string (optional)"
  }
}

Parâmetros:

APIs REST HTTP

Para sistemas externos, os endpoints HTTP REST fornecem uma alternativa mais simples à configuração de conexão CDP. Isso elimina a necessidade de estabelecer conexões WebSocket para cada transmissão de dados.

Prefixo do Endpoint Padrão do Navegador: https://browser.scrapeless.com/browser/{taskId}

POST /signal/send

Envia um sinal via HTTP.

Corpo da Requisição:

{
  "event": "string",
  "data": "object"
}

Parâmetros:

GET /signal/wait

Aguarda um sinal via requisição HTTP GET.

URL da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/wait?x-api-token={API_KEY}&event={event}&timeout={timeout}

Parâmetros de Consulta:

GET /signal/list

Lista todos os nomes de eventos pendentes.

URL da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/list?x-api-token={API_KEY}

GET /signal/stats

Recupera estatísticas da fila.

URL da Requisição:

GET https://browser.scrapeless.com/browser/{taskId}/signal/stats?x-api-token={API_KEY}

DELETE /signal/clear

Limpa eventos da fila.

Corpo da Requisição:

{
  "event": "string (optional)"
}

Parâmetros:

Melhores Práticas

Use Timeouts Apropriados

Defina valores de timeout com base nos atrasos esperados de verificação. Os tempos de entrega típicos de MFA variam de 10 a 60 segundos.

Tratamento de Erros

Sempre verifique os códigos de status de resposta (200, 408, 400) para lidar com sucesso, timeout e casos de erro apropriadamente.

Monitoramento de Fila

Verifique regularmente as estatísticas da fila para detectar condições de backlog que possam indicar problemas no sistema.

Nomenclatura de Canais de Eventos

Use nomes de canais de eventos descritivos (por exemplo, mfa_code, email_verification, totp_token) para evitar confusão em cenários multi-eventos.

Processamento Assíncrono

Aproveite o tratamento de sinal assíncrono para evitar o bloqueio de scripts enquanto aguarda a entrada do usuário.

Limpeza de Fila

Limpe eventos obsoletos da fila para manter o desempenho do sistema e evitar problemas de memória.

Exemplo Completo

const puppeteer = require('puppeteer-core');
 
(async () => {
    const API_TOKEN = 'API Key';
    const API_URL = 'https://api.scrapeless.com/api/v2/browser'; // Create session task API endpoint
 
    try {
        // Step 1: Get session ID via HTTP API
        const sessionResponse = await fetch(API_URL, {
            method: 'GET',
            headers: {'x-api-token': API_TOKEN},
        });
 
        const {taskId} = await sessionResponse.json();
        console.log('Session created with task ID:', taskId);
 
        // Step 2: Connect to browser via WebSocket
        const browser = await puppeteer.connect({
            browserWSEndpoint: `wss://api.scrapeless.com/browser/${taskId}`,
            headers: {'x-api-token': API_TOKEN},
        });
 
        // Step 3: Navigate to page and wait for signal
        const page = await browser.newPage();
        await page.goto("https://example.com", {waitUntil: "domcontentloaded"});
 
        const client = await page.createCDPSession();
 
        console.log('Waiting for example event...');
        const result = await client.send('Signal.wait', {
            event: 'example_event',
            timeout: 60000
        });
 
        console.log('Received example data:', result.data);
 
        await browser.close();
    } catch (error) {
        console.error('Error occurred:', error);
    }
})();

# Send data to example event using curl
# Replace {taskId} with the session ID from the first step
curl 'https://browser.scrapeless.com/browser/{taskId}/signal/send' \
  -H 'content-type: application/json' \
  -H 'token: API Key' \
  --data-raw $'{  "event":"example_event",  "data":{ "email":"example@host.com", "password": "mypassword"  }}'

O sistema de Sinalização em Tempo Real do Scraping Browser fornece uma estrutura robusta e flexível para lidar com a autenticação multifator em fluxos de trabalho automatizados. Ao combinar interfaces CDP e HTTP com um sistema de fila de eventos inteligente, ele permite a integração perfeita de sistemas de verificação externos, mantendo a segurança e a confiabilidade.

Seja você construindo scripts de automação simples ou orquestrações complexas de múltiplos sistemas, a arquitetura assíncrona e não bloqueante do sistema de sinalização garante que seus fluxos de trabalho sejam concluídos de forma confiável — mesmo quando a verificação de MFA é necessária.