Lambda Managed Instances with Rust Multi-Concurrency — Zero Cold Starts in Practice

[package]
name = "rust-mi-bench"
version = "0.1.0"
edition = "2021"
 
[dependencies]
lambda_runtime = { version = "1", features = ["concurrency-tokio"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["macros"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }

use lambda_runtime::{service_fn, run_concurrent, LambdaEvent, Error};
use serde::{Deserialize, Serialize};
use std::time::Instant;
 
#[derive(Deserialize, Default)]
struct Request {
    #[serde(default = "default_n")]
    n: u32,
}
 
fn default_n() -> u32 { 40 }
 
#[derive(Serialize)]
struct BenchResult {
    runtime: String,
    mode: String,
    fib_result: u64,
    fib_n: u32,
    compute_ms: f64,
    alloc_items: usize,
    alloc_ms: f64,
    total_ms: f64,
}
 
fn fibonacci(n: u32) -> u64 {
    if n <= 1 { return n as u64; }
    let (mut a, mut b) = (0u64, 1u64);
    for _ in 2..=n {
        let tmp = a + b;
        a = b;
        b = tmp;
    }
    b
}
 
async fn handler(event: LambdaEvent<Request>) -> Result<BenchResult, Error> {
    let n = event.payload.n;
    let total_start = Instant::now();
 
    let compute_start = Instant::now();
    let fib_result = fibonacci(n);
    let compute_ms = compute_start.elapsed().as_secs_f64() * 1000.0;
 
    let alloc_start = Instant::now();
    let items: Vec<u64> = (0..100_000).map(|i| i * i).collect();
    let alloc_ms = alloc_start.elapsed().as_secs_f64() * 1000.0;
 
    let total_ms = total_start.elapsed().as_secs_f64() * 1000.0;
 
    Ok(BenchResult {
        runtime: "rust".to_string(),
        mode: "managed-instance".to_string(),
        fib_result, fib_n: n, compute_ms,
        alloc_items: items.len(), alloc_ms, total_ms,
    })
}
 
#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .json()
        .init();
    run_concurrent(service_fn(handler)).await
}

ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
REGION="ap-northeast-1"
 
# 1. Execution role
aws iam create-role --role-name lambda-mi-exec-role \
  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"lambda.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
aws iam attach-role-policy --role-name lambda-mi-exec-role \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
 
# 2. Operator role (for EC2 management)
aws iam create-role --role-name lambda-mi-operator-role \
  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"lambda.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
aws iam attach-role-policy --role-name lambda-mi-operator-role \
  --policy-arn arn:aws:iam::aws:policy/AWSLambdaManagedEC2ResourceOperator
 
# 3. Capacity Provider
aws lambda create-capacity-provider \
  --capacity-provider-name rust-bench-cp \
  --vpc-config SubnetIds=SUBNET_1,SUBNET_2,SUBNET_3,SecurityGroupIds=SG_ID \
  --permissions-config CapacityProviderOperatorRoleArn=arn:aws:iam::${ACCOUNT_ID}:role/lambda-mi-operator-role \
  --instance-requirements Architectures=arm64 \
  --capacity-provider-scaling-config ScalingMode=Auto \
  --region $REGION
 
# 4. Lambda function with Capacity Provider
cargo lambda build --release --arm64
aws lambda create-function \
  --function-name rust-mi-bench \
  --runtime provided.al2023 --handler bootstrap \
  --role arn:aws:iam::${ACCOUNT_ID}:role/lambda-mi-exec-role \
  --zip-file fileb://target/lambda/rust-mi-bench/bootstrap.zip \
  --architectures arm64 --memory-size 2048 --timeout 30 \
  --capacity-provider-config "LambdaManagedInstancesCapacityProviderConfig={CapacityProviderArn=arn:aws:lambda:${REGION}:${ACCOUNT_ID}:capacity-provider:rust-bench-cp,PerExecutionEnvironmentMaxConcurrency=8}" \
  --region $REGION
 
# 5. Publish version (required for MI)
aws lambda wait function-active-v2 --function-name rust-mi-bench --region $REGION
aws lambda publish-version --function-name rust-mi-bench --region $REGION
# EC2 provisioning takes ~100 seconds

# Wait for version to become Active (EC2 provisioning)
VERSION=1  # from publish-version output
while true; do
  STATE=$(aws lambda get-function-configuration \
    --function-name rust-mi-bench --qualifier $VERSION \
    --region ap-northeast-1 --query 'State' --output text)
  echo "State: $STATE"
  [ "$STATE" = "Active" ] && break
  [ "$STATE" = "Failed" ] && echo "Failed!" && break
  sleep 10
done
 
# Invoke (version qualifier required)
aws lambda invoke \
  --function-name rust-mi-bench:$VERSION \
  --cli-binary-format raw-in-base64-out \
  --payload '{"n": 40}' \
  --region ap-northeast-1 \
  /tmp/mi_result.json
cat /tmp/mi_result.json
 
# Get Duration from CloudWatch Logs
aws logs filter-log-events \
  --log-group-name /aws/lambda/rust-mi-bench \
  --filter-pattern "platform.report" \
  --start-time $(( $(date +%s) - 300 ))000 \
  --region ap-northeast-1 \
  --query 'events[*].message' --output text