AI 서빙 업계의 Rust: 왜 주목받고 있는가?

Published by

on

들어가며

AI 모델 서빙 업계에서 Rust가 빠르게 성장하고 있습니다. Python이 여전히 모델 개발의 표준이지만, 프로덕션 환경에서는 다른 이야기가 펼쳐지고 있습니다. 성능, 메모리 안전성, 그리고 리소스 효율성이 중요한 실전에서 Rust가 새로운 선택지로 떠오르고 있습니다.

주요 프로덕션 사례

Cloudflare의 Infire

Cloudflare는 자체 Rust 기반 인퍼런스 엔진인 Infire를 개발했습니다. 결과는 인상적입니다:

  • H100 GPU에서 vLLM 0.10.0 대비 최대 7% 빠른 성능
  • CPU 사용량을 2.5 코어에서 극적으로 감소
  • GPU 활용률 80% 이상 달성
  • 단일 바이너리로 배포, gvisor 샌드박싱 오버헤드 제거

이는 단순한 벤치마크 수치가 아닙니다. 실제 프로덕션 환경에서 더 적은 리소스로 더 많은 요청을 처리할 수 있다는 의미입니다.

왜 Rust를 선택했을까?

Techempower 벤치마크에서 Rust 프레임워크들은 일관되게 최상위 점수를 기록했습니다. 특히 다중 쿼리 처리 – 인퍼런스 서버의 핵심 작업 – 에서 우수한 성능을 보였습니다.

Python의 GIL(Global Interpreter Lock)이 병목을 만드는 곳에서, Rust는 진정한 멀티스레딩과 제로 코스트 추상화를 제공합니다.

Rust ML 생태계

핵심 프레임워크

1. Candle (Hugging Face)

  • 최소주의 설계의 ML 프레임워크
  • CPU/GPU 추론 지원
  • Transformers, Whisper 등 주요 모델 실행
  • Hugging Face의 공식 지원

2. mistral.rs

  • Candle 기반 고성능 인퍼런스 엔진
  • Apple Silicon Metal 백엔드 최적화
  • OpenAI 호환 서버 내장
  • 순수 Rust 구현과 비동기 API

3. Burn

  • 훈련과 추론을 모두 지원하는 종합 프레임워크
  • 다양한 백엔드 (CPU, WGPU를 통한 GPU)
  • 동적 그래프와 모양 지원
  • 성능 희생 없는 유연성

4. ONNX Runtime & Tract

  • ONNX Runtime: Microsoft의 고성능 런타임에 대한 Rust 래퍼, GPU 지원
  • Tract: 순수 Rust 경량 ONNX 추론 엔진
  • 프로덕션에서 검증된 안정성

실무 스택 구성

API 서버 예제

use axum::{Router, Json, extract::State};
use ort::{Session, SessionBuilder, Value};
use std::sync::Arc;

#[derive(Clone)]
struct AppState {
    session: Arc<Session>,
}

async fn predict(
    State(state): State<AppState>,
    Json(input): Json<Vec<f32>>,
) -> Json<Vec<f32>> {
    // ONNX 추론 실행
    let input_tensor = Value::from_array(
        state.session.allocator(),
        &[1, input.len()]
    ).unwrap();
    
    let outputs = state.session
        .run(vec![input_tensor])
        .unwrap();
    
    Json(outputs[0].extract_tensor().unwrap())
}

#[tokio::main]
async fn main() {
    let session = SessionBuilder::new()
        .unwrap()
        .with_model_from_file("model.onnx")
        .unwrap();
    
    let state = AppState {
        session: Arc::new(session),
    };
    
    let app = Router::new()
        .route("/predict", axum::routing::post(predict))
        .with_state(state);
    
    axum::Server::bind(&"0.0.0.0:8080".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

모노레포 구조

ai-platform/
├── Cargo.toml              # 워크스페이스 루트
├── db-schema/              # 공유 데이터 모델
│   ├── Cargo.toml
│   └── src/
│       └── models/
├── inference-api/          # REST API 서버
│   ├── Cargo.toml
│   └── src/
│       ├── main.rs
│       └── handlers/
└── batch-worker/           # 배치 추론 워커
    ├── Cargo.toml
    └── src/

Hybrid 워크플로우

실무에서는 Python과 Rust를 함께 사용하는 패턴이 효과적입니다:

┌──────────────────┐
│ Python Research  │  → 모델 훈련 (PyTorch/JAX)
│ Jupyter/Colab    │
└─────────┬────────┘
          │
          │ ONNX/SafeTensors 내보내기
          ▼
┌──────────────────┐
│ Rust Inference   │  → 프로덕션 서빙 (Axum + ONNX)
│ + Tract/Candle   │
└─────────┬────────┘
          │
          ▼
┌──────────────────┐
│ AWS 배포         │  → ECS/Lambda
│ (단일 바이너리)  │
└──────────────────┘

장점

연구 단계

  • Python의 풍부한 생태계 활용
  • 빠른 프로토타이핑과 실험

프로덕션 단계

  • Rust의 성능과 안전성
  • 낮은 메모리 사용량
  • 예측 가능한 레이턴시
  • 단일 바이너리 배포

AWS 환경에서의 이점

Lambda에서의 Rust

콜드 스타트

  • Python: 수백 ms
  • Rust: 수십 ms
  • 컴파일된 단일 바이너리의 빠른 시작

메모리 효율성

  • Python 런타임 오버헤드 제거
  • 더 작은 메모리 할당으로 비용 절감

실행 시간

  • GIL 없는 진정한 병렬성
  • 더 많은 요청을 동일 시간에 처리

ECS/Fargate에서의 Rust

# 멀티스테이지 빌드
FROM rust:1.75 as builder
WORKDIR /app
COPY . .
RUN cargo build --release

# 최소 런타임 이미지
FROM debian:bookworm-slim
COPY --from=builder /app/target/release/inference-api /usr/local/bin/
CMD ["inference-api"]
  • 최종 이미지 크기: ~50MB (Python 이미지 대비 1/10)
  • 빠른 컨테이너 시작
  • 낮은 CPU/메모리 사용량

실전 팁

1. 작게 시작하기

처음부터 모든 것을 Rust로 전환하지 마세요:

  1. 핫 패스(hot path)부터 Rust로 마이그레이션
  2. ONNX 모델로 내보내기
  3. 간단한 REST API 구축
  4. 벤치마크로 검증

2. 도구 체인 활용

# 개발 중 자동 재시작
cargo watch -x run

# 릴리스 빌드 최적화
cargo build --release

# 프로파일링
cargo flamegraph

3. 타입 안전성 활용

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize)]
struct PredictionRequest {
    features: Vec<f32>,
}

#[derive(Debug, Serialize)]
struct PredictionResponse {
    prediction: f32,
    confidence: f32,
}

컴파일 타임에 API 계약을 검증하여 런타임 에러를 방지합니다.

결론

AI 서빙에서 Rust는 더 이상 실험적 선택이 아닙니다. Cloudflare, Hugging Face 같은 기업들이 프로덕션에서 검증하고 있으며, 생태계는 빠르게 성숙하고 있습니다.

Python으로 연구하고, Rust로 배포하는 하이브리드 접근법은 두 언어의 강점을 모두 활용합니다. 특히 클라우드 환경에서 리소스 효율성과 성능이 직접적인 비용 절감으로 이어지는 만큼, Rust는 고려할 가치가 충분합니다.

20년간 웹 개발을 해오셨다면, Rust의 학습 곡선은 가파르지만 투자 대비 효과는 확실합니다. 타입 시스템과 컴파일러가 많은 버그를 사전에 잡아주고, 한번 컴파일되면 프로덕션에서 안정적으로 동작합니다.

참고 자료

더 많은 정보를 보시려면 https://worldofdevice.tistory.com 으로 접속하세요.!


댓글 남기기

오픈바이브 | oftenvibe.com에서 더 알아보기

지금 구독하여 계속 읽고 전체 아카이브에 액세스하세요.

계속 읽기