Skip to content
HeliosDB HeliosDB Full

WASM Edge Computing: Deployment

WASM Edge Computing: Deployment

Part of: WASM Edge Computing User Guide

CI/CD Integration

GitHub Actions

name: Deploy Edge Functions


on:
  push:
    branches: [main]


jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3


      - name: Install Rust
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          target: wasm32-unknown-unknown


      - name: Build WASM
        run: cargo build --target wasm32-unknown-unknown --release


      - name: Deploy to Edge
        env:
          HELIOSDB_API_KEY: ${{ secrets.HELIOSDB_API_KEY }}
          CLOUDFLARE_API_KEY: ${{ secrets.CLOUDFLARE_API_KEY }}
        run: |
          heliosdb edge deploy \
            --provider cloudflare \
            --function handle_request \
            --wasm ./target/wasm32-unknown-unknown/release/function.wasm \
            --version ${GITHUB_SHA::8}


      - name: Run Health Checks
        run: heliosdb edge health-check --all

Blue-Green Deployment

// Deploy new version (green)
let green_deployment = cdn_manager.deploy(
    CdnProvider::Cloudflare,
    "handle_request".to_string(),
    new_wasm_bytes,
    "2.0.0".to_string(),
).await?;


// Test green deployment
let health = test_deployment(&green_deployment).await?;


if health.is_healthy() {
    // Switch traffic to green
    router.update_routing_table(green_deployment).await?;


    // Wait for traffic to migrate
    tokio::time::sleep(Duration::from_secs(60)).await;


    // Retire blue deployment
    cdn_manager.retire_deployment(&blue_deployment_id).await?;
} else {
    // Rollback: keep blue, retire green
    cdn_manager.retire_deployment(&green_deployment).await?;
}

Canary Releases

// Deploy canary (5% traffic)
let canary_deployment = cdn_manager.deploy(
    CdnProvider::Cloudflare,
    "handle_request_v2".to_string(),
    new_wasm_bytes,
    "2.0.0-canary".to_string(),
).await?;


// Route 5% traffic to canary
router.update_weights(vec![
    (stable_deployment, 0.95),
    (canary_deployment, 0.05),
]).await?;


// Monitor canary metrics
for _ in 0..60 {
    let metrics = analytics.get_deployment_metrics(&canary_deployment).await?;


    if metrics.error_rate > 0.01 {
        // Rollback canary
        router.update_weights(vec![
            (stable_deployment, 1.0),
        ]).await?;
        cdn_manager.retire_deployment(&canary_deployment).await?;
        return Err(Error::CanaryFailed);
    }


    tokio::time::sleep(Duration::from_secs(60)).await;
}


// Canary successful, promote to 100%
router.update_weights(vec![
    (canary_deployment, 1.0),
]).await?;

Rollback Procedures

// List deployments
let deployments = cdn_manager.get_deployments().await;


for deployment in deployments {
    println!("{} - {} ({})",
        deployment.version,
        deployment.status,
        deployment.deployed_at,
    );
}


// Rollback to previous version
let previous_deployment = deployments
    .iter()
    .filter(|d| d.status == DeploymentStatus::Retired)
    .max_by_key(|d| d.deployed_at)
    .unwrap();


// Re-activate previous deployment
cdn_manager.deploy(
    previous_deployment.provider,
    previous_deployment.function_name.clone(),
    load_wasm_for_version(&previous_deployment.version)?,
    previous_deployment.version.clone(),
).await?;


// Update routing
router.update_routing_table(previous_deployment).await?;

Multi-Region Testing

// Test deployment in specific regions before global rollout
let test_regions = vec![
    Region::UsWest1,
    Region::EuWest1,
];


for region in test_regions {
    let result = test_in_region(region, &deployment).await?;


    println!("Region {}: {}", region.name(), result.status);
    println!("  Latency P99: {:.2}ms", result.latency_p99);
    println!("  Error rate: {:.2}%", result.error_rate * 100.0);


    if !result.is_healthy() {
        return Err(Error::TestFailed(region));
    }
}


// All tests passed, deploy globally
runtime.deploy_globally(function_name).await?;