Como Engenheiros de Software, frequentemente nos deparamos com gargalos de performance em aplicações backend, especialmente aquelas construídas em Node.js (JavaScript/TypeScript). Embora o V8 seja incrivelmente rápido, tarefas CPU-bound (como processamento de imagens, criptografia ou cálculos matemáticos complexos) podem bloquear o Event Loop.

A inovação que tem mudado o jogo no desenvolvimento de software moderno é o uso de WebAssembly (Wasm) aliado ao Rust. Esta combinação permite executar código quase na velocidade nativa, com segurança de memória, diretamente no ambiente Node.js.

Neste tutorial técnico avançado, vamos criar uma função intensiva em CPU em Rust, compilá-la para Wasm e consumi-la em um servidor Express.js, realizando um benchmark real.

Pré-requisitos

  1. Node.js (v18+)
  2. Rust (rustup default stable)
  3. wasm-pack (Ferramenta para compilar Rust para Wasm: cargo install wasm-pack)

Passo 1: Inicializando a Biblioteca Rust

Primeiro, vamos criar um projeto do tipo biblioteca no Rust.

cargo new --lib rust-wasm-math
cd rust-wasm-math

Edite o seu Cargo.toml para configurar a biblioteca para Wasm e adicionar a dependência wasm-bindgen:

[package]
name = "rust-wasm-math"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2"

Passo 2: Escrevendo o Algoritmo CPU-Bound em Rust

Vamos implementar o cálculo de números primos em um intervalo, uma tarefa clássica de alto custo computacional. Edite o src/lib.rs:

use wasm_bindgen::prelude::*;

// A anotação #[wasm_bindgen] exporta a função para o JavaScript
#[wasm_bindgen]
pub fn count_primes(limit: u32) -> u32 {
    let mut count = 0;
    for i in 2..=limit {
        if is_prime(i) {
            count += 1;
        }
    }
    count
}

fn is_prime(n: u32) -> bool {
    if n <= 1 {
        return false;
    }
    if n <= 3 {
        return true;
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false;
    }
    let mut i = 5;
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false;
        }
        i += 6;
    }
    true
}

Passo 3: Compilando para WebAssembly

Use o wasm-pack para gerar o módulo Wasm focado no Node.js:

wasm-pack build --target nodejs

Isso criará um diretório pkg/ contendo o .wasm e os bindings JavaScript/TypeScript, prontos para uso.

Passo 4: Integrando no Node.js e Comparando Performance

Crie um novo projeto Node.js adjacente:

mkdir ../node-backend
cd ../node-backend
npm init -y
npm install express

Agora, vamos criar o servidor e implementar a mesma função nativamente em JS para efeito de benchmark (index.js):

const express = require('express');
const { count_primes: countPrimesWasm } = require('../rust-wasm-math/pkg');

const app = express();
const PORT = 3000;

// Implementação equivalente em JavaScript puramente para benchmark
function isPrimeJS(n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 === 0 || n % 3 === 0) return false;
    let i = 5;
    while (i * i <= n) {
        if (n % i === 0 || n % (i + 2) === 0) return false;
        i += 6;
    }
    return true;
}

function countPrimesJS(limit) {
    let count = 0;
    for (let i = 2; i <= limit; i++) {
        if (isPrimeJS(i)) count++;
    }
    return count;
}

app.get('/benchmark', (req, res) => {
    const limit = 5000000; // 5 milhões

    // Benchmark Wasm
    const startWasm = process.hrtime.bigint();
    const resultWasm = countPrimesWasm(limit);
    const endWasm = process.hrtime.bigint();
    const timeWasm = Number(endWasm - startWasm) / 1000000; // ms

    // Benchmark JavaScript nativo
    const startJS = process.hrtime.bigint();
    const resultJS = countPrimesJS(limit);
    const endJS = process.hrtime.bigint();
    const timeJS = Number(endJS - startJS) / 1000000; // ms

    res.json({
        limit,
        result_wasm: resultWasm,
        time_wasm_ms: timeWasm.toFixed(2),
        result_js: resultJS,
        time_js_ms: timeJS.toFixed(2),
        speedup: (timeJS / timeWasm).toFixed(2) + 'x mais rápido'
    });
});

app.listen(PORT, () => {
    console.log(`Servidor rodando em http://localhost:${PORT}`);
    console.log(`Execute 'curl http://localhost:${PORT}/benchmark' para testar.`);
});

Resultados Práticos

Ao fazer a chamada para o /benchmark, você verá que o WebAssembly em código compilado de Rust costuma executar 2 a 4 vezes mais rápido neste cenário computacional puro, mantendo o uso eficiente da CPU. Para algoritmos de criptografia ou processamento multimídia, esse speedup pode passar de 10x!

Conclusão

Como engenheiros de software, nosso objetivo não é reescrever tudo em Rust, mas sim utilizar a ferramenta certa para o trabalho certo. Offload de funções CPU-bound do Event Loop do Node.js para módulos WebAssembly compilados em Rust representa o estado da arte na otimização de arquiteturas web contemporâneas.