Rust/WASM Edge Functions versus Cloudflare en Vercel Edge

Een V8-isolaat is een lichtgewicht JavaScript-uitvoeringscontext binnen dezelfde V8-engine: geen nieuwe systeemprocessen, geen nieuwe kernel om te starten. Dit is het mechanisme dat Cloudflare voor het eerst openbaar maakte voor Workers, en dat Vercel hergebruikt voor zijn Edge Runtime. Het doel is aan beide kanten hetzelfde: de kosten van een container of een VM voor elk verzoek vermijden.

Een WebAssembly-module voorziet in dezelfde behoefte via een ander mechanisme. De WASM-bytecode draait in een begrensd lineair geheugen, gedefinieerd door de specificatie zelf. De gastmodule kan zich niet buiten dit gebied richten, ongeacht de brontaal (Rust, C, Go...) die het binaire bestand heeft geproduceerd. Het is dit model dat Wasmtime toepast in de wasm-modus van Aurabase, zoals hieronder beschreven. Voor opstartmetingen tussen de twee mechanismen, zie ons bestand over WebAssembly koude start benchmarks.

Elke Aurabase-functie heeft een veld runtime dat de waarde "wasm" of "deno"heeft. De aanroepengine kiest het uitvoeringspad dienovereenkomstig:

// Verzending op basis van runtime: WASM (wasmtime) of Deno (V8 isoleert via edge-runtime)
let resp = if func.runtime == "wasm" {
    state.runtime.invoke(&wasm_bytes, &func.code_hash, req).await?
} else {
    // Proxy voor aura-edge-runtime — V8 isolaten (supabase/edge-runtime, MIT)
    proxy_to_edge_runtime(&state.config.edge_runtime_url, …).await?
};

De sandbox is gebaseerd op drie gecombineerde Wasmtime-mechanismen. Een CPU-budget geteld als “brandstof”: elke WASM-instructie verbruikt het. Een time-out toegepast in epoch-stappen: een speciale thread verhoogt de Wasmtime-klok na de geconfigureerde vertraging, waardoor de huidige uitvoering wordt onderbroken. Een geheugenlimiet ingesteld via StoreLimits. De drie terminals worden geconfigureerd wanneer de engine wordt geïnstantieerd:

let mut cfg = Config::new();
cfg.consume_fuel(true);
cfg.epoch_interruption(true);

// Geheugen begrensd door StoreLimits, initiële brandstof = max_fuel,
// timeout = epoch-increment na timeout_secs (speciale thread)

De gecompileerde module wordt in de cache opgeslagen door code_hash: hetzelfde geïmplementeerde binaire bestand wordt niet bij elke aanroep opnieuw gecompileerd. Elke aanroep genereert niettemin een nieuw Store en exemplaar. Geen enkele staat lekt van de ene oproep naar de andere. Het oppervlak dat wordt blootgesteld aan de gastmodule blijft opzettelijk minimaal, vijf hostfuncties in totaal: aura.log, aura.get_input, aura.set_output, aura.get_env en een stub env.abort voor AssemblyScript-compatibiliteit. Er zijn momenteel geen hostfuncties die uitgaande netwerkoproepen zichtbaar maken.

Aan de implementatiezijde compileert de CLI uw krat lokaal voordat deze wordt verzonden: aura functions new stelt een krat in cdylib, aura functions deploy compileert het en verzendt het vervolgens.

# Steigers: creëert aurabase/functions/<naam>/ (Cargo.toml krat-type = cdylib)
aura functions new my-fn

# cargo build --target wasm32-unknown-unknown --release en vervolgens uploaden
# POST /v1/functions/:project_id { runtime: "wasm", code: <wasm in base64> }
aura functions deploy my-fn

Cloudflare Workers voeren JavaScript en TypeScript standaard uit in V8-isolaten, verspreid over het wereldwijde netwerk van Cloudflare. WebAssembly is sinds het begin van het platform een ​​eersteklas burger: een .wasm-module kan net als elke andere module rechtstreeks in een Worker worden geïmporteerd.

Om een Worker volledig in Rust te schrijven, is de meest gebruikte route de community SDK workers-rs, die de code compileert naar wasm32-unknown-unknown en deze uitvoert in de Workers-runtime. Het verschil met de wasm-modus van Aurabase is de beschikbare oppervlakte. Een Worker die via deze SDK in Rust is geschreven, draait in de volledige Workers-omgeving en kan daarom fetch of andere platformbindingen aanroepen. De wasm-modus van Aurabase begint met een opzettelijk verkleind hostoppervlak (vorige sectie).

Vercel's Edge Runtime voert ook code uit in V8-isolaten, met een subset van standaard web-API's (fetch, Request/Response, crypto.subtle…) in plaats van de volledige Node.js-omgeving. Native Node-modules en willekeurige compilatietoolchains horen daar niet thuis.

Het object WebAssembly maakt deel uit van deze subset: niets belet u een binair bestand .wasm te laden en dit handmatig te instantiëren vanuit een JavaScript- of TypeScript-functie. Maar voor zover wij weten, publiceert Vercel geen officiële SDK of CLI om rechtstreeks een Edge-functie in Rust te schrijven, in tegenstelling tot workers-rs aan de Cloudflare-kant of aura functions deploy aan de Aurabase-kant. Het pad blijft mogelijk, maar volledig handmatig, zonder speciaal gereedschap.

Een V8-isolaat scheidt de code die wordt uitgevoerd door een speciale heap en zijn eigen context, binnen hetzelfde motorproces. Het is een beproefd mechanisme, op de schaal van miljoenen verzoeken per seconde bij Cloudflare en Vercel, maar het blijft een software-isolatiemechanisme binnen één enkele JavaScript-engine.

Het WASM-model isoleert anders: elke instantie krijgt zijn eigen lineaire geheugen, een aaneengesloten buffer waarbuiten geen toegang mogelijk is door de constructie van het binaire formaat zelf, onafhankelijk van de engine die het uitvoert. In de Aurabase-runtime valideert elke hostfunctie die een aanwijzer van de gastmodule manipuleert (aura.log, aura.get_env…) expliciet de grenzen opnieuw voordat enige geheugentoegang plaatsvindt. Dit is een extra diepgaande verdediging tegen een kwaadaardige module of module met fouten.

Aurabase runtime-specificaties. Cloudflare- en Vercel-kolommen beschreven vanuit de gedocumenteerde openbare architectuur van elk platform (isoleert V8, WebAssembly als builddoel).

Pure berekening, zonder netwerkoproepen: schemavalidatie, gegevenstransformatie, scores, lichtgewicht generatie van afbeeldingen. De wasm-modus van Aurabase is direct geschikt, met een strikte geheugensandbox, een expliciet CPU-budget en zonder afhankelijkheid van een externe service.

Functie die een API van derden aanroept (betaling, e-mail, uitgaande webhook). De deno-modus van Aurabase blijft vandaag de dag de standaardkeuze, net zoals een klassieke Cloudflare Worker of een Vercel Edge-functie native op fetch vertrouwt.

Team heeft al geïnvesteerd in het Cloudflare-ecosysteem (KV, Sustainable Objects, R2). Bij Workers blijven is logisch; Met workers-rs kun je Rust geleidelijk introduceren, zonder van platform te veranderen.

Een native Rust-runtime nodig die end-to-end wordt beheerd, met een speciale CLI en dezelfde taal als de rest van de backend. Dit is de invalshoek die documenteert in onze Wasmtime versus Wasmer-vergelijkingover de keuze van de WebAssembly-engine zelf.