NUOVOPublication of @aurabase/aurabase-js v0.7.5 NPM Packages & Rust Crate v0.1.2Vedi il registro delle modifiche →

Ingegneria · 8 lettura minima

Rust/WASM Edge Functions contro Cloudflare e Vercel Edge

Affane Daylami · Fondateur · 22 giugno 2026

Torniamo al blog

Cloudflare Workers e Vercel Edge Functions eseguono il tuo codice in isolati V8, un contesto JavaScript leggero, non un contenitore o una macchina virtuale. Aurabase offre un secondo percorso, verificato nel suo codice: una modalità wasm che esegue direttamente Rust compilato in WebAssembly, nativamente, nell'aura-functionsservice, tramite il runtime Wasmtime.

Questa pagina è stata tradotta automaticamente. Fa fede la versione inglese.

However, Aurabase's default mode remains Deno (V8 Isolates too), as documented in Aurabase's Rust core. “Edge Functions in Rust” covers three different realities depending on the platform: a community SDK on the Cloudflare side, no official route on the Vercel side, a native execution mode with its own CLI on the Aurabase side. This comparison details the three architectures without mixing what is verified and what remains a platform objective.

L'essenziale

  • Aurabase offre due runtime Edge Functions: deno (Isolati V8, servizio dedicato, modalità predefinita) e wasm (Rust compilato, eseguito in modo nativo tramite Wasmtime).
  • Cloudflare Workers funziona su isolati V8 e può eseguire anche WebAssembly, in particolare tramite l'SDK della community workers-rs. Non è un runtime Rust nativo dedicato come la modalità wasm di Aurabase.
  • Vercel Edge Functions si basa su Edge Runtime, un sottoinsieme dell'API Node.js sugli isolati V8: nessun SDK o CLI ufficiale per scrivere la funzione stessa in Rust.
  • La modalità wasm di Aurabase isola ogni esecuzione con un budget di carburante per la CPU Wasmtime, un limite di memoria dedicata e un timeout per epoca, ma attualmente non espone alcun accesso di rete in uscita al modulo guest.
  • Tre diverse architetture per lo stesso obiettivo: iniziare rapidamente e isolare ogni esecuzione, senza il costo di un contenitore completo.
#
Contesto

Isolati V8 e moduli WASM: due meccaniche sandboxing

Un isolato V8 è un contesto di esecuzione JavaScript leggero all'interno dello stesso motore V8: nessun nuovo processo di sistema, nessun nuovo kernel da avviare. Questo è il meccanismo che Cloudflare ha reso pubblico per la prima volta per Workers e che Vercel riutilizza per il suo Edge Runtime. L'obiettivo è lo stesso da entrambe le parti: evitare il costo di un container o di una VM per ogni richiesta.

Un modulo WebAssembly soddisfa la stessa esigenza attraverso un meccanismo diverso. Il bytecode WASM viene eseguito in una memoria lineare limitata, definita dalla specifica stessa. Il modulo ospite non può indirizzarsi al di fuori di quest'area, indipendentemente dalla lingua di origine (Rust, C, Go…) che ha prodotto il binario. È questo modello che Wasmtime applica nella modalità wasm di Aurabase, descritta di seguito. Per le misurazioni di avvio tra i due meccanismi, vedere il nostro file sui benchmark di avvio a freddo di WebAssembly.

#
WASM Tempo di esecuzione

Cosa viene eseguito in produzione dalla modalità Aurabase wasm

Ogni funzione Aurabase contiene un campo runtime che vale "wasm" o "deno". Il motore di invocazione sceglie di conseguenza il percorso di esecuzione:

runtime/dispatch.rsrust
// Invio in base al runtime: WASM (wasmtime) o Deno (V8 isola tramite edge-runtime)
let resp = if func.runtime == "wasm" {
    state.runtime.invoke(&wasm_bytes, &func.code_hash, req).await?
} else {
    // Proxy per aura-edge-runtime — V8 Isolates (supabase/edge-runtime, MIT)
    proxy_to_edge_runtime(&state.config.edge_runtime_url, …).await?
};

La sandbox si basa su tre meccanismi Wasmtime combinati. Un budget della CPU conteggiato in “carburante”: ogni istruzione WASM lo consuma. Un timeout applicato con incrementi epoch: un thread dedicato aumenta l'orologio Wasmtime dopo il ritardo configurato, che interrompe l'esecuzione corrente. Un limite di memoria impostato tramite StoreLimits. I tre terminali vengono configurati quando viene istanziato il motore:

runtime/wasm.rsrust
let mut cfg = Config::new();
cfg.consume_fuel(true);
cfg.epoch_interruption(true);

// Memoria limitata da StoreLimits, carburante iniziale = max_fuel,
// timeout = incremento dell'epoca dopo timeout_secs (thread dedicato)

Il modulo compilato viene memorizzato nella cache da code_hash: lo stesso binario distribuito non viene ricompilato ad ogni chiamata. Ogni invocazione crea comunque un'istanza di un nuovo Store e di un'istanza. Nessuna fuga di stato da una chiamata all'altra. La superficie esposta al modulo guest rimane volutamente minima, cinque funzioni host in totale: aura.log, aura.get_input, aura.set_output, aura.get_env e uno stub env.abort per la compatibilità AssemblyScript. Al momento nessuna funzione host espone le chiamate di rete in uscita.

Obiettivo verificato rispetto al prodotto

La modalità wasm è ora adatta al puro calcolo: convalida, trasformazione dei dati, punteggio, analisi. Una funzione che deve chiamare un'API di terze parti (pagamento, posta elettronica, servizio esterno) deve comunque passare attraverso la modalità deno. Questa è la modalità predefinita per Aurabase e la modalità consigliata per la migrazione del codice Deno esistente.

Dal punto di vista della distribuzione, la CLI compila il crate localmente prima dell'invio: aura functions new supporta un crate cdylib, aura functions deploy lo compila e quindi lo invia.

terminalbash
# Scaffolding: crea aurabase/functions/<name>/ (Cargo.toml crate-type = cdylib)
aura functions new my-fn

# cargo build --target wasm32-unknown-unknown --release, quindi carica
# POST /v1/functions/:project_id { runtime: "wasm", codice: <wasm in base64> }
aura functions deploy my-fn
#
Cloudflare

Cloudflare Workers: isola V8, con WebAssembly in aggiunta

Cloudflare Workers esegue in modo nativo JavaScript e TypeScript negli isolati V8 distribuiti sulla rete globale di Cloudflare. WebAssembly è un cittadino di prima classe fin dall'inizio della piattaforma: un modulo .wasm può essere importato direttamente in un Worker come qualsiasi altro modulo.

Per scrivere un Worker interamente in Rust, il percorso più utilizzato è l'SDK della community workers-rs, che compila il codice in wasm32-unknown-unknown e lo esegue nel runtime Workers. La differenza con la modalità wasm di Aurabase è la superficie disponibile. Un Worker scritto in Rust tramite questo SDK viene eseguito nell'ambiente Workers completo e può quindi chiamare fetch o altre associazioni di piattaforma. La modalità wasm di Aurabase inizia da una superficie host deliberatamente ridotta (sezione precedente).

#
Vercel

Vercel Edge Functions: un sottoinsieme Node.js, nessun percorso Rust ufficiale

Edge Runtime di Vercel esegue anche codice in isolati V8, con un sottoinsieme di API Web standard (fetch, Request/Response, crypto.subtle…) anziché l'ambiente Node.js completo. I moduli del nodo nativo e le toolchain di compilazione arbitrarie non trovano posto lì.

L'oggetto WebAssembly fa parte di questo sottoinsieme: nulla impedisce di caricare un binario .wasm e istanziarlo manualmente da una funzione JavaScript o TypeScript. Ma per quanto ne sappiamo, Vercel non pubblica alcun SDK o CLI ufficiale per scrivere direttamente una funzione Edge in Rust, a differenza di workers-rs sul lato Cloudflare o aura functions deploy sul lato Aurabase. Il percorso resta possibile, ma interamente manuale, senza strumenti dedicati.

#
Sicurezza

Sandbox: memoria lineare WASM rispetto all'isolamento V8

Un isolato V8 separa il codice eseguito da un heap dedicato e dal proprio contesto, all'interno dello stesso processo del motore. Si tratta di un meccanismo collaudato, sulla scala di milioni di richieste al secondo su Cloudflare e Vercel, ma che rimane un meccanismo di isolamento software all'interno di un singolo motore JavaScript.

Il modello WASM isola in modo diverso: ogni istanza riceve una propria memoria lineare, un buffer contiguo al di fuori del quale non è possibile alcun accesso per costruzione del formato binario stesso, indipendentemente dal motore che lo esegue. Nel runtime Aurabase, ogni funzione host che manipola un puntatore fornito dal modulo guest (aura.log, aura.get_env…) riconvalida esplicitamente i limiti prima di qualsiasi accesso alla memoria. Si tratta di un'ulteriore difesa approfondita contro un modulo dannoso o difettoso.

#
Panoramica

Le tre architetture, fianco a fianco

Aurabase (wasm)Cloudflare WorkersVercel Edge Functions
Modello di esecuzioneModulo nativo WASM, WasmtimeIsola V8 + WASM come modulo opzionaleIsola V8, sottoinsieme Node.js
Rust in primo pianoSì, modalità dedicata + CLITramite SDK della community (workers-rs)No, nessun percorso ufficiale
Accesso alla rete in uscita dal moduloNo, ho inserito il codice (nessuna funzione host di rete)Sì, tramite l'ambiente completo di WorkersSì, API di recupero standard
Budget della CPUCarburante Wasmtime, configurabileLimite di tempo della CPU per richiesta (Cloudflare doc)Limite di durata per evocazione (doc. Vercel)
Distribuzione Rust dedicatadistribuzione delle funzioni dell'aura (creazione del carico locale)attaccabrighe + lavoratori-rsNessuno strumento equivalente ufficiale

Aurabase specifiche di runtime. Colonne Cloudflare e Vercel descritte dall'architettura pubblica documentata di ciascuna piattaforma (isola V8, WebAssembly come destinazione di compilazione).

#
Decisione

Quale runtime scegliere in base alla tua funzione

Calcolo puro, senza chiamate di rete: convalida dello schema, trasformazione dei dati, punteggio, generazione di immagini leggere. La modalità wasm di Aurabase è adatta direttamente, con una rigorosa sandbox di memoria, un budget CPU esplicito e senza dipendenza da un servizio esterno.

Funzione che chiama un'API di terze parti (pagamento, email, webhook in uscita). La modalità deno di Aurabase rimane la scelta predefinita oggi, nello stesso modo in cui un classico Cloudflare Worker o una funzione Vercel Edge si basa su fetch in modo nativo.

Il team ha già investito nell'ecosistema Cloudflare (KV, Sustainable Objects, R2). Rimanere su Workers ha senso; workers-rs ti consente di introdurre Rust gradualmente, senza cambiare piattaforma.

Necessita di un runtime nativo Rust gestito end-to-end, con una CLI dedicata e lo stesso linguaggio del resto del backend. Questo è l'angolo che documenta nel nostro confronto Wasmtime vs Wasmer, sulla scelta del motore WebAssembly stesso.

#
Domande frequenti

Domande frequenti

Puoi scrivere Aurabase Edge Functions in Rust?+
Sì, tramite la modalità wasm. La CLI avrà funzioni di un nuovo scaffolde e di un Rust crate (cdylib di tipo crate). Il comando aurafunctions deploy lo compila localmente con cargo build --target wasm32-unknown-unknown --release, quindi invia il file binario al servizio aura-functions, che lo esegue in modo nativo con il runtime Wasmtime. Questa non è la modalità predefinita: per impostazione predefinita, una funzione Edge Aurabase viene eseguita in JavaScript/TypeScript (runtime Deno, isolati V8).
Cloudflare Workers ti consente davvero di scrivere funzioni in Rust?+
Sì, ma indirettamente: Cloudflare Workers esegue nativamente JavaScript/TypeScript negli isolati V8. L'SDK della community di lavoratori-rs ti consente di compilare un intero Worker in Rust su WebAssembly, ma questo non è il percorso più ufficialmente documentato. WASM integra un Worker anziché sostituire completamente il modello JS.
Vercel Edge Functions supporta WebAssembly o Rust in modo nativo?+
Il runtime Vercel Edge espone API Web standard, incluso l'oggetto WebAssembly, quindi un modulo .wasm può essere caricato e istanziato manualmente da una funzione JavaScript/TypeScript. Ma per quanto ne sappiamo, Vercel non pubblica alcun SDK o CLI ufficiale per scrivere una funzione Edge direttamente in Rust, a differenza dei lavoratori-rs sul lato Cloudflare o delle funzioni aura distribuite sul lato Aurabase.
La modalità Aurabase wasm può chiamare un'API di terze parti (pagamento, e-mail, ecc.)?+
Non oggi: le funzioni host esposte al modulo guest WASM sono il log, la lettura della richiesta di input e la scrittura della risposta di output, oltre alla lettura delle variabili di ambiente. Per una funzione che deve chiamare un'API esterna (recupero dalla rete), il runtime Deno (predefinito) è il percorso consigliato.

PRONTO PER L'IMPLEMENTAZIONE?

Il tuo backend in cinque minuti.

Nessuna carta di credito richiesta · 500 MB gratuiti · 50.000 MAU