BentoML 기초: 서비스 작성부터 모델 저장, 패키징, 컨테이너까지

uv venv .venv --python 3.12
source .venv/bin/activate
export BENTOML_HOME="$PWD/bentoml-home"
uv pip install bentoml==1.4.40 scikit-learn==1.9.1 mlflow==3.17.2

# hello_service.py
import bentoml


@bentoml.service
class HelloService:
    @bentoml.api
    def greet(self, name: str) -> dict[str, str]:
        return {"message": f"안녕하세요, {name}!"}

bentoml serve hello_service:HelloService --host 127.0.0.1 --port 3055

curl -i -X POST http://127.0.0.1:3055/greet \
  -H 'Content-Type: application/json' \
  -d '{"name":"BentoML"}'

# train_iris.py
import bentoml
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

X, y = load_iris(return_X_y=True)
model = RandomForestClassifier(n_estimators=100, random_state=7)
model.fit(X, y)
saved = bentoml.sklearn.save_model("iris_classifier:20261025", model)
print(f"saved={saved.tag}")

python train_iris.py
bentoml models list

# iris_service.py
import bentoml
import numpy as np
from bentoml.models import BentoModel
from pydantic import BaseModel, Field


class IrisRequest(BaseModel):
    sepal_length: float = Field(gt=0, le=10)
    sepal_width: float = Field(gt=0, le=10)
    petal_length: float = Field(gt=0, le=10)
    petal_width: float = Field(gt=0, le=10)


class IrisResponse(BaseModel):
    class_id: int
    species: str
    probabilities: list[float]


@bentoml.service(resources={"cpu": "1"}, traffic={"timeout": 30}, workers=1)
class IrisService:
    model_ref = BentoModel("iris_classifier:20261025")

    def __init__(self) -> None:
        self.model = bentoml.sklearn.load_model(self.model_ref.tag)
        self.species = ["setosa", "versicolor", "virginica"]

    @bentoml.api
    def predict(self, request: IrisRequest) -> IrisResponse:
        row = np.array([[request.sepal_length, request.sepal_width,
                         request.petal_length, request.petal_width]])
        class_id = int(self.model.predict(row)[0])
        probabilities = self.model.predict_proba(row)[0].tolist()
        return IrisResponse(
            class_id=class_id,
            species=self.species[class_id],
            probabilities=probabilities,
        )

bentoml serve iris_service:IrisService --host 127.0.0.1 --port 3055

curl -i -X POST http://127.0.0.1:3055/predict \
  -H 'Content-Type: application/json' \
  -d '{"request":{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}}'

{"class_id":0,"species":"setosa","probabilities":[1.0,0.0,0.0]}

curl -i -X POST http://127.0.0.1:3055/predict \
  -H 'Content-Type: application/json' \
  -d '{"request":{"sepal_length":-1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}}'

# batch_service.py
import bentoml
import numpy as np


@bentoml.service
class BatchService:
    @bentoml.api(batchable=True, max_batch_size=8, max_latency_ms=100)
    def double(self, values: np.ndarray) -> np.ndarray:
        print(f"combined batch shape={values.shape}", flush=True)
        return values * 2

bentoml serve batch_service:BatchService --host 127.0.0.1 --port 3056

# batch_requests.py
from concurrent.futures import ThreadPoolExecutor
import requests


def send(value):
    response = requests.post(
        "http://127.0.0.1:3056/double",
        json={"values": [value, value + 1]},
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


with ThreadPoolExecutor(max_workers=4) as pool:
    print(list(pool.map(send, [1.0, 3.0, 5.0, 7.0])))

python batch_requests.py

# bentofile.yaml
service: "iris_service:IrisService"
include:
  - "iris_service.py"
python:
  packages:
    - "bentoml==1.4.40"
    - "scikit-learn==1.9.1"

bentoml build --version 20261025
bentoml list

uv pip install --python .venv/bin/python pip uv

bentoml containerize iris_service:20261025

docker run --rm -p 127.0.0.1:3057:3000 iris_service:20261025

curl -i -X POST http://127.0.0.1:3057/predict \
  -H 'Content-Type: application/json' \
  -d '{"request":{"sepal_length":5.1,"sepal_width":3.5,"petal_length":1.4,"petal_width":0.2}}'

# mlflow_import.py
from pathlib import Path
import bentoml
import mlflow
import mlflow.sklearn
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

root = Path(__file__).resolve().parent
tracking_uri = f"sqlite:///{root / 'mlflow.db'}"
mlflow.set_tracking_uri(tracking_uri)
mlflow.set_registry_uri(tracking_uri)
mlflow.set_experiment("bentoml-import-demo")
X, y = load_iris(return_X_y=True)
model = RandomForestClassifier(n_estimators=20, random_state=7).fit(X, y)
with mlflow.start_run():
    info = mlflow.sklearn.log_model(
        model,
        name="iris-model",
        registered_model_name="iris_registry",
        skops_trusted_types=["sklearn.tree._tree.Tree"],
    )
print(f"registered_version={info.registered_model_version}")
imported = bentoml.mlflow.import_model(
    "iris_from_mlflow:20261025",
    "models:/iris_registry/1",
)
print(f"imported={imported.tag}")

python mlflow_import.py

# verify_mlflow_load.py
import bentoml
model = bentoml.mlflow.load_model("iris_from_mlflow:20261025")
print(model.predict([[5.1, 3.5, 1.4, 0.2]]).tolist())

python verify_mlflow_load.py

# Feast 저장소와 feature view가 준비된 프로젝트에서 사용하는 개념 스케치
from feast import FeatureStore

store = FeatureStore(repo_path="feature_repo")
features = store.get_online_features(
    features=["iris_features:sepal_length", "iris_features:petal_length"],
    entity_rows=[{"flower_id": 1}],
).to_dict()