Déployer et évaluer un modèle de Machine Learning à l’aide d’un point de terminaison en ligne

  • Article
  • 38 minutes pour lire

S’APPLIQUE À :Extension Azure ML CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (préversion)

Découvrez comment utiliser un point de terminaison en ligne pour déployer votre modèle sans créer ni gérer l’infrastructure sous-jacente. Vous allez commencer par déployer un modèle sur votre ordinateur local pour déboguer les erreurs éventuelles, puis vous allez le déployer et le tester dans Azure.

Vous allez également apprendre à afficher les journaux et à surveiller le contrat de niveau de service (SLA). Vous commencez avec un modèle et obtenez un point de terminaison HTTPS/REST évolutif qui peut être utilisé pour la notation en ligne et en temps réel.

Les points de terminaison en ligne sont des points de terminaison utilisés pour l’inférence en ligne (en temps réel). Il existe deux types de points de terminaison en ligne : les points de terminaison en ligne managés et les points de terminaison en ligne Kubernetes. Pour plus d’informations sur les points de terminaison et les différences entre les points de terminaison en ligne managés et les points de terminaison en ligne Kubernetes, consultez Qu’est-ce que les points de terminaison Azure Machine Learning ?.

Les points de terminaison en ligne managés vous aident à déployer vos modèles de ML dans un mode clé en main. Les points de terminaison en ligne managés fonctionnent avec des ordinateurs de processeur et GPU puissants dans Azure de manière évolutive et entièrement gérée. Les points de terminaison en ligne gérés prennent en charge la fourniture, la mise à l’échelle et le monitoring de vos modèles, ce qui vous évite la surcharge liée à la configuration et à la gestion de l’infrastructure sous-jacente.

L’exemple principal de ce document utilise des points de terminaison en ligne managés pour le déploiement. Pour utiliser Kubernetes à la place, consultez les notes dans ce document en ligne avec la discussion sur le point de terminaison en ligne managé.

Conseil

Pour créer des points de terminaison en ligne managés dans Azure Machine Learning studio, consultez Utilisation de points de terminaison en ligne managés dans le studio.

Prérequis

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

  • Les contrôles d’accès en fonction du rôle Azure (Azure RBAC) sont utilisés pour accorder l’accès aux opérations dans Azure Machine Learning. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit avoir le rôle Propriétaire ou Contributeur sur l’espace de travail Azure Machine Learning, ou un rôle personnalisé autorisant Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Pour plus d’informations, consultez Gérer l’accès à un espace de travail Azure Machine Learning.

  • Si vous n’avez pas encore défini les paramètres par défaut pour l’interface CLI Azure, enregistrez vos paramètres par défaut. Pour éviter de transmettre plusieurs fois les valeurs de votre abonnement, de votre espace de travail et de votre groupe de ressources, exécutez le code suivant :

    az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>

  • (Facultatif) Pour déployer localement, vous devez installer Moteur Docker sur votre ordinateur local. Nous recommandons fortement cette option pour déboguer les problèmes plus facilement.

Important

Les exemples cités dans ce document partent du principe que vous utilisez un interpréteur de commandes Bash. Par exemple, à partir d’un système Linux ou d’un Sous-système Windows pour Linux.

Préparer votre système

Clonez l’exemple de dépôt

Pour suivre cet article, commencez par cloner le référentiel d’exemples (azureml-examples). Ensuite, exécutez le code suivant pour accéder au répertoire d’exemples :

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

Conseil

Utilisez --depth 1 pour cloner uniquement le dernier commit dans le dépôt, ce qui réduit le temps nécessaire à l’exécution de l’opération.

Définir un nom d’un point de terminaison

Pour définir un nom de point de terminaison, exécutez la commande suivante (remplacez YOUR_ENDPOINT_NAME par un nom unique).

Pour UNIX, exécutez la commande suivante :

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Notes

Les noms de points de terminaison doivent être uniques au sein d’une région Azure. Par exemple, dans la région Azure westus2, il ne peut y avoir qu’un seul point de terminaison avec le nom my-endpoint.

Définition du point de terminaison et du déploiement

L’extrait de code suivant montre le fichier endpoints/online/managed/sample/endpoint.yml :

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

Notes

Pour obtenir une description complète du YAML, consultez Informations de référence du schéma YAML de point de terminaison en ligne.

La référence pour le format YAML du point de terminaison est décrite dans le tableau suivant. Pour savoir comment spécifier ces attributs, consultez l’exemple YAML dans Préparez votre système ou la référence YAML du point de terminaison en ligne. Pour plus d’informations sur les limites associées aux points de terminaison managés, consultez Gérer et augmenter les quotas pour les ressources avec Azure Machine Learning.

Clé Description
$schema (Facultatif) Schéma YAML. Pour visualiser toutes les options disponibles dans le fichier YAML, vous pouvez visualiser le schéma dans l’exemple précédent dans un navigateur.
name Nom du point de terminaison. Il doit être unique au sein de la région Azure.
Les règles de nommage sont définies sous les limites du point de terminaison en ligne managé.
auth_mode Utilisez key pour l’authentification basée sur les clés. Utilisez aml_token pour l’authentification Azure Machine Learning basée sur les jetons. key n’expire pas mais aml_token expire. (Récupérez le jeton le plus récent avec la commande az ml online-endpoint get-credentials.)

L’exemple contient tous les fichiers nécessaires pour déployer un modèle sur un point de terminaison en ligne. Pour déployer un modèle, vous devez disposer des éléments suivants :

  • Fichiers de modèle (ou le nom et la version d’un modèle déjà inscrit dans votre espace de travail). Dans l’exemple, nous avons un modèle scikit-learn qui effectue une régression.
  • Code requis pour évaluer le modèle. Dans ce cas, nous disposons d’un fichier score.py.
  • Environnement dans lequel votre modèle s’exécute. Comme vous le verrez, l’environnement peut être une image Docker avec les dépendances Conda, ou il peut s’agir d’un fichier Dockerfile.
  • Paramètres pour spécifier le type d’instance et la capacité de mise à l’échelle.

L’extrait de code suivant montre le fichier endpoints/online/managed/sample/blue-deployment.yml, avec toutes les entrées requises :

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my-endpoint
model:
  path: ../../model-1/model/
code_configuration:
  code: ../../model-1/onlinescoring/
  scoring_script: score.py
environment: 
  conda_file: ../../model-1/environment/conda.yml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
instance_type: Standard_DS3_v2
instance_count: 1

Le tableau décrit les attributs d’un deployment :

Clé Description
name Le nom du déploiement.
model Dans cet exemple, nous spécifions les propriétés de modèle inline : path. Les fichiers de modèle sont automatiquement téléchargés et enregistrés avec un nom généré automatiquement. Pour connaître les meilleures pratiques associées, consultez les conseils dans la section suivante.
code_configuration.code.path Répertoire dans l’environnement de développement local qui contient tout le code source Python pour le scoring du modèle. Vous pouvez utiliser des répertoires et des packages imbriqués.
code_configuration.scoring_script Fichier Python qui se trouve dans le répertoire de scoring code_configuration.code.path dans l’environnement de développement local. Ce code Python doit avoir une fonction init() et une fonction run(). La fonction init() sera appelée une fois le modèle créé ou mis à jour (vous pouvez l’utiliser pour mettre en cache le modèle en mémoire, par exemple). La fonction run() est appelée à chaque appel du point de terminaison pour effectuer la notation et la prédiction réelles.
environment Contient les détails de l’environnement pour héberger le modèle et le code. Dans cet exemple, nous avons des définitions inline qui incluent le path. Nous utiliserons environment.docker.image pour l’image. Les dépendances conda_file seront installées au-dessus de l’image. Pour en savoir plus, consultez les conseils dans la section suivante.
instance_type Référence SKU de machine virtuelle pour héberger vos instances de déploiement. Pour plus d’informations, consultez Références SKU de machine virtuelle prises en charge par des points de terminaison en ligne managés.
instance_count Nombre d’instances dans le déploiement. Basez la valeur sur la charge de travail que vous attendez. Pour une haute disponibilité, nous vous recommandons de définir instance_count sur au moins 3. Nous réservons 20 % en plus pour effectuer des mises à niveau. Pour plus d’informations, consultez les quotas de point de terminaison en ligne managé.

Pendant le déploiement, les fichiers locaux comme la source Python du modèle de scoring sont chargés à partir de l’environnement de développement.

Pour plus d’informations sur le schéma YAML, consultez le document Référence YAML sur les points de terminaison en ligne.

Notes

Pour utiliser Kubernetes comme cible de calcul à la place des points de terminaison gérés :

  1. Créez et attachez votre cluster Kubernetes comme cible de calcul à votre espace de travail Azure Machine Learning avec Azure Machine Learning Studio.
  2. Utilisez le code YAML de point de terminaison pour cibler Kubernetes à la place du code YAML de point de terminaison géré. Vous devrez modifier le code YAML pour remplacer la valeur de target par le nom de votre cible de calcul inscrite. Vous pouvez utiliser ce fichier deployment.yaml qui a des propriétés supplémentaires applicables au déploiement Kubernetes.

Toutes les commandes utilisées dans cet article (à l’exception de la surveillance du contrat SLA facultative et de l’intégration d’Azure Log Analytics) peuvent être utilisées avec des points de terminaison gérés ou avec des points de terminaison Kubernetes.

Enregistrement séparé de votre modèle et de votre environnement

Dans cet exemple, nous spécifions le path (l’emplacement à partir duquel charger les fichiers) inline. L’interface CLI charge automatiquement les fichiers et inscrit le modèle et l’environnement. En guise de bonne pratique pour la production, vous devez inscrire le modèle et l’environnement et spécifier séparément le nom et la version inscrits dans le code YAML. Utilisez le formulaire model: azureml:my-model:1 ou environment: azureml:my-env:1.

Pour effectuer l’inscription, vous pouvez extraire les définitions YAML de model et environment dans des fichiers YAML distincts et utiliser les commandes az ml model create et az ml environment create. Pour en savoir plus sur ces commandes, exécutez az ml model create -h et az ml environment create -h.

Utilisation de différents types d’instances de processeur et GPU

Le code YAML ci-dessus utilise un type à usage général (Standard_DS2_v2) et une image Docker non GPU (dans le code YAML, reportez-vous à l’attribut image). Pour le calcul GPU, choisissez une référence SKU de type de calcul GPU et une image Docker GPU.

Pour connaître les types d’instances à usage général et GPU pris en charge, consultez les SKU de machine virtuelle prises en charge par des points de terminaison en ligne managés. Pour obtenir la liste des images de base de processeur et GPU d’Azure ML, consultez Images de base Azure Machine Learning.

Notes

Pour utiliser Kubernetes au lieu de points de terminaison gérés en tant que cible de calcul, consultez Présentation de la cible de calcul Kubernetes.

Utilisation de plusieurs modèles

Actuellement, vous pouvez spécifier un seul modèle par déploiement dans le code YAML. Si vous avez plusieurs modèles, quand vous inscrivez le modèle, copiez tous les modèles sous forme de fichiers ou de sous-répertoires dans un dossier que vous utilisez pour l’inscription. Dans votre script de notation, utilisez la variable d’environnement AZUREML_MODEL_DIR pour récupérer le chemin d’accès au dossier racine du modèle. La structure de répertoire sous-jacente est conservée. Pour obtenir un exemple de déploiement de plusieurs modèles dans un même déploiement, consultez Déployer plusieurs modèles sur un même déploiement.

Conseil

Si vous avez plus de 1 500 fichiers à inscrire, vous pouvez envisager de compresser les fichiers ou sous-répertoires au format .tar.gz lors de l’inscription du modèle. Pour utiliser les modèles, vous pouvez décompresser les fichiers ou sous-répertoires dans la fonction init() du script de scoring. Lorsque vous inscrivez le modèle, vous pouvez également définir la propriété azureml.unpack sur True, ce qui autorise la décompression automatique. Dans les deux cas, la décompression se produit une fois dans l’étape d’initialisation.

Comprendre le script de scoring

Conseil

Le format du script de scoring pour les points de terminaison en ligne est le même que celui utilisé dans la version précédente de l’interface CLI et dans le SDK Python.

Comme spécifié plus tôt, le script spécifié dans code_configuration.scoring_script doit avoir une fonction init() et une fonction run().

Cet exemple utilise le fichier score.py :score.py

import os
import logging
import json
import numpy
import joblib


def init():
    """
    This function is called when the container is initialized/started, typically after create/update of the deployment.
    You can write the logic here to perform init operations like caching the model in memory
    """
    global model
    # AZUREML_MODEL_DIR is an environment variable created during deployment.
    # It is the path to the model folder (./azureml-models/$MODEL_NAME/$VERSION)
    # Please provide your model's folder name if there is one
    model_path = os.path.join(
        os.getenv("AZUREML_MODEL_DIR"), "model/sklearn_regression_model.pkl"
    )
    # deserialize the model file back into a sklearn model
    model = joblib.load(model_path)
    logging.info("Init complete")


def run(raw_data):
    """
    This function is called for every invocation of the endpoint to perform the actual scoring/prediction.
    In the example we extract the data from the json input and call the scikit-learn model's predict()
    method and return the result back
    """
    logging.info("model 1: request received")
    data = json.loads(raw_data)["data"]
    data = numpy.array(data)
    result = model.predict(data)
    logging.info("Request processed")
    return result.tolist()

La fonction init() est appelée lorsque le conteneur est initialisé ou démarré. Cette initialisation se produit généralement peu après la création ou la mise à jour du déploiement. Écrivez la logique ici pour effectuer des opérations d’initialisation globales telles que la mise en cache du modèle en mémoire (comme dans cet exemple). La fonction run() est appelée à chaque appel du point de terminaison et doit effectuer la notation et la prédiction réelles. Dans l’exemple, nous extrayons les données de l’entrée JSON, appelons la méthode predict() du modèle scikit-learn et retournons le résultat.

Déployer et déboguer localement à l’aide de points de terminaison locaux

Pour gagner du temps lors du débogage, il est fortement recommandé d’effectuer une série de tests localement sur votre point de terminaison. Pour plus d’informations, consultez Déboguer les points de terminaison en ligne localement dans Visual Studio Code.

Notes

  • Pour déployer localement, vous devez avoir installé le moteur Docker.
  • Le moteur Docker doit être en cours d’exécution. Le moteur Docker démarre généralement au démarrage de l’ordinateur. Si ce n’est pas le cas, vous pouvez dépanner le Moteur Docker.

Important

L’objectif d’un déploiement de points de terminaison local consiste à valider et déboguer votre code et votre configuration avant le déploiement sur Azure. Un déploiement local présente les limitations suivantes :

  • Les points de terminaison locaux ne prennent pas en charge les règles de trafic, l’authentification ni les paramètres de sonde.
  • Les points de terminaison locaux ne prennent en charge qu’un seul déploiement par point de terminaison.
  • Les points de terminaison locaux ne prennent pas en charge les modèles inscrits. Pour utiliser des modèles déjà inscrits, vous pouvez les télécharger à l’aide de l’interface CLI ou du kit de développement logiciel (SDK) et y faire référence dans la définition de déploiement.

Conseil

Vous pouvez utiliser le package Python du serveur HTTP d’inférence Azure Machine Learning pour déboguer votre script de scoring localement sans moteur Docker. Le débogage avec le serveur d’inférence vous aide à déboguer le script de scoring avant le déploiement sur des points de terminaison locaux afin de pouvoir déboguer sans être affecté par les configurations de conteneur de déploiement.

Déployer le modèle localement

Tout d’abord, créez un point de terminaison. Si vous le souhaitez, pour un point de terminaison local, vous pouvez ignorer cette étape et créer directement le déploiement (étape suivante), qui créera ensuite les métadonnées requises. Le déploiement de modèles localement est utile à des fins de développement et de test.

az ml online-endpoint create --local -n $ENDPOINT_NAME -f endpoints/online/managed/sample/endpoint.yml

À présent, créez un déploiement nommé blue sous le point de terminaison.

az ml online-deployment create --local -n blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment.yml

L’indicateur --local oriente l’interface CLI pour déployer le point de terminaison dans l’environnement Docker.

Conseil

Utilisez Visual Studio Code pour tester et déboguer vos points de terminaison localement. Pour plus d’informations, consultez Déboguer les points de terminaison en ligne localement dans Visual Studio Code.

Vérifier si le déploiement local a réussi

Vérifiez l’état pour voir si le modèle a été déployé sans erreur :

az ml online-endpoint show -n $ENDPOINT_NAME --local

Le résultat doit ressembler au JSON suivant. Le provisioning_state est Succeeded.

{
  "auth_mode": "key",
  "location": "local",
  "name": "docs-endpoint",
  "properties": {},
  "provisioning_state": "Succeeded",
  "scoring_uri": "http://localhost:49158/score",
  "tags": {},
  "traffic": {}
}

Le tableau suivant contient les valeurs possibles de provisioning_state :

State Description
Creating La ressource est en cours de création.
Mise à jour La ressource est en cours de mise à jour.
Suppression en cours La ressource est en cours de suppression.
Réussi L’opération de création/mise à jour a réussi.
Échec L’opération de création/mise à jour/suppression a échoué.

Appeler le point de terminaison local pour effectuer la notation des données avec votre modèle

Appelez le point de terminaison pour effectuer la notation du modèle à l’aide de la commande pratique invoke et en transmettant les paramètres de requête stockés dans un fichier JSON :

az ml online-endpoint invoke --local --name $ENDPOINT_NAME --request-file endpoints/online/model-1/sample-request.json

Si vous souhaitez utiliser un client REST (par exemple, une boucle), vous devez disposer de l’URI de notation. Pour récupérer l’URI de notation, exécutez az ml online-endpoint show --local -n $ENDPOINT_NAME. Dans les données retournées, recherchez l’attribut scoring_uri. Des exemples de commandes curl sont disponibles plus loin dans ce document.

Rechercher dans les journaux la sortie de l’opération d’appel

Dans l’exemple fichier score.py, la méthode run() journalise une sortie dans la console.

Vous pouvez afficher cette sortie en utilisant la commande get-logs :

az ml online-deployment get-logs --local -n blue --endpoint $ENDPOINT_NAME

Déployer votre point de terminaison en ligne dans Azure

Ensuite, déployez votre point de terminaison en ligne dans Azure.

Déployer sur Azure

Pour créer le point de terminaison dans le cloud, exécutez le code suivant :

az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/managed/sample/endpoint.yml

Pour créer le déploiement nommé blue sous le point de terminaison, exécutez le code suivant :

az ml online-deployment create --name blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment.yml --all-traffic

Ce déploiement peut prendre jusqu’à 15 minutes selon que l’environnement ou l’image sous-jacent(e) est généré(e) pour la première fois ou non. Les déploiements suivants qui utilisent le même environnement termineront le traitement plus rapidement.

Conseil

  • Si vous préférez ne pas bloquer votre console CLI, vous pouvez ajouter l’indicateur --no-wait à la commande. Toutefois, cela arrêtera l’affichage interactif de l’état du déploiement.

Important

L’indicateur --all-traffic dans az ml online-deployment create ci-dessus alloue 100 % du trafic au point de terminaison pour le déploiement nouvellement créé. Bien que cela soit utile à des fins de développement et de test, pour la production, vous souhaiterez peut-être ouvrir le trafic vers le nouveau déploiement via une commande explicite. Par exemple : az ml online-endpoint update -n $ENDPOINT_NAME --traffic "blue=100"

Conseil

Vérifiez l’état du point de terminaison

La commande show contient des informations dans provisioning_status pour le point de terminaison et le déploiement :

az ml online-endpoint show -n $ENDPOINT_NAME

Vous pouvez répertorier tous les points de terminaison dans l’espace de travail sous la forme d’un tableau à l’aide de la commande list :

az ml online-endpoint list --output table

Vérifier l’état du déploiement en ligne

Vérifiez les journaux pour voir si le modèle a été déployé sans erreur :

az ml online-deployment get-logs --name blue --endpoint $ENDPOINT_NAME

Par défaut, les journaux sont extraits du serveur d’inférence. Pour afficher les journaux de l’initialiseur de stockage (lequel monte des ressources telles que le modèle et le code dans le conteneur), ajoutez l’indicateur --container storage-initializer.

Pour plus d’informations sur les journaux de déploiement, consultez Obtenir des journaux de conteneur.

Appeler le point de terminaison pour effectuer la notation des données avec votre modèle

Vous pouvez utiliser la commande invoke ou un client REST de votre choix pour appeler le point de terminaison et effectuer le scoring de certaines données :

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/model-1/sample-request.json

L’exemple suivant montre comment récupérer la clé utilisée pour l’authentification auprès du point de terminaison :

Conseil

Vous pouvez contrôler les principaux de sécurité Azure Active Directory qui peuvent obtenir la clé d’authentification en leur attribuant un rôle personnalisé qui autorise Microsoft.MachineLearningServices/workspaces/onlineEndpoints/token/action et Microsoft.MachineLearningServices/workspaces/onlineEndpoints/listkeys/action. Pour plus d’informations, consultez Gérer l’accès à un espace de travail Azure Machine Learning.

ENDPOINT_KEY=$(az ml online-endpoint get-credentials -n $ENDPOINT_NAME -o tsv --query primaryKey)

Ensuite, utilisez la boucle pour noter les données.

SCORING_URI=$(az ml online-endpoint show -n $ENDPOINT_NAME -o tsv --query scoring_uri)

curl --request POST "$SCORING_URI" --header "Authorization: Bearer $ENDPOINT_KEY" --header 'Content-Type: application/json' --data @endpoints/online/model-1/sample-request.json

Notez que nous utilisons les commandes show et get-credentials pour récupérer les informations d’authentification. Notez également que nous utilisons l’indicateur --query pour filtrer les attributs sur les attributs nécessaires uniquement. Pour en apprendre davantage sur --query consultez Interroger la sortie de commande Azure CLI.

Pour visualiser les journaux d’appel, exécutez get-logs de nouveau.

Pour plus d’informations sur l’authentification avec un jeton, consultez S’authentifier sur des points de terminaison en ligne.

(Facultatif) Mettre à jour le déploiement

Si vous souhaitez mettre à jour le code, le modèle ou l’environnement, mettez à jour le fichier YAML et exécutez la commande az ml online-endpoint update.

Notes

Si vous mettez à jour le nombre d’instances, ainsi que d’autres paramètres de modèle (code, modèle ou environnement) dans une même commande update : la première opération de mise à l’échelle est effectuée, puis les autres mises à jour sont appliquées. Dans l’environnement de production, il est conseillé d’effectuer ces opérations séparément.

Pour comprendre comment update fonctionne :

  1. Ouvrez le fichier online/model-1/onlinescoring/score.py.

  2. Modifiez la dernière ligne de la fonction init() : après logging.info("Init complete"), ajoutez logging.info("Updated successfully").

  3. Enregistrez le fichier .

  4. Exécutez cette commande :

    az ml online-deployment update -n blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment.yml

    Notes

    La mise à jour à l’aide de YAML est déclarative. Autrement dit, les modifications apportées dans le fichier YAML seront reflétées dans les ressources du Gestionnaire de ressource Azure sous-jacentes (points de terminaison et déploiements). Une approche déclarative facilite les GitOps : Toutes les modifications apportées aux points de terminaison et déploiements passent (même instance_count) par le fichier YAML.

    Conseil

    Avec la commande update, vous pouvez utiliser le paramètre --set disponible dans l’interface CLI Azure pour remplacer des attributs dans votre code YAML ou pour définir des attributs spécifiques sans transmettre le fichier YAML. L’utilisation de --set pour les attributs uniques est particulièrement importante dans les scénarios de développement et de test. Par exemple, pour effectuer un scale-up de la valeur instance_count pour le premier déploiement, vous pouvez utiliser l’indicateur --set instance_count=2. Toutefois, étant donné que le code YAML n’est pas mis à jour, cette technique ne facilite pas les GitOps.

  5. Comme vous avez modifié la fonction init() (init()qui s’exécute lors de la création ou de la mise à jour du point de terminaison), le message Updated successfully figurera dans les journaux. Récupérez les journaux en exécutant :

    az ml online-deployment get-logs --name blue --endpoint $ENDPOINT_NAME

La commande update fonctionne également avec les déploiements locaux. Utilisez la même commande az ml online-deployment update avec l’indicateur --local.

Notes

Vous trouverez ci-après un exemple de mise à niveau propagée sur place.

  • Pour le point de terminaison en ligne managé, le même déploiement est mis à jour avec la nouvelle configuration et 20 % de nœuds à la fois, c’est-à-dire, si le déploiement a 10 nœuds, 2 nœuds à la fois seront mis à jour.
  • Pour le point de terminaison en ligne Kubernetes, le système itère une instance de déploiement avec la nouvelle configuration et supprime l’ancienne.
  • Pour l’utilisation en production, vous souhaiterez peut-être envisager un déploiement bleu-vert, qui offre une alternative plus sûre.

(Facultatif) Configurer la mise à l’échelle automatique

La mise à l’échelle automatique exécute automatiquement la quantité appropriée de ressources pour gérer la charge sur votre application. Les points de terminaison en ligne managés prennent en charge la mise à l’échelle automatique via l’intégration à la fonctionnalité de mise à l’échelle automatique d’Azure Monitor. Pour configurer la mise à l’échelle automatique, consultez Mise à l’échelle automatique des points de terminaison en ligne.

(Facultatif) Surveiller le contrat SLA à l’aide d’Azure Monitor

Pour afficher les mesures et définir des alertes en fonction de votre contrat SLA, suivez les étapes décrites dans Analyser les points de terminaison en ligne.

(Facultatif) Intégrer à Log Analytics

La commande get-logs pour CLI ou la méthode get_logs pour SDK ne fournit que les quelques dernières centaines de lignes de journaux d’une instance sélectionnée automatiquement. Toutefois, Log Analytics offre un moyen de stocker et d’analyser durablement les journaux. Pour plus d’informations sur l’utilisation de la journalisation, consultez Analyser les points de terminaison en ligne

Comment configurer des e-mails dans studio

Pour commencer à recevoir des e-mails lorsque votre travail, point de terminaison en ligne ou point de terminaison de lot est terminé ou s’il existe un problème (échec, annulation), suivez les instructions suivantes :

  1. Dans Azure ML Studio, accédez aux paramètres en sélectionnant l’icône d’engrenage.
  2. Sélectionnez l’onglet Notifications par e-mail.
  3. Activez ou désactivez les notifications par e-mail pour un événement spécifique.

Capture d’écran des paramètres d’Azure ML Studio sous l’onglet Notifications par e-mail.

Supprimez le point de terminaison et le déploiement

Si vous n’envisagez pas d’utiliser le déploiement, vous devez le supprimer en exécutant le code suivant (cela supprime le point de terminaison et tous les déploiements sous-jacents) :

az ml online-endpoint delete --name $ENDPOINT_NAME --yes --no-wait

Étapes suivantes

Essayez un déploiement sécurisé de vos modèles à l’étape suivante :

Pour en savoir plus, consultez les articles suivants :