Verwenden eines benutzerdefinierten Containers zum Bereitstellen eines Modells für einen Onlineendpunkt

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

Erfahren Sie, wie Sie einen benutzerdefinierten Container zum Bereitstellen eines Modells für einen Onlineendpunkt in Azure Machine Learning verwenden.

Benutzerdefinierte Containerbereitstellungen können andere Webserver als den standardmäßigen Python Flask-Server verwenden, der von Azure Machine Learning verwendet wird. Benutzer dieser Bereitstellungen können weiterhin die Vorteile der in Azure Machine Learning integrierten Überwachung, Skalierung, Warnungen und Authentifizierung nutzen.

In der folgenden Tabelle sind verschiedene Bereitstellungsbeispiele aufgeführt, die benutzerdefinierte Container wie TensorFlow Serving, TorchServe, Triton Inference Server, Plumber R-Paket und Azure Machine Learning Inference Minimal-Image verwenden.

In diesem Artikel wird die Bereitstellung eines TensorFlow-Modells mit TensorFlow (TF) Serving behandelt.

Voraussetzungen

Stellen Sie vor dem Ausführen der Schritte in diesem Artikel sicher, dass Sie über die folgenden erforderlichen Komponenten verfügen:

• Ein Azure Machine Learning-Arbeitsbereich. Wenn keiner vorliegt, führen Sie die Schritte unter Schnellstart: Erstellen von Arbeitsbereichsressourcen aus, um einen Arbeitsbereich zu erstellen.

• Die Azure CLI und die ml-Erweiterung oder das Azure Machine Learning Python SDK v2:

  • Informationen zum Installieren der Azure CLI und der Erweiterung finden Sie unter Installieren, Einrichten und Verwenden der CLI (v2).

    Wichtig

    In den CLI-Beispielen in diesem Artikel wird davon ausgegangen, dass Sie die Bash-Shell (oder eine kompatible Shell) verwenden, beispielsweise über ein Linux-System oder ein Windows-Subsystem für Linux.

  • Verwenden Sie zum Installieren des Python SDK v2 den folgenden Befehl:

    pip install azure-ai-ml azure-identity
    

    Verwenden Sie den folgenden Befehl, um eine vorhandene Installation des SDK auf die neueste Version zu aktualisieren:

    pip install --upgrade azure-ai-ml azure-identity
    

    Weitere Informationen finden Sie unter Installieren des Python SDK v2 für Azure Machine Learning.

• Sie oder der von Ihnen verwendete Dienstprinzipal muss über Zugriff für Mitwirkende auf die Azure-Ressourcengruppe verfügen, die Ihren Arbeitsbereich enthält. Sie verfügen über eine solche Ressourcengruppe, wenn Sie Ihren Arbeitsbereich gemäß dem Schnellstartartikel konfiguriert haben.

• Für die lokale Bereitstellung muss die Docker-Engine lokal ausgeführt werden. Dieser Schritt wird dringend empfohlen. Er hilft Ihnen beim Debuggen von Problemen.

Herunterladen des Quellcodes

Klonen Sie den Quellcode von GitHub, um dieses Tutorial zu befolgen.

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Initialisieren von Umgebungsvariablen

Definieren von Umgebungsvariablen:

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Herunterladen eines TensorFlow-Modells

Laden Sie ein Modell herunter, das eine Eingabe durch zwei dividiert und dem Ergebnis 2 hinzufügt, und entzippen Sie es:

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Lokales Ausführen eines TF Serving-Images, um zu testen, ob es funktioniert

Verwenden Sie Docker, um Ihr Image lokal zum Testen auszuführen:

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Überprüfen, ob Sie Verfügbarkeits- und Bewertungsanforderungen an das Image senden können

Überprüfen Sie zunächst, ob der Container lebt, d. h. der Prozess noch im Container ausgeführt wird. Sie sollten eine „200 (OK)“-Antwort erhalten.

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Überprüfen Sie dann, ob Sie Vorhersagen zu Daten ohne Bezeichnung erhalten:

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

Beenden des Images

Nachdem Sie nun lokal getestet haben, beenden Sie das Image:

docker stop tfserving-test

Bereitstellen Ihres Onlineendpunkts in Azure

Stellen Sie als nächstes Ihren Onlineendpunkt in Azure bereit.

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: {{MODEL_VERSION}}
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/{{MODEL_VERSION}}
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
   ManagedOnlineEndpoint,
   ManagedOnlineDeployment,
   Model,
   Environment,
   CodeConfiguration,
)
from azure.identity import DefaultAzureCredential

# enter details of your Azure Machine Learning workspace
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AZUREML_WORKSPACE_NAME>"

# get a handle to the workspace
ml_client = MLClient(
   DefaultAzureCredential(), subscription_id, resource_group, workspace
)

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is a sample online endpoint",
    auth_mode="key",
    tags={"foo": "bar"},
)

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

In diesem YAML-/Python-Parameter sind einige wichtige Konzepte zu beachten:

Base image

Das Basisimage wird als Parameter in der Umgebung angegeben, und docker.io/tensorflow/serving:latest wird in diesem Beispiel verwendet. Beim Überprüfen des Containers können Sie feststellen, dass dieser Server ENTRYPOINT verwendet, um ein Einstiegspunktskript zu starten, das die Umgebungsvariablen (etwa MODEL_BASE_PATH und MODEL_NAME) verwendet und Ports (etwa 8501) verfügbar macht. Diese Details sind spezifische Informationen für diesen ausgewählten Server. Sie können diese Informationen zum Server nutzen, um zu ermitteln, wie die Bereitstellung definiert werden soll. Wenn Sie beispielsweise Umgebungsvariablen für MODEL_BASE_PATH und MODEL_NAME in der Bereitstellungsdefinition festlegen, übernimmt der Server (in diesem Fall TF Serving) die Werte, um den Server zu initiieren. Wenn Sie den Port für die Routen in der Bereitstellungsdefinition auf 8501 festlegen, wird die Benutzeranforderung an diese Routen ordnungsgemäß an den TF Serving-Server weitergeleitet.

Beachten Sie, dass dieses spezifische Beispiel auf dem TF Serving-Fall basiert. Sie können jedoch jeden Container verwenden, der aktiv ist und auf Anforderungen reagiert, die über Verfügbarkeits-, Bereitschafts- und Bewertungsrouten eingehen. Sie können in anderen Beispielen ansehen, wie das Dockerfile gebildet wird (z. B. mithilfe von CMD anstelle von ENTRYPOINT), um die Container zu erstellen.

Rückschlusskonfiguration

Die Rückschlusskonfiguration ist ein Parameter in der Umgebung und gibt den Port und den Pfad für drei Routentypen an: Verfügbarkeits-, Bereitschafts- und Bewertungsroute. Die Rückschlusskonfiguration ist erforderlich, wenn Sie Ihren eigenen Container mit verwaltetem Onlineendpunkt ausführen möchten.

Bereitschaftsroute im Vergleich zur Verfügbarkeitsroute

Der von Ihnen ausgewählte API-Server bietet u. U. eine Möglichkeit, den Status des Servers zu überprüfen. Es gibt zwei Routentypen, die Sie angeben können: Verfügbarkeit und Bereitschaft. Eine Verfügbarkeitsroute wird verwendet, um zu überprüfen, ob der Server ausgeführt wird. Eine Bereitschaftsroute wird verwendet, um zu prüfen, ob der Server bereit ist, zu arbeiten. Im Kontext von Rückschlüssen beim maschinellen Lernen kann ein Server mit „200 - OK“ auf eine Verfügbarkeitsanforderung reagieren, bevor ein Modell geladen wird, und der Server kann erst mit „200 - OK“ auf eine Bereitschaftsanforderung reagieren, nachdem das Modell in den Speicher geladen wurde.

Weitere Informationen zu Verfügbarkeits- und Bereitschaftstests im Allgemeinen finden Sie in der Kubernetes-Dokumentation.

Die Verfügbarkeits- und Bereitschaftsrouten werden vom API-Server Ihrer Wahl bestimmt, wie Sie beim lokalen Testen des Containers in einem früheren Schritt festgestellt haben. Beachten Sie, dass die Beispielbereitstellung in diesem Artikel sowohl für Verfügbarkeit als auch für Bereitschaft denselben Pfad verwendet, da TF Serving nur eine Verfügbarkeitsroute definiert. Verschiedene Muster zum Definieren der Routen finden Sie in anderen Beispielen.

Bewertungsroute

Der von Ihnen ausgewählte API-Server bietet eine Möglichkeit, die Nutzlast für die Arbeit zu empfangen. Im Kontext von Rückschlüssen beim maschinellen Lernen empfängt ein Server die Eingabedaten über eine bestimmte Route. Identifizieren Sie diese Route für Ihren API-Server beim lokalen Testen des Containers in einem früheren Schritt, und geben Sie diese an, wenn Sie die zu erstellende Bereitstellung definieren. Beachten Sie, dass die erfolgreiche Erstellung der Bereitstellung auch den Parameter „scoring_uri“ des Endpunkts aktualisiert, den Sie mit az ml online-endpoint show -n <name> --query scoring_uri überprüfen können.

Suchen des eingebundenen Modells

Wenn Sie ein Modell als Onlineendpunkt bereitstellen, bindet Azure Machine Learning Ihr Modell in Ihren Endpunkt ein. Mit der Modelleinbindung können Sie neue Versionen des Modells bereitstellen, ohne ein neues Docker-Image erstellen zu müssen. Standardmäßig befindet sich ein mit dem Namen foo und der Version 1 registriertes Modell im folgenden Pfad in Ihrem bereitgestellten Container: /var/azureml-app/azureml-models/foo/1

Wenn Sie beispielsweise über eine Verzeichnisstruktur von /azureml-examples/cli/endpoints/online/custom-container auf Ihrem lokalen Computer verfügen, auf dem der Name des Modells half_plus_two lautet:

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

Dann befindet sich Ihr Modell unter /var/azureml-app/azureml-models/tfserving-deployment/1 in Ihrer Bereitstellung:

Sie können Ihre model_mount_path optional konfigurieren. Sie können den Pfad ändern, in dem das Modell eingebunden ist.

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
.....

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    ...
)

Dann befindet sich Ihr Modell unter /var/tfserving-model-mount/tfserving-deployment/1 in Ihrer Bereitstellung. Beachten Sie, dass es sich nicht mehr unter azureml-app/azureml-models befindet, sondern unter dem von Ihnen angegebenen Einbindungspfad:

Erstellen Sie Ihren Endpunkt und die Bereitstellung

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving-endpoint.yml

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving-deployment.yml --all-traffic

ml_client.begin_create_or_update(endpoint)

ml_client.begin_create_or_update(blue_deployment)

Aufrufen des Endpunkts

Nachdem die Bereitstellung abgeschlossen ist, prüfen Sie, ob Sie eine Bewertungsanforderung an den bereitgestellten Endpunkt senden können.

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample-request.json",
)

Löschen des Endpunkts

Nachdem Sie ihren Endpunkt erfolgreich bewertet haben, können Sie ihn löschen:

az ml online-endpoint delete --name tfserving-endpoint

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Zugehöriger Inhalt

• Sicherer Rollout für Onlineendpunkte
• Problembehandlung bei der Bereitstellung von Onlineendpunkten
• Torchserve-Beispiel