9장: 엣지 컴퓨팅과 Wasm 배포

// Cloudflare Workers에서 Wasm 사용
import wasmModule from './processor.wasm';
 
export default {
    async fetch(request, env) {
        // Wasm 인스턴스 생성
        const instance = await WebAssembly.instantiate(wasmModule);
        
        // URL에서 파라미터 추출
        const url = new URL(request.url);
        const input = url.searchParams.get('input') || '';
        
        // Wasm 함수로 처리
        const encoder = new TextEncoder();
        const inputBytes = encoder.encode(input);
        
        // 메모리에 쓰기
        const memory = new Uint8Array(instance.exports.memory.buffer);
        memory.set(inputBytes, 0);
        
        // 처리 함수 호출
        const resultLen = instance.exports.process(0, inputBytes.length);
        
        // 결과 읽기
        const resultBytes = memory.slice(0, resultLen);
        const result = new TextDecoder().decode(resultBytes);
        
        return new Response(JSON.stringify({ result }), {
            headers: { 'Content-Type': 'application/json' }
        });
    }
};

use worker::*;
 
#[event(fetch)]
async fn fetch(req: Request, env: Env, _ctx: Context) -> Result<Response> {
    let router = Router::new();
    
    router
        .get_async("/api/process/:input", |_req, ctx| async move {
            let input = ctx.param("input").unwrap();
            
            // 연산 집약적 처리를 Rust/Wasm에서 수행
            let result = heavy_computation(input);
            
            Response::from_json(&serde_json::json!({
                "input": input,
                "result": result,
                "edge_location": "auto"
            }))
        })
        .run(req, env)
        .await
}
 
fn heavy_computation(input: &str) -> String {
    // SHA-256 해시 등 연산 집약적 작업
    let hash = sha256(input.as_bytes());
    hex::encode(hash)
}

use fastly::http::{header, Method, StatusCode};
use fastly::{Error, Request, Response};
 
#[fastly::main]
fn main(req: Request) -> Result<Response, Error> {
    // 요청 라우팅
    match (req.get_method(), req.get_path()) {
        (&Method::GET, "/api/geo") => {
            // Fastly의 지리 정보 활용
            let geo = req.get_client_geo()
                .unwrap_or_default();
            
            let body = serde_json::json!({
                "country": geo.country_code(),
                "city": geo.city(),
                "latitude": geo.latitude(),
                "longitude": geo.longitude(),
            });
            
            Ok(Response::from_status(StatusCode::OK)
                .with_header(header::CONTENT_TYPE, "application/json")
                .with_body_json(&body)?)
        }
        
        (&Method::GET, path) if path.starts_with("/api/transform/") => {
            // 이미지 변환 등 연산 처리
            let image_url = &path["/api/transform/".len()..];
            
            // 오리진에서 이미지 가져오기
            let mut origin_resp = Request::get(image_url)
                .with_header("Host", "images.example.com")
                .send("origin_backend")?;
            
            let image_data = origin_resp.take_body_bytes();
            
            // Wasm에서 이미지 처리 (리사이즈, 포맷 변환 등)
            let processed = process_image(&image_data, 800, 600);
            
            Ok(Response::from_status(StatusCode::OK)
                .with_header(header::CONTENT_TYPE, "image/webp")
                .with_header(header::CACHE_CONTROL, "public, max-age=86400")
                .with_body(processed))
        }
        
        _ => Ok(Response::from_status(StatusCode::NOT_FOUND)
            .with_body_text_plain("Not Found"))
    }
}

# Spin 앱을 Akamai Edge에 배포
spin deploy --provider akamai
 
# 배포 상태 확인
spin cloud status
 
# 로그 확인
spin cloud logs --follow

import { NextRequest, NextResponse } from 'next/server';
 
// Edge Runtime 지정
export const runtime = 'edge';
 
// Wasm 모듈 임포트
import wasmModule from '../../../wasm/processor.wasm?module';
 
let wasmInstance: WebAssembly.Instance | null = null;
 
async function getWasmInstance() {
    if (!wasmInstance) {
        wasmInstance = await WebAssembly.instantiate(wasmModule);
    }
    return wasmInstance;
}
 
export async function GET(request: NextRequest) {
    const instance = await getWasmInstance();
    
    const searchParams = request.nextUrl.searchParams;
    const n = parseInt(searchParams.get('n') || '10');
    
    // Wasm 함수 호출
    const result = (instance.exports.fibonacci as Function)(n);
    
    return NextResponse.json({
        input: n,
        result: result,
        computed_at: 'edge',
    });
}

use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;
 
// 경량 AI 모델을 Wasm에 임베딩
mod model;
 
#[http_component]
fn classify(req: Request) -> anyhow::Result<impl IntoResponse> {
    let body: serde_json::Value = serde_json::from_slice(req.body())?;
    let text = body["text"].as_str().unwrap_or("");
    
    // 엣지에서 텍스트 분류 수행
    let classification = model::classify_text(text);
    
    let response = serde_json::json!({
        "text": text,
        "classification": classification.label,
        "confidence": classification.confidence,
        "processed_at": "edge",
        "latency_benefit": "~195ms saved vs origin"
    });
    
    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(serde_json::to_string(&response)?)
        .build())
}