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.

Beispiel	Skript (CLI)	BESCHREIBUNG
minimal/multimodel	deploy-custom-container-minimal-multimodel	Stellen Sie mehrere Modelle in einer einzelnen Bereitstellung bereit, indem Sie das Azure Machine Learning Inference Minimal-Image erweitern
minimal/single-model	deploy-custom-container-minimal-single-model	Stellen Sie ein einzelnes Modell bereit, indem Sie das Azure Machine Learning Inference Minimal-Image erweitern.
mlflow/multideployment-scikit	deploy-custom-container-mlflow-multideployment-scikit	Stellen Sie zwei MLFlow-Modelle mit unterschiedlichen Python-Anforderungen in zwei separaten Bereitstellungen hinter einem einzelnen Endpunkt mithilfe des Azure Machine Learning Inference Minimal-Images bereit.
r/multimodel-plumber	deploy-custom-container-r-multimodel-plumber	Bereitstellen von drei Regressionsmodellen auf einem Endpunkt mithilfe des Plumber R-Pakets
tfserving/half-plus-two	deploy-custom-container-tfserving-half-plus-two	Stellen Sie ein Half Plus Two-Modell mit einem benutzerdefinierten TensorFlow Serving-Container mithilfe des Standardverfahrens für die Modellregistrierung bereit.
tfserving/half-plus-two-integrated	deploy-custom-container-tfserving-half-plus-two-integrated	Stellen Sie ein Half Plus Two-Modell mit einem benutzerdefinierten TensorFlow Serving-Container mit dem in das Image integrierten Modell bereit.
torchserve/densenet	deploy-custom-container-torchserve-densenet	Bereitstellen eines einzelnen Modells mithilfe eines benutzerdefinierten TorchServe-Containers
torchserve/huggingface-textgen	deploy-custom-container-torchserve-huggingface-textgen	Bereitstellen von Hugging Face-Modellen auf einem Onlineendpunkt und Ausführen des TorchServe-Beispiels für Hugging Face Transformers
triton/single-model	deploy-custom-container-triton-single-model	Bereitstellen eines Triton-Modells mithilfe eines benutzerdefinierten Containers

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

Warnung

Microsoft kann möglicherweise nicht helfen, Probleme zu beheben, die durch ein benutzerdefiniertes Image verursacht werden. Wenn Sie auf Probleme stoßen, werden Sie möglicherweise aufgefordert, das Standardimage oder eines der von Microsoft bereitgestellten Images zu verwenden, um zu sehen, ob das Problem von Ihrem Image verursacht wird.

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.

Azure-Befehlszeilenschnittstelle

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

Python SDK

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

Weitere Informationen finden Sie auch im Beispiel-Notebook. Beachten Sie jedoch, dass der Abschnitt 3. Test locally im Notebook davon ausgeht, dass es unter dem azureml-examples/sdk-Verzeichnis ausgeführt wird.

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.

Azure-Befehlszeilenschnittstelle

Erstellen Sie eine YAML-Datei für Ihren Endpunkt und Ihr Bereitstellen.

Sie können Ihre Cloudbereitstellung mit YAML konfigurieren. Schauen Sie sich das YAML-Beispiel für dieses Beispiel an:

tfserving-endpoint.yml

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

tfserving-deployment.yml

$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

Python SDK

Herstellen einer Verbindung mit einem Azure Machine Learning-Arbeitsbereich

Stellen Sie eine Verbindung mit Ihrem Azure Machine Learning-Arbeitsbereich her, konfigurieren Sie Arbeitsbereichsdetails, und rufen Sie wie folgt einen Handle für den Arbeitsbereich ab:

1. Importieren Sie die erforderlichen Bibliotheken.

# 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

2. Konfigurieren von Arbeitsbereichsdetails und Abrufen eines Handles für den Arbeitsbereich:

# 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
)

Weitere Informationen erhalten Sie unter Bereitstellen von Machine Learning-Modellen für verwaltete Online-Endpunkte mit Python SDK v2.

Konfigurieren des Online-Endpunkts

Tipp

• name: Der Name des Endpunkts. Er muss in der Azure-Region eindeutig sein. Der Name eines Endpunkts muss mit einem Groß- oder Kleinbuchstaben beginnen und darf nur aus Bindestrichen (-) und alphanumerischen Zeichen bestehen. Weitere Informationen zu den Benennungsregeln finden Sie unter Endpunktgrenzwerte.
• auth_mode: Verwenden Sie key für die schlüsselbasierte Authentifizierung. Verwenden Sie aml_token für die tokenbasierte Azure Machine Learning-Authentifizierung. Ein key läuft nicht ab, dafür aber aml_token. Weitere Informationen zur Authentifizierung finden Sie unter Authentifizieren bei einem Onlineendpunkt.

Optional können Sie eine Beschreibung und Tags zu Ihrem Endpunkt hinzufügen.

# 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"},
)

Konfigurieren der Onlinebereitstellung

Eine Einrichtung ist ein Satz von Ressourcen, die für das Hosting des Modells erforderlich sind, das die eigentliche Inferenz durchführt. Erstellen Sie eine Bereitstellung für unseren Endpunkt mithilfe der ManagedOnlineDeployment-Klasse.

Tipp

• name – Name der Bereitstellung
• endpoint_name – Name des Endpunkts, unter dem die Bereitstellung erstellt werden soll.
• model – Das für die Bereitstellung zu verwendende Modell. Dieser Wert kann entweder ein Verweis auf ein vorhandenes versioniertes >-Modell im Arbeitsbereich oder eine Inline-Modellspezifikation sein.
• environment – Die für die Bereitstellung zu verwendende Umgebung. Dieser Wert kann entweder ein Verweis auf eine vorhandene versionierte >-Umgebung im Arbeitsbereich oder eine Inline-Umgebungsspezifikation sein.
• code_configuration – Die Konfiguration für den Quellcode und das Bewertungsskript.
  • path – Pfad zum Quellcodeverzeichnis für die Bewertung des Modells.
  • scoring_script – Relativer Pfad zur Bewertungsdatei im Quellcodeverzeichnis.
• instance_type – Die VM-Größe, die für die Bereitstellung verwendet werden soll. Eine Liste der unterstützten Größen finden Sie unter SKU-Liste für Endpunkte.
• instance_count – Die Anzahl der Instanzen, die für die Bereitstellung verwendet werden sollen.

# 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:

Bereitschaftsroute im Vergleich zur Verfügbarkeitsroute

Ein HTTP-Server definiert Pfade sowohl für Lebensfähigkeit als auch für 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 Machine Learning-Rückschluss könnte ein Server eine „200 OK“-Antwort auf eine Verfügbarkeitsanforderung geben, bevor er ein Modell lädt. Der Server kann erst dann mit „200 OK“ auf eine Bereitschaftsanforderung antworten, nachdem das Modell in den Arbeitsspeicher geladen wurde.

Weitere Informationen zu Live- und Bereitschaftstests finden Sie in der Kubernetes-Dokumentation.

Beachten Sie, dass diese Bereitstellung sowohl für Verfügbarkeit als auch für Bereitschaft denselben Pfad verwendet, da TF Serving nur eine Verfügbarkeitsroute definiert.

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:

Azure-Befehlszeilenschnittstelle

Und tfserving-deployment.yml enthält:

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

Python SDK

Und die Model-Klasse enthält:

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.

Wichtig

Bei model_mount_path muss es sich um einen gültigen absoluten Pfad in Linux (dem Betriebssystem des Container-Images) handeln.

Azure-Befehlszeilenschnittstelle

Sie können zum Beispiel model_mount_path Parameter in Ihrer tfserving-deployment.yml haben:

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

Python SDK

Sie können zum Beispiel model_mount_path-Parameter in Ihrer ManagedOnlineDeployment-Klasse haben:

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

Azure-Befehlszeilenschnittstelle

Nachdem Sie nun wissen, wie die YAML-Datei erstellt wurde, erstellen Sie Ihren Endpunkt.

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

Die Erstellung einer Bereitstellung kann einige Minuten dauern.

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

Python SDK

Mithilfe des zuvor erstellten MLClient erstellen Sie jetzt den Endpunkt im Arbeitsbereich. Dieser Befehl startet die Endpunkterstellung und gibt eine Bestätigungsantwort zurück, während die Endpunkterstellung fortgesetzt wird.

ml_client.begin_create_or_update(endpoint)

Erstellen Sie die Bereitstellung, indem Sie Folgendes ausführen:

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.

Azure-Befehlszeilenschnittstelle

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

Python SDK

Mithilfe des zuvor erstellten MLClient rufen Sie einen Handle für den Endpunkt ab. Der Endpunkt kann mithilfe des invoke Befehls mit den folgenden Parametern aufgerufen werden:

• endpoint_name – Name des Endpunkts
• request_file – Datei mit Anforderungsdaten
• deployment_name – Name der spezifischen Bereitstellung, die in einem Endpunkt getestet werden soll

Senden Sie eine Beispielanforderung mithilfe einer JSON-Datei. Die JSON-Beispieldatei befindet sich im Beispiel-Repository.

# 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:

Azure-Befehlszeilenschnittstelle

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

Python SDK

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