Skip to content
HeliosDB HeliosDB Full

WASM Edge Computing: Quick Start

WASM Edge Computing: Quick Start

Part of: WASM Edge Computing User Guide

Time to Complete: 15 minutes

Prerequisites

Terminal window
# HeliosDB installed
heliosdb --version


# Rust toolchain (for WASM compilation)
rustup target add wasm32-unknown-unknown


# CDN provider accounts (at least one)
# - Cloudflare Workers
# - AWS Lambda@Edge
# - Fastly Compute
# - Akamai EdgeWorkers
# - Vercel Edge Functions
# - Netlify Edge Functions

Step 1: Deploy Your First Edge Function (3 minutes)

Create a simple edge function:

edge_function.rs
use heliosdb_wasm::{EdgeFunction, EdgeContext, Value};


#[heliosdb_edge_function]
pub async fn get_user_data(ctx: &EdgeContext, user_id: String) -> Result<Value, Error> {
    // Read from local edge cache (< 1ms)
    if let Some(cached) = ctx.cache.get(&user_id).await? {
        return Ok(cached);
    }


    // Query database
    let user = ctx.db.query("SELECT * FROM users WHERE id = ?", &[user_id]).await?;


    // Cache for 5 minutes
    ctx.cache.set(&user_id, &user, Duration::from_secs(300)).await?;


    Ok(user)
}

Compile to WASM:

Terminal window
cargo build --target wasm32-unknown-unknown --release

Step 2: Configure Edge Runtime (2 minutes)

use heliosdb_wasm::edge::{EdgeRuntimeManager, EdgeRuntimeConfig, RoutingPolicy};
use std::time::Duration;


let config = EdgeRuntimeConfig {
    health_check_interval: Duration::from_secs(30),
    health_check_timeout: Duration::from_secs(5),
    auto_scale_enabled: true,
    scale_up_threshold: 0.8,      // Scale up at 80% capacity
    scale_down_threshold: 0.3,    // Scale down at 30% capacity
    min_capacity_per_region: 100,
    max_capacity_per_region: 10000,
    routing_policy: RoutingPolicy {
        strategy: LoadBalancingStrategy::GeographicProximity,
        max_latency_ms: 50,
        enable_failover: true,
        failover_regions: 3,
        sticky_sessions: false,
    },
};


let mut runtime = EdgeRuntimeManager::new(config);
runtime.start().await?;

Step 3: Deploy to CDN Provider (5 minutes)

use heliosdb_wasm::edge::cdn::{CdnIntegrationManager, CdnConfig, CdnProvider};


let cdn_manager = CdnIntegrationManager::new();


// Configure Cloudflare Workers
let cloudflare_config = CdnConfig::cloudflare(
    "YOUR_API_KEY".to_string(),
    "YOUR_ACCOUNT_ID".to_string(),
);


cdn_manager.register_provider(cloudflare_config).await?;


// Read compiled WASM
let wasm_bytes = std::fs::read("target/wasm32-unknown-unknown/release/edge_function.wasm")?;


// Deploy to Cloudflare
let deployment_id = cdn_manager.deploy(
    CdnProvider::Cloudflare,
    "get_user_data".to_string(),
    wasm_bytes,
    "1.0.0".to_string(),
).await?;


println!("Deployed: {}", deployment_id);

Step 4: Configure Geographic Routing (2 minutes)

use heliosdb_edge::{GeoRouter, RoutingStrategy, GeoLocation};


let router = GeoRouter::new(RoutingStrategy::Hybrid);


// Client location (latitude, longitude)
let client_location = GeoLocation {
    latitude: 37.7749,  // San Francisco
    longitude: -122.4194,
};


// Route to optimal edge node
let decision = router.route(client_location)?;


println!("Routing to: {} (latency: {}ms, distance: {}km)",
    decision.node_id,
    decision.estimated_latency_ms,
    decision.distance_km,
);

Step 5: Test Edge Execution (3 minutes)

// Invoke edge function
let result = runtime.invoke_function(
    "get_user_data",
    vec![Value::String("user_12345".to_string())],
    Some(client_location),
).await?;


println!("Result: {:?}", result);
println!("Latency: {}ms", result.execution_time_ms);


// Verify global distribution
let stats = runtime.get_stats().await;
println!("Deployed to {} nodes across {} regions",
    stats.total_nodes,
    stats.regions.len(),
);

Expected Output:

Routing to: edge-us-west-1 (latency: 3.2ms, distance: 45km)
Result: {"id": "user_12345", "name": "Alice", ...}
Latency: 4.7ms
Deployed to 50 nodes across 45 regions