[PYTHON] BentoML vs Ray Serve : 고성능 ML 서빙 아키텍처 설계를 위한 7가지 핵심 해결 방법

BentoML vs Ray Serve

 

머신러닝 모델을 단순한 API로 만드는 것을 넘어, 대규모 트래픽을 견디는 프로덕션 환경에서의 최적화 전략을 심층 분석합니다.

1. 현대적 ML 서빙의 도전 과제와 아키텍처의 중요성

단순히 Flask나 FastAPI를 사용하여 모델을 래핑하는 시대는 지났습니다. 실제 운영 환경에서는 모델의 크기, 추론 시간(Latency), 자원 활용률(GPU/CPU), 그리고 동적 스케일링이 수익성과 직결됩니다. 특히 Python 기반의 ML 생태계에서 BentoML과 Ray Serve는 각각의 독특한 철학으로 고성능 서빙 아키텍처를 구현하는 강력한 도구입니다. 본 가이드에서는 두 프레임워크의 차이를 명확히 구분하고, 개발자가 실무에서 맞닥뜨리는 병목 현상을 해결하는 구체적인 아키텍처 패턴을 제시합니다.

---

2. BentoML vs Ray Serve: 기능 및 아키텍처 비교

두 프레임워크는 모두 분산 환경을 지원하지만, BentoML은 모델 패키징과 정적 최적화에 강점이 있고, Ray Serve는 동적 오케스트레이션과 복잡한 그래프 연산에 특화되어 있습니다.

구분	BentoML (Unified Model Serving)	Ray Serve (Distributed Serving Graph)
핵심 철학	표준화된 Bento 패키징 및 Runner 기반 최적화	Ray 클러스터 위에서 실행되는 유연한 Actor 모델
추론 그래프	선형적 워크플로우에 최적화	복잡한 DAG(Directed Acyclic Graph) 지원
리소스 관리	Runner 단위로 GPU/CPU 자동 할당	Fine-grained 리소스 할당 (Fractional GPU)
배포 방식	Docker 이미지화 및 Yatai를 통한 관리	Ray Cluster 상의 실시간 배포 및 업데이트
오토스케일링	K8s 기반 HPA 또는 BentoCloud 연동	Ray 자체 Autoscaler를 통한 노드/프로세스 제어

---

3. 실무 적용을 위한 7가지 고성능 서빙 해결 예제 (Sample Examples)

개발자가 현업에서 즉시 활용할 수 있는 코드 패턴입니다. 각 예제는 성능 최적화와 확장성에 초점을 맞추었습니다.

Example 1: BentoML을 활용한 Adaptive Batching 구현

여러 요청을 하나로 묶어 GPU 연산 효율을 극대화하는 방법입니다.

import bentoml
from bentoml.io import JSON, Numpy
import numpy as np

# Runner 정의: 배칭 설정 추가
iris_clf_runner = bentoml.sklearn.get("iris_clf:latest").to_runner(
    max_batch_size=50,
    max_latency_ms=200
)

svc = bentoml.Service("iris_fast_service", runners=[iris_clf_runner])

@svc.api(input=Numpy(), output=JSON())
async def classify(input_series: np.ndarray):
    # Runner가 내부적으로 개별 요청을 모아 일괄 처리함
    result = await iris_clf_runner.predict.async_run(input_series)
    return {"prediction": result.tolist()}
        

Example 2: Ray Serve를 이용한 모델 앙상블 및 가중치 분산

동일한 입력을 두 개 이상의 모델에 전달하고 결과를 취합하는 아키텍처입니다.

import ray
from ray import serve
from starlette.requests import Request

@serve.deployment(num_replicas=2)
class ModelA:
    def __call__(self, data):
        return f"ModelA result for {data}"

@serve.deployment(num_replicas=1)
class ModelB:
    def __call__(self, data):
        return f"ModelB result for {data}"

@serve.deployment
class Ingress:
    def __init__(self, handle_a, handle_b):
        self.handle_a = handle_a
        self.handle_b = handle_b

    async def __call__(self, request: Request):
        data = (await request.json())["data"]
        # 병렬 호출
        ref_a = self.handle_a.remote(data)
        ref_b = self.handle_b.remote(data)
        results = await ray.get([ref_a, ref_b])
        return {"ensemble_results": results}

# 배포 그래프 연결
model_a = ModelA.bind()
model_b = ModelB.bind()
app = Ingress.bind(model_a, model_b)
        

Example 3: BentoML에서의 다단계 파이프라인 (IO 최적화)

전처리와 모델 추론을 분리하여 리소스 병목을 해결하는 구조입니다.

import bentoml
from PIL import Image

class Preprocessor:
    def process(self, img):
        # 복잡한 이미지 연산 수행
        return img.resize((224, 224))

preprocessor = Preprocessor()
model_runner = bentoml.pytorch.get("resnet:latest").to_runner()

svc = bentoml.Service("image_pipeline", runners=[model_runner])

@svc.api(input=bentoml.io.Image(), output=bentoml.io.JSON())
async def predict_image(input_img: Image):
    # 1단계: CPU 기반 전처리
    processed = preprocessor.process(input_img)
    # 2단계: GPU 기반 추론 (Runner)
    prediction = await model_runner.predict.async_run(processed)
    return {"class": prediction}
        

Example 4: Ray Serve의 Fractional GPU 할당 기술

단일 GPU를 여러 모델 인스턴스가 나누어 쓰도록 설정하여 가성비를 높이는 방법입니다.

@serve.deployment(
    ray_actor_options={"num_cpus": 1, "num_gpus": 0.25}, # GPU 1개를 4개의 인스턴스가 공유
    num_replicas=4
)
class EfficientModel:
    def __call__(self, request):
        return "Processed on shareable GPU"
        

Example 5: BentoML 1.x의 비동기 스트리밍 (LLM/Video)

대규모 언어 모델(LLM) 서빙 시 필수적인 토큰 스트리밍 처리 방법입니다.

import bentoml
from bentoml.io import Text

svc = bentoml.Service("llm_service")

@svc.api(input=Text(), output=Text())
async def stream_output(input_text: str):
    # 비동기 제너레이터를 통한 결과 전송
    async def response_generator():
        for char in "This is a streaming response from BentoML":
            yield char
    return response_generator()
        

Example 6: Ray Serve의 다이나믹 리퀘스트 라우팅

사용자 등급이나 입력 데이터 크기에 따라 다른 모델 버전을 호출하는 해결 방식입니다.

@serve.deployment
class Router:
    def __init__(self, v1_handle, v2_handle):
        self.v1 = v1_handle
        self.v2 = v2_handle

    async def __call__(self, request: Request):
        user_tier = request.query_params.get("tier", "free")
        if user_tier == "premium":
            return await self.v2.remote("High-end Model Result")
        return await self.v1.remote("Standard Model Result")
        

Example 7: 모니터링을 위한 커스텀 메트릭 연동 (Prometheus)

성능 지표를 실시간으로 수집하여 아키텍처의 안정성을 확보하는 방법입니다.

from prometheus_client import Summary
import bentoml

REQUEST_TIME = Summary('inference_seconds', 'Time spent processing prediction')

@svc.api(input=JSON(), output=JSON())
@REQUEST_TIME.time() # 자동으로 실행 시간 측정
async def monitored_predict(data):
    return await runner.predict.async_run(data)
        

---

4. 고성능 아키텍처를 위한 5가지 최적화 전략

1. Zero-Copy Serializer: 모델 간 데이터 전달 시 직렬화 비용을 줄이기 위해 Apache Arrow 등을 활용하십시오.
2. Batch Windowing: 처리량을 늘리되 지연 시간을 제어하기 위해 max_latency_ms를 세밀하게 튜닝해야 합니다.
3. Isolation: I/O 바운드 작업(DB 조회 등)과 CPU/GPU 바운드 작업을 독립된 프로세스로 분리하십시오.
4. Cold Start 완화: Ray Serve의 경우 미리 Warm-up 리플리카를 유지하여 첫 요청 지연을 방지하십시오.
5. Shadow Deployment: 신규 아키텍처 배포 전, 실제 트래픽의 복사본을 전달하여 성능 검증을 수행하십시오.

5. 결론 및 향후 전망

BentoML은 빠른 제품화와 표준화가 필요한 팀에게 최적이며, Ray Serve는 데이터 처리 파이프라인과 모델 서빙이 복합적으로 얽힌 대규모 클러스터 환경에서 빛을 발합니다. 기술의 선택보다 중요한 것은 병목 지점을 정확히 파악하고 이를 해결하기 위한 분산 아키텍처 패턴을 올바르게 적용하는 것입니다.

참고 문헌 및 출처

• BentoML 공식 문서: docs.bentoml.org
• Ray Serve 공식 가이드: docs.ray.io/en/latest/serve/
• NVIDIA Triton Inference Server 아키텍처 백서
• Margo, "Scaling Machine Learning at Uber with Ray", Uber Engineering Blog.