Mise à l'échelle automatique des points de terminaison en ligne dans Azure Machine Learning

Article
09/03/2024

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

Dans cet article, vous apprendrez à gérer l’utilisation des ressources dans un déploiement en configurant la mise à l’échelle automatique en fonction de métriques et de planifications. Le processus de mise à l'échelle automatique vous permet d'exécuter automatiquement la quantité appropriée de ressources pour gérer la charge de votre application. Les points de terminaison en ligne dans Azure Machine Learning prennent en charge la mise à l’échelle automatique via l’intégration avec la fonctionnalité de mise à l’échelle automatique dans Azure Monitor.

La mise à l’échelle automatique Azure Monitor vous permet de définir des règles qui déclenchent une ou plusieurs actions de mise à l’échelle automatique lorsque les conditions des règles sont remplies. Vous pouvez configurer une mise à l'échelle basée sur des métriques (comme une utilisation du processeur (CPU) supérieure à 70 %), une mise à l'échelle basée sur un calendrier (comme des règles de mise à l'échelle pour les heures de pointe), ou une combinaison des deux. Pour plus d’informations, consultez Vue d’ensemble de la mise à l’échelle automatique dans Microsoft Azure.

Diagramme qui montre comment la mise à l'échelle automatique ajoute et supprime des instances selon les besoins.

Vous pouvez actuellement gérer la mise à l'échelle automatique en utilisant Azure CLI, les API REST, Azure Resource Manager, le kit de développement logiciel (SDK) Python ou le Portail Microsoft Azure basé sur le navigateur.

Prérequis

Point de terminaison déployé. Pour plus d’informations, consultez Déployer et scorer un modèle Machine Learning en utilisant un point de terminaison en ligne.
Pour utiliser la mise à l’échelle automatique, le rôle microsoft.insights/autoscalesettings/write doit être attribué à l’identité qui gère la mise à l’échelle automatique. Vous pouvez utiliser n’importe quel rôle intégré ou personnalisé qui autorise cette action. Pour obtenir des conseils généraux sur la gestion des rôles pour Azure Machine Learning, consultez Gérer les utilisateurs et les rôles. Pour plus d’informations sur les paramètres de mise à l’échelle automatique d’Azure Monitor, consultez Paramètres de mise à l’échelle automatique Microsoft Insights.
Pour utiliser le SDK Python pour gérer le service Azure Monitor, installez le package azure-mgmt-monitor avec la commande suivante :
```
pip install azure-mgmt-monitor
```

Définir le profil de mise à l'échelle automatique

Pour activer la mise à l'échelle automatique pour un point de terminaison en ligne, vous devez d'abord définir un profil de mise à l'échelle automatique. Le profil spécifie la capacité par défaut, minimale et maximale du groupe d'échelle. L'exemple suivant montre comment définir le nombre d'instances de machine virtuelle (VM) pour la capacité d'échelle par défaut, minimale et maximale.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

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>

Définissez les noms du point de terminaison et du déploiement :

# set your existing endpoint name
ENDPOINT_NAME=your-endpoint-name
DEPLOYMENT_NAME=blue

Obtenez l’ID Azure Resource Manager du déploiement et du point de terminaison :

# ARM id of the deployment
DEPLOYMENT_RESOURCE_ID=$(az ml online-deployment show -e $ENDPOINT_NAME -n $DEPLOYMENT_NAME -o tsv --query "id")
# ARM id of the deployment. todo: change to --query "id"
ENDPOINT_RESOURCE_ID=$(az ml online-endpoint show -n $ENDPOINT_NAME -o tsv --query "properties.\"azureml.onlineendpointid\"")
# set a unique name for autoscale settings for this deployment. The below will append a random number to make the name unique.
AUTOSCALE_SETTINGS_NAME=autoscale-$ENDPOINT_NAME-$DEPLOYMENT_NAME-`echo $RANDOM`

Créer le profil de mise à l’échelle automatique :

az monitor autoscale create \
  --name $AUTOSCALE_SETTINGS_NAME \
  --resource $DEPLOYMENT_RESOURCE_ID \
  --min-count 2 --max-count 5 --count 2

Remarque

Pour plus d'informations, consultez la référence az monitor autoscale.

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Importer les modules nécessaires :

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
from azure.mgmt.monitor.models import AutoscaleProfile, ScaleRule, MetricTrigger, ScaleAction, Recurrence, RecurrentSchedule
import random 
import datetime

Définissez des variables pour l’espace de travail, le point de terminaison et le déploiement :

subscription_id = "<YOUR-SUBSCRIPTION-ID>"
resource_group = "<YOUR-RESOURCE-GROUP>"
workspace = "<YOUR-WORKSPACE>"

endpoint_name = "<YOUR-ENDPOINT-NAME>"
deployment_name = "blue"

Obtenez les clients Azure Machine Learning et Azure Monitor :

credential = DefaultAzureCredential()
ml_client = MLClient(
    credential, subscription_id, resource_group, workspace
)

mon_client = MonitorManagementClient(
    credential, subscription_id
)

Obtenez les objets de point de terminaison et de déploiement :

deployment = ml_client.online_deployments.get(
    deployment_name, endpoint_name
)

endpoint = ml_client.online_endpoints.get(
    endpoint_name
)

Créez un profil de mise à l’échelle automatique :

# Set a unique name for autoscale settings for this deployment. The following code appends a random number to create a unique name.
autoscale_settings_name = f"autoscale-{endpoint_name}-{deployment_name}-{random.randint(0,1000)}"

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "profiles" : [
            AutoscaleProfile(
                name="my-scale-settings",
                capacity={
                    "minimum" : 2, 
                    "maximum" : 5,
                    "default" : 2
                },
                rules = []
            )
        ]
    }
)

Créer une règle de mise à l'échelle basée sur les mesures de déploiement

Une règle de mise à l’échelle courante consiste à augmenter le nombre d’instances de machine virtuelle lorsque la charge CPU moyenne est élevée. L'exemple suivant montre comment allouer deux nœuds supplémentaires (jusqu'au maximum) si la charge moyenne du processeur (CPU) est supérieure à 70 % pendant 5 minutes :

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

az monitor autoscale rule create \
  --autoscale-name $AUTOSCALE_SETTINGS_NAME \
  --condition "CpuUtilizationPercentage > 70 avg 5m" \
  --scale out 2

La règle fait partie du profil my-scale-settings, où autoscale-name correspond la partie name du profil. La valeur de l'argument de la règle condition indique que la règle se déclenche lorsque « La consommation moyenne du CPU parmi les instances de VM dépasse 70 % pendant 5 minutes. » Lorsque la condition est satisfaite, deux instances de VM supplémentaires sont allouées.

Remarque

Pour plus d'informations, consultez la référence de syntaxe de l'interface de ligne de commande Azure (CLI) pour az monitor autoscale.

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Créez la définition de règle :

rule_scale_out = ScaleRule(
    metric_trigger = MetricTrigger(
        metric_name="CpuUtilizationPercentage",
        metric_resource_uri = deployment.id, 
        time_grain = datetime.timedelta(minutes = 1),
        statistic = "Average",
        operator = "GreaterThan", 
        time_aggregation = "Last",
        time_window = datetime.timedelta(minutes = 5), 
        threshold = 70
    ), 
    scale_action = ScaleAction(
        direction = "Increase", 
        type = "ChangeCount", 
        value = 2, 
        cooldown = datetime.timedelta(hours = 1)
    )
)

Cette règle fait référence à la moyenne des 5 dernières minutes de la valeur CPUUtilizationpercentage des arguments metric_name, time_window, et time_aggregation. Lorsque la valeur de la métrique est supérieure threshold à 70, le déploiement alloue deux instances de machine virtuelle supplémentaires.

Mettez à jour le profil my-scale-settings pour inclure cette règle :

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "profiles" : [
            AutoscaleProfile(
                name="my-scale-settings",
                capacity={
                    "minimum" : 2, 
                    "maximum" : 5,
                    "default" : 2
                },
                rules = [
                    rule_scale_out
                ]
            )
        ]
    }
)

Créer une règle de réduction des effectifs basée sur les mesures de déploiement

Lorsque la charge CPU moyenne est faible, une règle de réduction peut réduire le nombre d'instances de machine virtuelle. L'exemple suivant montre comment réduire un seul nœud à un minimum de deux, si la charge du processeur (CPU) est inférieure à 30 % pendant 5 minutes.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

az monitor autoscale rule create \
  --autoscale-name $AUTOSCALE_SETTINGS_NAME \
  --condition "CpuUtilizationPercentage < 25 avg 5m" \
  --scale in 1

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Créez la définition de règle :

rule_scale_in = ScaleRule(
    metric_trigger = MetricTrigger(
        metric_name="CpuUtilizationPercentage",
        metric_resource_uri = deployment.id, 
        time_grain = datetime.timedelta(minutes = 1),
        statistic = "Average",
        operator = "LessThan", 
        time_aggregation = "Last",
        time_window = datetime.timedelta(minutes = 5), 
        threshold = 30
    ), 
    scale_action = ScaleAction(
        direction = "Increase", 
        type = "ChangeCount", 
        value = 1, 
        cooldown = datetime.timedelta(hours = 1)
    )
)

Mettez à jour le profil my-scale-settings pour inclure cette règle :

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "profiles" : [
            AutoscaleProfile(
                name="my-scale-settings",
                capacity={
                    "minimum" : 2, 
                    "maximum" : 5,
                    "default" : 2
                },
                rules = [
                    rule_scale_out, 
                    rule_scale_in
                ]
            )
        ]
    }
)

Créer une règle d'échelle basée sur les mesures des points de terminaison

Dans les sections précédentes, vous avez créé des règles permettant une mise à l’échelle en fonction des métriques de déploiement. Vous pouvez également créer une règle qui s’applique au point de terminaison de déploiement. Dans cette section, vous apprendrez comment allouer un autre nœud lorsque la latence des requêtes est supérieure à une moyenne de 70 millisecondes pendant 5 minutes.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

az monitor autoscale rule create \
 --autoscale-name $AUTOSCALE_SETTINGS_NAME \
 --condition "RequestLatency > 70 avg 5m" \
 --scale out 1 \
 --resource $ENDPOINT_RESOURCE_ID

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Créez la définition de règle :

rule_scale_out_endpoint = ScaleRule(
    metric_trigger = MetricTrigger(
        metric_name="RequestLatency",
        metric_resource_uri = endpoint.id, 
        time_grain = datetime.timedelta(minutes = 1),
        statistic = "Average",
        operator = "GreaterThan", 
        time_aggregation = "Last",
        time_window = datetime.timedelta(minutes = 5), 
        threshold = 70
    ), 
    scale_action = ScaleAction(
        direction = "Increase", 
        type = "ChangeCount", 
        value = 1, 
        cooldown = datetime.timedelta(hours = 1)
    )
)

Le champ metric_resource_uri de cette règle fait maintenant référence au point de terminaison au lieu du déploiement.

Mettez à jour le profil my-scale-settings pour inclure cette règle :

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "profiles" : [
            AutoscaleProfile(
                name="my-scale-settings",
                capacity={
                    "minimum" : 2, 
                    "maximum" : 5,
                    "default" : 2
                },
                rules = [
                    rule_scale_out, 
                    rule_scale_in,
                    rule_scale_out_endpoint
                ]
            )
        ]
    }
)

Trouver les identifiants des métriques prises en charge

Si vous souhaitez utiliser d'autres métriques dans le code pour configurer des règles d'automatisation de l'échelle en utilisant l'interface de ligne de commande Azure (CLI) ou le SDK, consultez le tableau dans Métriques disponibles.

Créer une règle d'échelle basée sur un calendrier

Vous pouvez également créer des règles qui s’appliquent uniquement à certains jours ou à certaines heures. Dans cette section, vous créez une règle qui définit le nombre de nœuds sur 2 le week-end.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

az monitor autoscale profile create \
  --name weekend-profile \
  --autoscale-name $AUTOSCALE_SETTINGS_NAME \
  --min-count 2 --count 2 --max-count 2 \
  --recurrence week sat sun --timezone "Pacific Standard Time"

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "profiles" : [
            AutoscaleProfile(
                name="Default",
                capacity={
                    "minimum" : 2, 
                    "maximum" : 2,
                    "default" : 2
                },
                recurrence = Recurrence(
                    frequency = "Week", 
                    schedule = RecurrentSchedule(
                        time_zone = "Pacific Standard Time", 
                        days = ["Saturday", "Sunday"], 
                        hours = [], 
                        minutes = []
                    )
                )
            )
        ]
    }
)

Activer ou désactiver la mise à l'échelle automatique

Vous pouvez activer ou désactiver un profil de mise à l'échelle automatique spécifique.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

az monitor autoscale update \
  --autoscale-name $AUTOSCALE_SETTINGS_NAME \
  --enabled false

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

mon_client.autoscale_settings.create_or_update(
    resource_group, 
    autoscale_settings_name, 
    parameters = {
        "location" : endpoint.location,
        "target_resource_uri" : deployment.id,
        "enabled" : False
    }
)

Supprimer des ressources

Si vous n’utilisez pas vos déploiements, supprimez les ressources en procédant comme suit.

S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

# delete the autoscaling profile
az monitor autoscale delete -n "$AUTOSCALE_SETTINGS_NAME"

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

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

mon_client.autoscale_settings.delete(
    resource_group, 
    autoscale_settings_name
)

ml_client.online_endpoints.begin_delete(endpoint_name)

Partager via

Mise à l'échelle automatique des points de terminaison en ligne dans Azure Machine Learning

Prérequis

Définir le profil de mise à l'échelle automatique

Créer une règle de mise à l'échelle basée sur les mesures de déploiement

Créer une règle de réduction des effectifs basée sur les mesures de déploiement

Créer une règle d'échelle basée sur les mesures des points de terminaison

Trouver les identifiants des métriques prises en charge

Créer une règle d'échelle basée sur un calendrier

Activer ou désactiver la mise à l'échelle automatique

Supprimer des ressources

Commentaires

Ressources supplémentaires

Partager via

Mise à l'échelle automatique des points de terminaison en ligne dans Azure Machine Learning

Prérequis

Définir le profil de mise à l'échelle automatique

Créer une règle de mise à l'échelle basée sur les mesures de déploiement

Créer une règle de réduction des effectifs basée sur les mesures de déploiement

Créer une règle d'échelle basée sur les mesures des points de terminaison

Trouver les identifiants des métriques prises en charge

Créer une règle d'échelle basée sur un calendrier

Activer ou désactiver la mise à l'échelle automatique

Supprimer des ressources

Contenu connexe

Commentaires

Ressources supplémentaires