Dimensionar automaticamente um ponto final online

APLICA-SE A:Extensão v2 da CLI do Azure (atual)SDK python azure-ai-ml v2 (atual)

O dimensionamento automático executa a quantidade certa de recursos para processar a carga da aplicação. Os pontos finais online suportam o dimensionamento automático através da integração com a funcionalidade de dimensionamento automático do Azure Monitor.

O dimensionamento automático do Azure Monitor suporta um conjunto avançado de regras. Pode configurar o dimensionamento baseado em métricas (por exemplo, a utilização >da CPU 70%), o dimensionamento baseado na agenda (por exemplo, regras de dimensionamento para horas de ponta) ou uma combinação. Para obter mais informações, veja Descrição geral do dimensionamento automático no Microsoft Azure.

Atualmente, pode gerir o dimensionamento automático com a CLI do Azure, REST, ARM ou o portal do Azure baseado no browser. Outros SDKs do Azure Machine Learning, como o SDK python, irão adicionar suporte ao longo do tempo.

Pré-requisitos

• Um ponto final implementado. Implementar e classificar um modelo de machine learning com um ponto final online.
• Para utilizar o dimensionamento automático, a função microsoft.insights/autoscalesettings/write tem de ser atribuída à identidade que gere o dimensionamento automático. Pode utilizar quaisquer funções incorporadas ou personalizadas que permitam esta ação. Para obter orientações gerais sobre a gestão de funções do Azure Machine Learning, veja Gerir utilizadores e funções. Para obter mais informações sobre as definições de dimensionamento automático do Azure Monitor, veja Definições de dimensionamento automático do Microsoft.Insights.

Definir um perfil de dimensionamento automático

Para ativar o dimensionamento automático para um ponto final, primeiro defina um perfil de dimensionamento automático. Este perfil define a capacidade predefinida, máxima e mínima do conjunto de dimensionamento. O exemplo seguinte define a capacidade predefinida e mínima como duas instâncias de VM e a capacidade máxima como cinco:

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

O fragmento seguinte define os nomes de ponto final e implementação:

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

Em seguida, obtenha o ID de Resource Manager do Azure da implementação e do ponto final:

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

O fragmento seguinte cria o perfil de dimensionamento automático:

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

Nota

Para obter mais informações, veja a página de referência do dimensionamento automático

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

Importar módulos:

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 

Definir variáveis para a área de trabalho, o ponto final e a implementação:

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

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

Obter clientes do Azure Machine Learning e do Azure Monitor:

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

mon_client = MonitorManagementClient(
    credential, subscription_id
)

Obtenha os objetos de ponto final e implementação:

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

endpoint = ml_client.online_endpoints.get(
    endpoint_name
)

Criar um perfil de dimensionamento automático:

# 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 = 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 = []
            )
        ]
    }
)

Studio

No estúdio do Azure Machine Learning, selecione a área de trabalho e, em seguida, selecione Pontos finais no lado esquerdo da página. Assim que os pontos finais estiverem listados, selecione aquele que pretende configurar.

No separador Detalhes do ponto final, selecione Configurar dimensionamento automático.

Em Escolher como dimensionar os seus recursos, selecione Dimensionamento automático personalizado para iniciar a configuração. Para a condição de dimensionamento predefinida, utilize os seguintes valores:

• Defina o Modo de dimensionamento como Dimensionamento com base numa métrica.
• Defina Mínimo como 2.
• Defina Máximo como 5.
• Defina Predefinição como 2.

Criar uma regra para aumentar horizontalmente com métricas

Uma regra de aumento horizontal comum é uma regra que aumenta o número de instâncias de VM quando a carga média da CPU é elevada. O exemplo seguinte alocará mais dois nós (até ao máximo) se a média da CPU for superior a 70% durante cinco minutos:

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

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

A regra faz parte do my-scale-settings perfil (autoscale-name corresponde ao name do perfil). O valor do argumento diz que a regra deve ser acionada quando "O consumo médio da condition CPU entre as instâncias da VM excede 70% durante cinco minutos". Quando essa condição é satisfeita, são alocadas mais duas instâncias de VM.

Nota

Para obter mais informações sobre a sintaxe da CLI, consulte az monitor autoscale.

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

Crie a definição da regra:

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

Esta regra refere-se à média dos últimos 5 minutos dos CPUUtilizationpercentage argumentos metric_namee time_windowtime_aggregation. Quando o valor da métrica é maior do que o threshold de 70, são alocadas mais duas instâncias de VM.

Atualize o my-scale-settings perfil para incluir esta regra:

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
                ]
            )
        ]
    }
)

Studio

Na secção Regras , selecione Adicionar uma regra. A página Regra de dimensionamento é apresentada. Utilize as seguintes informações para preencher os campos nesta página:

• Defina o Nome da métrica como Percentagem de Utilização da CPU.
• Defina Operador como Maior que e defina o limiar de Métrica como 70.
• Defina Duração (minutos) como 5. Deixe a estatística Intervalo de agregação como Média.
• Defina Operação como Aumentar contagem por e defina Contagem de instâncias como 2.

Por fim, selecione o botão Adicionar para criar a regra.

Criar uma regra para reduzir horizontalmente com métricas

Quando a carga é leve, uma regra de dimensionamento pode reduzir o número de instâncias de VM. O exemplo seguinte irá libertar um único nó, até um mínimo de 2, se a carga da CPU for inferior a 30% durante 5 minutos:

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

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

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

Crie a definição da regra:

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

Atualize o my-scale-settings perfil para incluir esta regra:

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
                ]
            )
        ]
    }
)

Studio

Na secção Regras , selecione Adicionar uma regra. A página Regra de dimensionamento é apresentada. Utilize as seguintes informações para preencher os campos nesta página:

• Defina o Nome da métrica como Percentagem de Utilização da CPU.
• Defina Operador como Menor que e o limiar de Métrica como 30.
• Defina Duração (minutos) como 5.
• Defina Operação como Diminuir contagem por e defina Contagem de instâncias como 1.

Por fim, selecione o botão Adicionar para criar a regra.

Se tiver regras de aumento horizontal e redução horizontal, as regras terão um aspeto semelhante à seguinte captura de ecrã. Especificou que, se a carga média da CPU exceder 70% durante 5 minutos, devem ser alocados mais 2 nós, até ao limite de 5. Se a carga da CPU for inferior a 30% durante 5 minutos, deverá ser libertado um único nó, até ao mínimo de 2.

Criar uma regra de dimensionamento com base em métricas de ponto final

As regras anteriores aplicadas à implementação. Agora, adicione uma regra que se aplique ao ponto final. Neste exemplo, se a latência do pedido for superior a uma média de 70 milissegundos durante 5 minutos, aloque outro nó.

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

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

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

Crie a definição de regra:

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

O campo desta metric_resource_uri regra refere-se agora ao ponto final e não à implementação.

Atualize o my-scale-settings perfil para incluir esta regra:

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
                ]
            )
        ]
    }
)

Studio

Na parte inferior da página, selecione + Adicionar uma condição de dimensionamento.

Selecione Dimensionar com base na métrica e, em seguida, selecione Adicionar uma regra. A página Regra de dimensionamento é apresentada. Utilize as seguintes informações para preencher os campos nesta página:

• Defina origem da métrica como Outro recurso.
• Defina o Tipo de recurso como pontos finais online do Machine Learning.
• Defina Recurso para o ponto final.
• Defina Nome da métrica como Latência do pedido.
• Defina Operador como Maior do que e defina Limiar de métrica como 70.
• Defina Duração (minutos) como 5.
• Defina Operação para Aumentar contagem por e defina Contagem de instâncias como 1

Criar regras de dimensionamento com base numa agenda

Também pode criar regras que se aplicam apenas em determinados dias ou em determinadas alturas. Neste exemplo, a contagem de nós está definida como 2 no fim de semana.

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

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"

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

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 = []
                    )
                )
            )
        ]
    }
)

Studio

Na parte inferior da página, selecione + Adicionar uma condição de dimensionamento. Na nova condição de dimensionamento, utilize as seguintes informações para preencher os campos:

• Selecione Dimensionar para uma contagem de instâncias específica.
• Defina a Contagem de instâncias como 2.
• Defina a Agenda como Repetir dias específicos.
• Defina a agenda para Repetir todos ossábados e domingos.

Eliminar recursos

Se não pretender utilizar as suas implementações, elimine-as:

CLI do Azure

APLICA-SE A:Extensão v2 da CLI do Azure (atual)

# 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

Python

APLICA-SE A: SDK python azure-ai-ml v2 (atual)

mon_client.autoscale_settings.delete(
    resource_group, 
    autoscale_settings_name
)

ml_client.online_endpoints.begin_delete(endpoint_name)

Studio

1. Vá para o estúdio do Azure Machine Learning.
2. Na barra de navegação à esquerda, selecione a página Pontos finais .
3. Selecione um ponto final ao verificar o círculo junto ao nome do modelo.
4. Selecione Eliminar.

Em alternativa, pode eliminar um ponto final online gerido diretamente na página de detalhes do ponto final.

Passos seguintes

Para saber mais sobre o dimensionamento automático com o Azure Monitor, veja os seguintes artigos:

• Compreender as definições de dimensionamento automático
• Descrição geral dos padrões comuns de dimensionamento automático
• Melhores práticas do dimensionamento automático
• Resolução de problemas do dimensionamento automático do Azure