bentoml部署深度學習模型（一）

核心概念（Core Concepts）

文章來源：https://docs.bentoml.org/en/latest/concepts.html
BentoML的主要思想是，數據科學團隊應該能夠以易於測試、易於部署和易於集成的方式發佈他們的模型。爲了做到這一點，需要幫助數據科學家開發一個構建和發佈預測服務的工具，而不是將經過pickle的模型文件或Protobuf文件上傳到服務器上。bentoml.BentoService公司是使用BentoML構建此類預測服務的基類。bentoml是用於創建預測服務的基類，這裏給出一個最簡單的部署案例：

import bentoml
from bentoml.handlers import DataframeHandler
from bentoml.artifact import SklearnModelArtifact

@bentoml.env(auto_pip_dependencies=True)
@bentoml.artifacts([SklearnModelArtifact('model')])
class IrisClassifier(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        return self.artifacts.model.predict(df)

每一個BentoService類，可以通過@bentoml.artifact 接口包含多個模型，也可以包含多個API接口。每一個API接口的定義，都需要指定一個BentoHandler的數據類型，該類型，定義了API的輸入類型。BentoML提供了覆蓋絕大多數情景的數據類型，包括DataframeHandler，TensorHandler，ImageHandler，JsonHandler。
一旦一個機器學習模型訓練好了，用一個BentoService對象可以把訓練好的模型打包，具體打包的方式，是通過 BentoService的pack方法實現的。打包好後，API接口就可以通過 self.artifacts.ARTIFACT_NAME來訪問訓練好的模型做預測了。比如上述案例中，artifact類用名字"model"來初始化，所以，就可以通過 self.artifacts.model訪問模型了。
做完上述工作後，BentoService 就可以用於預測了。更重要的是，BentoML解決了將整個BentoService保存到磁盤、分發保存的文件以及在測試和生產環境中複製完全相同的預測服務的問題。
要保存一個BentoService對象，只需簡單的調用 BentoService的save方法，在這個過程中，BentoML將會做如下工作：

• 保存基於機器學習訓練框架下得到的模型，以及保存使用的artifact數據類型。
• 自動獲取BentoService類的所有依賴，並且把依賴寫到requirements.txt文件。
• 保存所有的本地python代碼依賴。
• 將生成的所有文件放在一個文件目錄中，默認情況下，該目錄是由BentoML管理，也可以自己指定目錄。

from sklearn import svm
from sklearn import datasets

clf = svm.SVC(gamma='scale')
iris = datasets.load_iris()
X, y = iris.data, iris.target
clf.fit(X, y)

# Create a iris classifier service with the newly trained model
iris_classifier_service = IrisClassifier()
iris_classifier_service.pack("model", clf)

# Test invoking BentoService instance
iris_classifier_service.predict([[5.1, 3.5, 1.4, 0.2]])

# Save the entire prediction service to file bundle
saved_path = iris_classifier_service.save()
print("saved_path:{saved_path}")

保存的BentoService文件目錄稱爲Bento。它是一個版本控制的文件目錄，包含運行此預測服務所需的所有信息。
對於每一個機器學習模型，可以把Bento想象成一個docker鏡像，或者一個二進制軟件。Bento可以在模型訓練結束後自動生成，新的Bento反應了模型的最新信息，可以很容易的保存、分發Bento文件、以及測試預測服務，然後把模型部署到生產。

BentoML跟蹤保存的所有bento，併爲模型管理提供web UI和CLI命令。默認情況下，BentoML將所有模型文件和元數據保存在本地文件系統中。對於一個開發團隊的配置來講，建議爲整個團隊運行一個共享的BentoML服務器，該服務器將其所有Bento文件和元數據存儲在雲中（例如RDS、S3）。這允許您的ML團隊輕鬆地共享、查找和使用彼此的模型和模型服務端點。在這裏閱讀更多關於它的信息。
BentoML CLI Listing recent Bento:

> bentoml list
BENTO_SERVICE                         CREATED_AT        APIS                       ARTIFACTS
IrisClassifier:20200121114004_360ECB  2020-01-21 19:40  predict<DataframeHandler>  model<SklearnModelArtifact>
IrisClassifier:20200120082658_4169CF  2020-01-20 16:27  predict<DataframeHandler>  clf<PickleArtifact>
...

BentoML model management web UI:

創建BentoService

通過創建一個預測類，這個類繼承 bentoml.BentoService，來實現自己的預測服務。建議將你的BentoService類源代碼放入一個單獨的python文件中，並將這個類與模型訓練的代碼放在一起用git託管。
BentoMl的設計，讓BentoService的代碼很容易就放在模型訓練之後，這樣可以將模型訓練和模型服務綁定在一起，使得後期模型的管理，測試、上線部署變得很容易。

注意
BentoService類不能在__main__模塊中定義，這意味着類本身不應該在Jupyter筆記本單元或python交互shell中定義。但是，您可以使用jupyter notebook中的%write file magic命令將BentoService類定義寫入單獨的文件，請參閱BentoML quickstart notebook中的示例。

BentoService只能使用Python創建。但是可以使用BentoML的其他語言/框架訓練模型，並從BentoML的模型管理、API服務器、dockerisation和性能優化中獲益。爲此，您需要創建自定義組件。對R和Spark MLlib模型的支持在我們的規劃之中。

定義依賴（Defining Service Environment）

定義服務的環境
bentoml.env用於定義預測服務的環境設置和依賴項的API。下面是BentoML支持的依賴類型：

PyPI Packages

Python 的PyPi包是最常用的依賴，BentoML提供了一種機制，可以自動計算出BentoService python類所需的PyPI包，只需使用auto-pip-dependencies=True選項：

@bentoml.env(auto_pip_dependencies=True)
class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        return self.artifacts.model.predict(df)

如果模型服務所需的PyPI包的特定版本不同於您的模型訓練環境，或者如果auto_pip_dependencies=True選項不適用於您的案例，您還可以手動指定PyPI包的列表，例如：

  pip_dependencies=['scikit-learn']
)
class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        return self.artifacts.model.predict(df)

類似地，如果您已經有在依賴包名稱，並且已經放在了文件requirements.txt.txt中，就可以指定這個依賴包文件的路徑，比如：

@bentoml.env(requirements_txt_file='./requirements.txt')
class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        return self.artifacts.model.predict(df)

Conda Packages

同樣的，可以指定Conda包依賴，下面是一個需要H2O的Conda包示例預測服務：

@bentoml.artifacts([H2oModelArtifact('model')])
@bentoml.env(
  pip_dependencies=['pandas', 'h2o==3.24.0.2'],
  conda_channels=['h2oai'],
  conda_dependencies=['h2o==3.24.0.2']
)
class ExamplePredictionService(bentoml.BentoService):

  @bentoml.api(DataframeHandler)
  def predict(self, df):
      return self.artifacts.model.predict(df)

注意：這裏的Conda包由於AWS Lambda平臺的限制，不能在AWS Lambda部署中使用。

Bash腳本（Init Bash Script）

Init setup腳本用於自定義提供docker容器的API。用戶可以通過init安裝腳本將任意bash腳本插入docker構建過程，以安裝額外的系統依賴項或執行預測服務所需的其他設置。

@bentoml.env(
    auto_pip_dependencies=True,
    setup_sh="./my_init_script.sh"
)
class ExamplePredictionService(bentoml.BentoService):
    ...

@bentoml.env(
    auto_pip_dependencies=True,
    setup_sh="""\
#!/bin/bash
set -e

apt-get install --no-install-recommends nvidia-driver-430
...
  """
)
class ExamplePredictionService(bentoml.BentoService):
    ...

如果您有一個特定的docker鏡像，您想用於您的API服務器，我們正在研究自定義docker鏡像支持。如果您有興趣幫助測試此功能，請與我們聯繫。

模型打包工件（Packaging Model Artifacts）

BentoML的API允許用戶指定BentoService所需的經過訓練後的模型。當保存和加載BentoService時，BentoML自動處理模型序列化和反序列化。因此BentoML要求用戶爲他們正在使用的機器學習框架選擇正確的類型。BentoML爲大多數流行的ML框架提供了內置的類型，您可以在這裏找到支持的框架列表。如果您使用的ML框架不在列表中，請告訴我們，我們將考慮添加它的支持。要指定BentoService所需的模型類型，請使bentoml.artifacts並傳遞一個模型類型列表，並在預測服務中爲每個模型指定一個唯一的名稱。下面是一個示例預測服務，它包含兩個經過訓練的模型：

import bentoml
from bentoml.handlers import DataframeHandler
from bentoml.artifact import SklearnModelArtifact, XgboostModelArtifact

@bentoml.env(auto_pip_dependencies=True)
@artifacts([
    SklearnModelArtifact("model_a"),
    XgboostModelArtifact("model_b")
])
class MyPredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        # assume the output of model_a will be the input of model_b in this example:
        df = self.artifacts.model_a.predict(df)

    return self.artifacts.model_b.predict(df)

序列化模型：

svc = MyPredictionService()
svc.pack('model_a', my_sklearn_model_object)
svc.pack('model_b', my_xgboost_model_object)
svc.save()

對於大多數模型服務場景，我們建議每個預測服務使用一個模型，並將非相關模型分離爲單獨的服務。唯一的例外是當多個模型相互依賴時，如上面的示例。

接口函數和輸入數據類型（API Function and Handlers）

BentoService API是客戶端訪問預測服務的入口點。它是通過編寫API處理函數（BentoService類中的方法）來定義的，該函數在客戶端發送推斷請求時被調用。用戶需要用 @bentoml.api，並傳入一個Handler類，該類定義API函數所需的輸入格式。例如，如果您的模型期望將DataFrame格式的數據作爲輸入，則可以對您的API使用DataframeHandler，例如：

class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        assert type(df) == pandas.core.frame.DataFrame
        return postprocessing(model_output)

當指定輸入是DataframeHandler格式時，服務端會將client端的預測請求參數：比如json格式、csv格式的輸入參數，轉換爲pandas.DataFrame格式。
用戶可以在處理數據的API函數中編寫任意的python代碼。除了將預測輸入數據傳遞給模型進行推理外，用戶還可以在API函數中編寫數據提取、數據預處理和後處理。例如：

from my_lib import preprocessing, postprocessing, fetch_user_profile_from_databasae

class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df):
        user_profile_column = fetch_user_profile_from_databasae(df['user_id'])
        df['user_profile'] = user_profile_column
        model_input = preprocessing(df)
        model_output = self.artifacts.model.predict(model_input)
        return postprocessing(model_output)

注意：可以查看支持哪些輸入數據集類型。

需要注意的是，在BentoML中，傳遞給用戶定義的API函數的輸入變量始終是一個用於預測的輸入列表。BentoML用戶必須確保他們的API函數代碼正在處理一個batch的輸入數據。
這種設計使得BentoML能夠在在線API服務中進行微批處理（Micro-Batching），這是模型服務系統最有效的優化技術之一。

接口返回值（API Function Return Value）

API接口可以返回如下類型的數據:

pandas.DataFrame
pandas.Series
numpy.ndarray
tensorflow.Tensor

# List of JSON Serializable
# JSON = t.Union[str, int, float, bool, None, t.Mapping[str, 'JSON'], t.List['JSON']]
List[JSON]

用戶API函數的任務是確保預測結果的列表與輸入序列的順序匹配，並且具有完全相同的長度。

注意：
在BentoML 0.7.0之前，API函數可以一次處理並返回一個預測請求，但是在引入自適應微批處（micro batching）理特性之後，不再推薦這樣做。

多服務接口（Service with Multiple APIs）

BentoService可以包含多個接口，這使得構建支持不同客戶端的不同訪問模式的預測服務變得非常容易，例如：

from my_lib import process_custom_json_format

class ExamplePredictionService(bentoml.BentoService):

    @bentoml.api(DataframeHandler)
    def predict(self, df: pandas.Dataframe):
        return self.artifacts.model.predict(df)

    @bentoml.api(JsonHandler)
    def predict_json(self, json_arr):
        df = processs_custom_json_format(json-arr)
        return self.artifacts.model.predict(df)

該案例演示瞭如何定義連個API的情況，兩個API底層預測函數是一樣的，不同的是，輸入不同，第一個API的輸入是DataFrame格式的數據，第二個API的輸入是一個json，然後需要一個處理json的函數，來把json類型的數據，轉換爲DataFrame，最後傳遞給預測函數。
確保爲每個API指定不同的名稱。BentoML使用方法名作爲API的名稱，這將成爲它生成的服務端點的一部分。

API的調用（Operational API）

完成模型訓練/評估的代碼和BentoService的定義之後，以下是創建BentoService實例並將其保存以供服務所需的步驟：

• 第一步，訓練模型
• 第二步，創建BentoService 實例
• 第三步， 用BentoService#pack打包訓練好的模型
• 第四步，用 BentoService#save保存一個Bento

下面給一個案例：

from sklearn import svm
from sklearn import datasets

# 1. 第一步，Model training
clf = svm.SVC(gamma='scale')
iris = datasets.load_iris()
X, y = iris.data, iris.target
clf.fit(X, y)

# 2. 第二步，Create BentoService instance
iris_classifier_service = IrisClassifier()

# 3. 第三步，Pack trained model artifacts
iris_classifier_service.pack("model", clf)

# 4. 第四步，Save
saved_path = iris_classifier_service.save()

完成上述四步，就創建了一個Bento，可以理解爲一個docker鏡像，也可以理解爲一個python包。

怎麼保存模型（How Save Works）

BentoService#save_to_dir（path）是將BentoService保存到目標目錄的基本操作。save_to_dir序列化模型組件，並將所有相關代碼、依賴項和配置保存到給定路徑中。

用戶可以使用 bentoml.load(path) 從保存的文件路徑加載完全相同的BentoService實例。這使得以相同的方式輕鬆地將預測服務分發到測試和生產環境中成爲可能。

BentoService#save本質上調用了BentoService#save_to_dir(path)，同時跟蹤您創建的所有預測服務並維護這些已保存包的文件結構和元數據信息。

模型服務（Model Serving）

一旦BentoService被保存爲Bento，就可以在不同的場景下部署了。
有三種主要的服務模式：

• 在線服務-客戶端通過API端點近實時地訪問預測
• 離線批量服務-在存儲系統中預計算預測和保存結果
• 設備端服務-分佈式模型並在移動或物聯網設備上運行

BentoML對在線服務和離線批量服務都有很好的支持。它有一個高性能的API服務器，可以加載保存的Bento並公開restapi供客戶端訪問。它還提供了加載Bento的工具，併爲其提供一批用於離線推斷的輸入。僅當客戶端具有Python運行時時（例如，路由器或樹莓派中的模型服務）才支持邊緣服務。

在線服務（Online API Serving）

一旦保存了BentoService，就可以輕鬆地啓動REST API服務器來測試發送請求和與服務器交互。例如，在“入門指南”中保存bentoservice後，可以立即使用以下命令啓動API服務器：

bentoml serve IrisClassifier:latest

如果您使用的是save_to_dir，或者您直接從其他計算機複製了保存的Bento文件目錄，那麼BentoService IrisClassifier不會在本地BentoML存儲庫中註冊。在這種情況下，您仍然可以通過提供保存的BentoService的路徑來啓動服務器：

bentoml serve $saved_path

REST API請求格式由每個API的處理程序類型和處理程序配置決定。更多細節可以在BentoML API Handler Refernces找到。
要運行生產API服務器，請確保改用bentoml serve-gunicorn命令，或使用Docker容器進行部署。

bentoml serve-gunicorn $saved_path --enable-microbatch --workers=2 --port=3000

API容器化部署（API Server Dockerisation）

當您準備將服務部署到生產環境中時，可以使用BentoML輕鬆創建包含模型API服務器的docker映像。保存Bento時，BentoML也會在同一目錄中生成Dockerfile。Dockerfile是一個文本文檔，包含創建docker映像所需的所有命令，docker build命令從Dockerfile生成映像。

# Find the saved path of the latest version of IrisClassifier Bento
saved_path=$(bentoml get IrisClassifier:latest -q | jq -r ".uri.uri")

# Build docker image using saved_path directory as the build context, replace the
# {username} below to your docker hub account name
docker build -t {username}/iris_classifier_bento_service $saved_path

# Run a container with the docker image built and expose port 5000
docker run -p 5000:5000 {username}/iris_classifier_bento_service

# Push the docker image to dockerhub for deployment
docker push {username}/iris_classifier_bento_service

下面是一個使用上面構建的docker映像在Kubernetes集羣中創建的部署示例：

apiVersion: apps/v1 # for k8s versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
  name: iris_classifier
spec:
  selector:
    matchLabels:
      app: iris_classifier
  replicas: 3
  template:
    metadata:
      labels:
        app: iris_classifier
    spec:
      containers:
      - name: iris_classifier_bento_service
        image: {username}/iris_classifier_bento_service:latest
        ports:
        - containerPort: 5000

自適應的微批處理（Adaptive Micro-Batching）

微批處理是將輸入的預測請求分組成小批，以實現模型推斷任務中批處理的性能優勢的一種技術。BentoML在剪紙機的啓發下實現了這樣一個微批處理層：一個低延遲的在線預測服務系統。

考慮到從微批處理中模型服務性能可以得到很大提升，bentomlapi被設計成在用戶端不需要任何代碼更改的情況下與微批處理一起工作。這就是爲什麼所有的API處理程序都被設計爲接受輸入是一個列表，如API函數和處理程序部分所述。

目前，微批處理仍然是一個beta版本，用戶可以在運行BentoML API服務器時通過傳遞參數來決定是否啓用微批處理：

# Launch micro batching API server from CLI
bentoml serve-gunicorn $saved_path --enable-microbatch

# Launch model server docker image with micro batching enabled
docker run -p 5000:5000 -e BENTOML_ENABLE_MICROBATCH=True {username}/iris-classifier:latest

程序訪問（Programmatic Access）

保存的BentoService也可以從保存的Bento直接load，並直接用Python訪問。主要有三種方法：

• 1.從保存的Bento目錄加載 bentoml.load(path)API

import bentoml

bento_service = bentoml.load(saved_path)
result = bento_service.predict(input_data)

這種方法的好處是靈活性。用戶可以輕鬆地在其後端應用程序中調用保存的BentoService，並以編程方式選擇要加載的模型以及如何使用它們進行推理。

• 2.Install BentoService as a PyPI package
  Bento目錄也可以安裝pip，如《入門指南》中所示：

pip install $saved_path

# Your bentoML model class name will become the package name
import IrisClassifier

installed_svc = IrisClassifier.load()
installed_svc.predict([[5.1, 3.5, 1.4, 0.2]])

這種方法確保在安裝時爲BentoService安裝了所有必需的pip依賴項。當您的數據科學團隊將預測服務作爲一個獨立的python包發佈時，它是非常方便的，可以由各種不同的開發人員共享以進行集成。

• 3.shell命令行訪問
  類似地，可以使用BentoML CLI工具加載Bento進行推斷。一旦通過pip安裝了bentoml，就可以使用CLI命令bentoml。要加載已保存的Bento文件，只需使用bentoml run命令，併爲其指定名稱和版本對或Bento的路徑：

# With BentoService name and version pair
bentoml run IrisClassifier:latest predict --input='[[5.1, 3.5, 1.4, 0.2]]'
bentoml run IrisClassifier:latest predict --input='./iris_test_data.csv'

# With BentoService's saved path
bentoml run $saved_path predict --input='[[5.1, 3.5, 1.4, 0.2]]'
bentoml run $saved_path predict --input='./iris_test_data.csv'

或者，如果您已經pip安裝了BentoService，它會專門爲此BentoService提供一個CLI命令。CLI命令與BentoService類名相同：

IrisClassifier run predict --input='[[5.1, 3.5, 1.4, 0.2]]'
IrisClassifier run predict --input='./iris_test_data.csv'

離線批服務（Offline Batch Serving）

上述編程訪問部分中的所有三種方法都可以用於執行單機批量離線模型服務。取決於輸入數據的格式，如果輸入是一個list（即訓練時的一個batch），每一個元素表示一個獨立的輸入，那麼就支持batch處理。預測可以使用BentoService的Python API或Bash CLI命令啓動。這使得與 Apache Airflow和Celery等作業調度工具的集成變得非常容易。

對於集羣上運行的大型數據集上的批處理服務，BentoML團隊正在爲BentoService構建Apache Spark UDF加載器。此功能仍處於測試階段。如果您有興趣幫助測試或改進它，請與我們聯繫。

模型管理(Model Management)

默認情況下，BentoService#save會將所有BentoService保存的捆綁文件保存在$/bentoml/repository/$目錄下，然後將服務名稱和服務版本保存爲子目錄名稱。保存的BentoService的所有元數據都存儲在~/bentoml/storage.db的本地SQLite數據庫文件中.

用戶可以方便地查詢和使用他們創建的所有BentoService，例如，列出所有創建的BentoService：

> bentoml list
BENTO_SERVICE                                   AGE                  APIS                        ARTIFACTS
IrisClassifier:20200323212422_A1D30D            1 day and 22 hours   predict<DataframeHandler>   model<SklearnModelArtifact>
IrisClassifier:20200304143410_CD5F13            3 weeks and 4 hours  predict<DataframeHandler>   model<SklearnModelArtifact>
SentimentAnalysisService:20191219090607_189CFE  13 weeks and 6 days  predict<DataframeHandler>   model<SklearnModelArtifact>
TfModelService:20191216125343_06BCA3            14 weeks and 2 days  predict<JsonHandler>        model<TensorflowSavedModelArtifact>

> bentoml get IrisClassifier
BENTO_SERVICE                         CREATED_AT        APIS                       ARTIFACTS
IrisClassifier:20200121114004_360ECB  2020-01-21 19:45  predict<DataframeHandler>  model<SklearnModelArtifact>
IrisClassifier:20200121114004_360ECB  2020-01-21 19:40  predict<DataframeHandler>  model<SklearnModelArtifact>

> bentoml get IrisClassifier:20200323212422_A1D30D
{
  "name": "IrisClassifier",
  "version": "20200323212422_A1D30D",
  "uri": {
    "type": "LOCAL",
    "uri": "/Users/chaoyu/bentoml/repository/IrisClassifier/20200323212422_A1D30D"
  },
  "bentoServiceMetadata": {
    "name": "IrisClassifier",
    "version": "20200323212422_A1D30D",
    "createdAt": "2020-03-24T04:24:39.517239Z",
    "env": {
      "condaEnv": "name: bentoml-IrisClassifier\nchannels:\n- defaults\ndependencies:\n- python=3.7.5\n- pip\n",
      "pipDependencies": "bentoml==0.6.3\nscikit-learn",
      "pythonVersion": "3.7.5"
    },
    "artifacts": [
      {
        "name": "model",
        "artifactType": "SklearnModelArtifact"
      }
    ],
    "apis": [
      {
        "name": "predict",
        "handlerType": "DataframeHandler",
        "docs": "BentoService API",
        "handlerConfig": {
          "output_orient": "records",
          "orient": "records",
          "typ": "frame",
          "is_batch_input": true,
          "input_dtypes": null
        }
      }
    ]
  }
}

類似地，可以使用Bento名稱和版本名稱，直接加載和運行這些BentoService。例如：

> bentoml serve IrisClassifier:latest
* Serving Flask app "IrisClassifier" (lazy loading)
* Environment: production
  WARNING: This is a development server. Do not use it in a production deployment.
  Use a production WSGI server instead.
* Debug mode: off
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

> bentoml run IrisClassifier:latest predict --input='[[5.1, 3.5, 1.4, 0.2]]'
[0]

自定義模型儲存庫（Customizing Model Repository）

BentoML有一個獨立的組件YataiService，用於處理模型存儲和部署。BentoML默認使用本地YataiService實例，該實例將BentoService文件保存到$\sim$/BentoML/repository/，並將其他元數據保存到~/BentoML/storage.db.

用戶還可以自定義此項以使其適用於團隊設置，從而使數據科學家團隊能夠輕鬆地共享、使用和部署彼此創建的模型和預測服務。爲此，用戶需要從BentoML cli命令yatai-service-start設置運行YataiService的主機服務器：

> bentoml yatai-service-start --help
Usage: bentoml yatai-service-start [OPTIONS]

  Start BentoML YataiService for model management and deployment

Options:
  --db-url TEXT         Database URL following RFC-1738, and usually can
                        include username, password, hostname, database name as
                        well as optional keyword arguments for additional
                        configuration
  --repo-base-url TEXT  Base URL for storing saved BentoService bundle files,
                        this can be a filesystem path(POSIX/Windows), or an S3
                        URL, usually starts with "s3://"
  --grpc-port INTEGER   Port for Yatai server
  --ui-port INTEGER     Port for Yatai web UI
  --ui / --no-ui        Start BentoML YataiService without Web UI
  -q, --quiet           Hide all warnings and info logs
  --verbose, --debug    Show debug logs when running the command
  --help                Show this message and exit.

BentoML爲運行YataiService提供了一個預先構建的docker鏡像。對於每一個BentoML版本，一個新的鏡像將被推送到bentoml/yatai-service服務下的docker hub，鏡像標籤與PyPI包版本相同。例如，使用以下命令啓動BentoML版本0.7.2的YataiService，從本地~/BentoML目錄下的本地BentoML存儲庫加載數據：

> docker run -v ~/bentoml:/bentoml \
    -p 3000:3000 \
    -p 50051:50051 \
    bentoml/yatai-service:0.7.2 \
    --db-url=sqlite:///bentoml/storage.db \
    --repo-base-url=/bentoml/repository

爲團隊部署YataiService的推薦方法用一個遠程PostgreSQL數據庫和S3存儲數據庫。例如，部署以下docker容器以運行配置有遠程數據庫和S3存儲的YataiService，以及用於管理在AWS上創建的部署的AWS憑據：

> docker run -p 3000:3000 -p 50051:50051 \
    -e AWS_SECRET_ACCESS_KEY=... -e AWS_ACCESS_KEY_ID=...  \
    bentoml/yatai-service:0.7.2 \
    --db-url postgresql://scott:tiger@localhost:5432/bentomldb \
    --repo-base-url s3://my-bentoml-repo/

* Starting BentoML YataiService gRPC Server
* Debug mode: off
* Web UI: running on http://127.0.0.1:3000
* Running on 127.0.0.1:50051 (Press CTRL+C to quit)
* Usage: `bentoml config set yatai_service.url=127.0.0.1:50051`
* Help and instructions: https://docs.bentoml.org/en/latest/guides/yatai_service.html
* Web server log can be found here: /Users/chaoyu/bentoml/logs/yatai_web_server.log

部署YataiService服務器後，獲取服務器IP地址並運行以下命令，將BentoML客戶端配置爲使用此遠程YataiService進行模型管理和部署。您需要將127.0.0.1替換爲您的團隊可以訪問的IP地址或URL:

bentoml config set yatai_service.url=127.0.0.1:50051

運行上述命令後，所有BentoML模型管理操作都將發送到遠程服務器，包括保存BentoService、查詢保存的BentoServices或創建模型服務部署。

注意：
BentoML的YataiService不提供任何身份驗證。爲了保護您的部署，我們建議您只允許您的數據科學團隊訪問VPC中的服務器。BentoML團隊還爲企業團隊提供託管YataiService，該團隊內置了所有在實踐中的最安全的配置，以引導端到端模型管理和模型服務部署工作流。請與我們聯繫以瞭解有關我們產品的更多信息。