[アップデート] AWS Lambda での Rust の利用が一般提供(GA)になりました

use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::Instant;

#[derive(Deserialize)]
struct Request {
    #[serde(default = "default_fib_n")]
    fib_n: u32,
    items: Option<Vec<Item>>,
}

fn default_fib_n() -> u32 {
    35
}

#[derive(Deserialize, Serialize, Clone)]
struct Item {
    id: u32,
    value: u64,
    category: String,
}

#[derive(Serialize)]
struct Response {
    #[serde(rename = "statusCode")]
    status_code: u16,
    body: ResponseBody,
}

#[derive(Serialize)]
struct ResponseBody {
    fibonacci: FibonacciResult,
    json_processing: JsonProcessingResult,
    total_duration_ms: f64,
    runtime: String,
}

#[derive(Serialize)]
struct FibonacciResult {
    n: u32,
    result: u64,
    duration_ms: f64,
}

#[derive(Serialize)]
struct JsonProcessingResult {
    items_count: usize,
    iterations: u32,
    duration_ms: f64,
    result: ProcessedData,
}

#[derive(Serialize)]
struct ProcessedData {
    total: u64,
    count: usize,
    average: f64,
    categories: HashMap<String, u32>,
}

fn fibonacci(n: u32) -> u64 {
    if n <= 1 {
        n as u64
    } else {
        fibonacci(n - 1) + fibonacci(n - 2)
    }
}

fn process_data(items: &[Item]) -> ProcessedData {
    let mut total: u64 = 0;
    let mut categories: HashMap<String, u32> = HashMap::new();

    for item in items {
        total += item.value;
        *categories.entry(item.category.clone()).or_insert(0) += 1;
    }

    ProcessedData {
        total,
        count: items.len(),
        average: if items.is_empty() {
            0.0
        } else {
            total as f64 / items.len() as f64
        },
        categories,
    }
}

async fn handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
    let start_time = Instant::now();
    let request = event.payload;

    // 1. CPU負荷: フィボナッチ計算
    let fib_start = Instant::now();
    let fib_result = fibonacci(request.fib_n);
    let fib_duration = fib_start.elapsed().as_secs_f64() * 1000.0;

    // 2. JSON処理: データ集計
    let items = request.items.unwrap_or_else(|| {
        (0..1000)
            .map(|i| Item {
                id: i,
                value: (i as u64) * 10,
                category: format!("cat_{}", i % 5),
            })
            .collect()
    });

    let json_start = Instant::now();
    let mut deserialized = items.clone();

    // シリアライズ/デシリアライズを複数回
    for _ in 0..100 {
        let serialized = serde_json::to_string(&deserialized)?;
        deserialized = serde_json::from_str(&serialized)?;
    }

    let processed = process_data(&deserialized);
    let json_duration = json_start.elapsed().as_secs_f64() * 1000.0;

    let total_duration = start_time.elapsed().as_secs_f64() * 1000.0;

    Ok(Response {
        status_code: 200,
        body: ResponseBody {
            fibonacci: FibonacciResult {
                n: request.fib_n,
                result: fib_result,
                duration_ms: (fib_duration * 100.0).round() / 100.0,
            },
            json_processing: JsonProcessingResult {
                items_count: deserialized.len(),
                iterations: 100,
                duration_ms: (json_duration * 100.0).round() / 100.0,
                result: processed,
            },
            total_duration_ms: (total_duration * 100.0).round() / 100.0,
            runtime: "rust".to_string(),
        },
    })
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}

import json
import time
from typing import Any

def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

def process_data(items: list[dict]) -> dict:
    """データ処理シミュレーション"""
    total = 0
    categories = {}

    for item in items:
        total += item.get("value", 0)
        cat = item.get("category", "unknown")
        categories[cat] = categories.get(cat, 0) + 1

    return {
        "total": total,
        "count": len(items),
        "average": total / len(items) if items else 0,
        "categories": categories
    }

def lambda_handler(event: dict, context: Any) -> dict:
    start_time = time.perf_counter()

    # 1. CPU負荷: フィボナッチ計算
    fib_n = event.get("fib_n", 35)
    fib_start = time.perf_counter()
    fib_result = fibonacci(fib_n)
    fib_duration = (time.perf_counter() - fib_start) * 1000

    # 2. JSON処理: データ集計
    items = event.get("items", [
        {"id": i, "value": i * 10, "category": f"cat_{i % 5}"}
        for i in range(1000)
    ])

    json_start = time.perf_counter()
    # シリアライズ/デシリアライズを複数回
    for _ in range(100):
        serialized = json.dumps(items)
        deserialized = json.loads(serialized)

    processed = process_data(deserialized)
    json_duration = (time.perf_counter() - json_start) * 1000

    total_duration = (time.perf_counter() - start_time) * 1000

    return {
        "statusCode": 200,
        "body": {
            "fibonacci": {
                "n": fib_n,
                "result": fib_result,
                "duration_ms": round(fib_duration, 2)
            },
            "json_processing": {
                "items_count": len(items),
                "iterations": 100,
                "duration_ms": round(json_duration, 2),
                "result": processed
            },
            "total_duration_ms": round(total_duration, 2),
            "runtime": "python3.13"
        }
    }