WebAssembly in the Enterprise: Beyond the Browser

┌───────────────────────────────────────────────────────────┐
│                                                           │
│                    WebAssembly Module                     │
│                                                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │             │  │             │  │             │        │
│  │  Types      │  │  Functions  │  │  Memory     │        │
│  │             │  │             │  │             │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
│                                                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │             │  │             │  │             │        │
│  │  Tables     │  │  Globals    │  │  Exports    │        │
│  │             │  │             │  │             │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
│                                                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
│  │             │  │             │  │             │        │
│  │  Imports    │  │  Data       │  │  Elements   │        │
│  │             │  │             │  │             │        │
│  └─────────────┘  └─────────────┘  └─────────────┘        │
│                                                           │
└───────────────────────────────────────────────────────────┘

// Rust example with WASI capabilities
use std::fs::File;
use std::io::{self, Read, Write};

fn main() -> io::Result<()> {
    // Open a file (requires wasi_snapshot_preview1.fd_open capability)
    let mut file = File::open("input.txt")?;
    
    // Read file contents (requires wasi_snapshot_preview1.fd_read capability)
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    
    // Process contents
    let processed = contents.to_uppercase();
    
    // Write to stdout (requires wasi_snapshot_preview1.fd_write capability)
    io::stdout().write_all(processed.as_bytes())?;
    
    Ok(())
}

# Compile Rust to WebAssembly
cargo build --target wasm32-wasi --release

# Run WebAssembly module with Wasmtime
wasmtime --dir=. target/wasm32-wasi/release/my_app.wasm

┌───────────────────────────────────────────────────────────┐
│                                                           │
│                    API Gateway                            │
│                                                           │
└───────────────────────────────────────────────────────────┘
                 ▲                        ▲
                 │                        │
    ┌────────────┴─────────┐    ┌─────────┴────────────┐
    │                      │    │                      │
    ▼                      ▼    ▼                      ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│                 │    │                 │    │                 │
│  Wasm Service A │    │  Wasm Service B │    │  Wasm Service C │
│  (Rust)         │    │  (C++)          │    │  (AssemblyScript)│
│                 │    │                 │    │                 │
└─────────┬───────┘    └─────────┬───────┘    └─────────┬───────┘
          │                      │                      │
          ▼                      ▼                      ▼
┌───────────────────────────────────────────────────────────┐
│                                                           │
│                    Shared Data Layer                      │
│                                                           │
└───────────────────────────────────────────────────────────┘

# spin.toml
spin_version = "1"
name = "order-service"
version = "1.0.0"
description = "Order processing service"

[[trigger.http]]
route = "/api/orders"
component = "order-processor"

[component.order-processor]
source = "target/wasm32-wasi/release/order_processor.wasm"
allowed_outbound_hosts = ["https://payment-api.example.com"]
[component.order-processor.build]
command = "cargo build --target wasm32-wasi --release"

// Cloudflare Worker example
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  // Instantiate the WebAssembly module
  const { instance } = await WebAssembly.instantiateStreaming(
    fetch('/processor.wasm'),
    {
      env: {
        // Import functions provided to the Wasm module
        log: (ptr, len) => {
          const memory = instance.exports.memory;
          const buffer = new Uint8Array(memory.buffer, ptr, len);
          const message = new TextDecoder().decode(buffer);
          console.log(message);
        }
      }
    }
  );
  
  // Parse request body
  const body = await request.json();
  
  // Process the request using the Wasm module
  const result = instance.exports.process_request(body);
  
  // Return the response
  return new Response(JSON.stringify(result), {
    headers: { 'Content-Type': 'application/json' }
  });
}

// Rust image processing at the edge
use fastly::http::{Method, StatusCode};
use fastly::{Error, Request, Response};
use fastly::mime;
use image::{DynamicImage, ImageOutputFormat};

#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    // Only handle GET requests to /resize
    if req.get_method() != Method::GET || !req.get_path().starts_with("/resize") {
        return Ok(Response::from_body("Not Found")
            .with_status(StatusCode::NOT_FOUND));
    }
    
    // Parse query parameters
    let params = req.get_query();
    let width = params.get("width").and_then(|w| w.parse::<u32>().ok()).unwrap_or(100);
    let height = params.get("height").and_then(|h| h.parse::<u32>().ok()).unwrap_or(100);
    let image_url = match params.get("url") {
        Some(url) => url,
        None => return Ok(Response::from_body("Missing 'url' parameter")
            .with_status(StatusCode::BAD_REQUEST))
    };
    
    // Fetch the original image
    let mut image_req = Request::get(image_url);
    let image_resp = image_req.send("origin")?;
    
    // Process the image
    let image_data = image_resp.into_body_bytes();
    let img = image::load_from_memory(&image_data)?;
    let resized = img.resize(width, height, image::imageops::FilterType::Lanczos3);
    
    // Convert to JPEG
    let mut output = Vec::new();
    resized.write_to(&mut output, ImageOutputFormat::Jpeg(85))?;
    
    // Return the processed image
    Ok(Response::from_body(output)
        .with_header("Content-Type", mime::IMAGE_JPEG.as_ref()))
}

| Aspect                | Containers           | WebAssembly          |
|-----------------------|----------------------|----------------------|
| Size                  | 10MB - 1GB+          | 10KB - 10MB          |
| Startup Time          | 100ms - seconds      | 1ms - 10ms           |
| Isolation Model       | Process/namespace    | Language-level       |
| Security              | Container escape     | Capability-based     |
| System Access         | Full (configurable)  | Limited (WASI)       |
| Resource Overhead     | Higher               | Lower                |
| Ecosystem Maturity    | Mature               | Emerging             |
| Language Support      | Any                  | Growing              |
| Deployment Complexity | Higher               | Lower                |
| Performance           | Near-native          | Near-native          |

// Rust actor for wasmCloud
use wasmbus_rpc::actor::prelude::*;
use wasmcloud_interface_httpserver::{HttpRequest, HttpResponse, HttpServer, HttpServerReceiver};

#[derive(Debug, Default, Actor, HealthResponder)]
#[services(Actor, HttpServer)]
struct OrderActor {}

#[async_trait]
impl HttpServer for OrderActor {
    async fn handle_request(&self, ctx: &Context, req: &HttpRequest) -> RpcResult<HttpResponse> {
        match (req.method.as_str(), req.path.as_str()) {
            ("GET", "/api/orders") => {
                // Get orders logic
                Ok(HttpResponse {
                    status_code: 200,
                    header: vec![
                        (String::from("content-type"), String::from("application/json")),
                    ],
                    body: String::from(r#"{"orders":[{"id":"1","status":"shipped"}]}"#).into_bytes(),
                })
            },
            ("POST", "/api/orders") => {
                // Create order logic
                Ok(HttpResponse {
                    status_code: 201,
                    header: vec![
                        (String::from("content-type"), String::from("application/json")),
                    ],
                    body: String::from(r#"{"id":"2","status":"created"}"#).into_bytes(),
                })
            },
            _ => {
                // Not found
                Ok(HttpResponse {
                    status_code: 404,
                    header: vec![],
                    body: vec![],
                })
            }
        }
    }
}

// Rust WebAssembly module
use wasm_bindgen::prelude::*;

// Export a function to JavaScript
#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u32 {
    if n <= 1 {
        return n;
    }
    
    let mut a = 0;
    let mut b = 1;
    
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    
    b
}

// Export a struct to JavaScript
#[wasm_bindgen]
pub struct Point {
    x: f64,
    y: f64,
}

#[wasm_bindgen]
impl Point {
    #[wasm_bindgen(constructor)]
    pub fn new(x: f64, y: f64) -> Point {
        Point { x, y }
    }
    
    pub fn distance_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

// Rust SIMD example for WebAssembly
use std::arch::wasm32::*;

#[cfg(target_feature = "simd128")]
pub unsafe fn sum_f32_simd(values: &[f32]) -> f32 {
    let mut sum = v128_const(0, 0, 0, 0);
    let mut i = 0;
    
    // Process 4 floats at a time
    while i + 4 <= values.len() {
        let chunk = v128_load(&values[i] as *const f32 as *const v128);
        sum = f32x4_add(sum, chunk);
        i += 4;
    }
    
    // Extract the sum
    let mut result = f32x4_extract_lane::<0>(sum) +
                    f32x4_extract_lane::<1>(sum) +
                    f32x4_extract_lane::<2>(sum) +
                    f32x4_extract_lane::<3>(sum);
    
    // Handle remaining elements
    while i < values.len() {
        result += values[i];
        i += 1;
    }
    
    result
}