8장: 서버사이드 Wasm — Spin, Fermyon, SpinKube

spin_manifest_version = 2
 
[application]
name = "my-app"
version = "1.0.0"
 
# HTTP 트리거
[[trigger.http]]
route = "/api/users/..."
component = "user-service"
 
# 스케줄 트리거 (cron)
[[trigger.cron]]
schedule = "0 */5 * * * *"  # 5분마다
component = "data-sync"
 
# Redis 메시지 트리거
[[trigger.redis]]
address = "redis://localhost:6379"
channel = "events"
component = "event-handler"
 
# 각 컴포넌트 설정
[component.user-service]
source = "user-service.wasm"
allowed_outbound_hosts = ["https://api.example.com"]
key_value_stores = ["default"]
sqlite_databases = ["default"]
 
[component.user-service.build]
command = "cargo component build --release"
 
[component.data-sync]
source = "data-sync.wasm"
allowed_outbound_hosts = ["https://external-api.com"]
 
[component.event-handler]
source = "event-handler.wasm"

use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;
 
// 이 함수는 매 요청마다 새로운 Wasm 인스턴스에서 실행됩니다
#[http_component]
fn handle(req: Request) -> anyhow::Result<impl IntoResponse> {
    // 영속 상태가 필요하면 Key-Value Store 사용
    let store = spin_sdk::key_value::Store::open_default()?;
    
    // 방문 카운터 증가
    let count: u64 = store.get("visit_count")?
        .map(|v| u64::from_le_bytes(v.try_into().unwrap_or([0; 8])))
        .unwrap_or(0) + 1;
    
    store.set("visit_count", &count.to_le_bytes())?;
    
    Ok(Response::builder()
        .status(200)
        .header("content-type", "application/json")
        .body(format!(r#"{{"visits":{}}}"#, count))
        .build())
}

apiVersion: core.spinkube.dev/v1alpha1
kind: SpinApp
metadata:
  name: todo-api
spec:
  image: "ghcr.io/myorg/todo-api:v1.0.0"
  replicas: 3
  executor: containerd-shim-spin
  
  # Spin 컴포넌트 설정
  variables:
    - name: db_url
      valueFrom:
        secretKeyRef:
          name: todo-secrets
          key: database-url
  
  # 리소스 제한
  resources:
    limits:
      memory: "128Mi"
      cpu: "100m"

# SpinKube 설치
helm repo add spinkube https://spinkube.github.io/charts
helm install spinkube-operator spinkube/spin-operator
 
# RuntimeClass 설정
kubectl apply -f https://spinkube.github.io/spin-operator/config/samples/runtime-class.yaml
 
# Spin 앱을 OCI 이미지로 패키징
spin registry push ghcr.io/myorg/todo-api:v1.0.0
 
# Kubernetes에 배포
kubectl apply -f spin-app.yaml

spin_manifest_version = 2
 
[application]
name = "api-gateway"
version = "1.0.0"
 
# 각 엔드포인트가 독립적인 컴포넌트
[[trigger.http]]
route = "/api/auth/..."
component = "auth"
 
[[trigger.http]]
route = "/api/users/..."
component = "users"
 
[[trigger.http]]
route = "/api/posts/..."
component = "posts"
 
[[trigger.http]]
route = "/api/search/..."
component = "search"
 
# 각 컴포넌트는 다른 언어로 작성 가능
[component.auth]
source = "auth.wasm"            # Rust
 
[component.users]
source = "users.wasm"           # Rust
 
[component.posts]
source = "posts.wasm"           # Python (componentize-py)
 
[component.search]
source = "search.wasm"          # Go (TinyGo)

use wasmtime::*;
use wasmtime_wasi::WasiCtxBuilder;
 
async fn handle_request(
    engine: &Engine,
    module: &Module,
    request_data: &[u8],
) -> Result<Vec<u8>> {
    // WASI 컨텍스트 설정
    let wasi_ctx = WasiCtxBuilder::new()
        .inherit_stdout()
        .build();
    
    // 스토어 생성
    let mut store = Store::new(engine, wasi_ctx);
    
    // 인스턴스화 (AOT 컴파일된 모듈은 ~0.5ms)
    let instance = Instance::new_async(&mut store, module, &[]).await?;
    
    // 요청 처리 함수 호출
    let process = instance.get_typed_func::<(i32, i32), i32>(&mut store, "process")?;
    
    // 메모리에 요청 데이터 쓰기
    let memory = instance.get_memory(&mut store, "memory")
        .ok_or_else(|| anyhow::anyhow!("no memory"))?;
    memory.write(&mut store, 0, request_data)?;
    
    // 함수 실행
    let result_len = process.call_async(&mut store, (0, request_data.len() as i32)).await?;
    
    // 결과 읽기
    let mut result = vec![0u8; result_len as usize];
    memory.read(&store, 0, &mut result)?;
    
    Ok(result)
}