Dimensionar automaticamente um ponto final online

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

O dimensionamento automático executa a quantidade certa de recursos para processar a carga da aplicação. Os pontos de extremidade online dão suporte ao dimensionamento automático por meio da integração com o recurso de dimensionamento automático do Azure Monitor.

O dimensionamento automático do Azure Monitor dá suporte a um rico conjunto de regras. Você pode configurar o dimensionamento baseado em métricas (por exemplo, utilização >da CPU 70%), o dimensionamento baseado em programação (por exemplo, regras de dimensionamento para horários comerciais de pico) ou uma combinação. Para obter mais informações, consulte Visão geral do dimensionamento automático no Microsoft Azure.

Hoje, você pode gerenciar o dimensionamento automático usando a CLI do Azure, REST, ARM ou o portal do Azure baseado em navegador. Outros SDKs do Azure Machine Learning, como o SDK do Python, adicionarão suporte ao longo do tempo.

Pré-requisitos

• Um ponto de extremidade implantado. Implante e classifique um modelo de aprendizado de máquina usando um ponto de extremidade online.
• Para usar o dimensionamento automático, a função microsoft.insights/autoscalesettings/write deve ser atribuída à identidade que gerencia o dimensionamento automático. Você pode usar quaisquer funções internas ou personalizadas que permitam essa ação. Para obter orientações gerais sobre como gerenciar funções para o Azure Machine Learning, consulte Gerenciar usuários e funções. Para obter mais informações sobre as configurações de dimensionamento automático do Azure Monitor, consulte Microsoft.Insights autoscalesettings.

Definir um perfil de dimensionamento automático

Para habilitar o dimensionamento automático para um ponto de extremidade, 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 a seguir define a capacidade padrão e mínima como duas instâncias de VM e a capacidade máxima como cinco:

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (atual)

O trecho a seguir define os nomes de ponto de extremidade e implantação:

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

Em seguida, obtenha a ID do Azure Resource Manager da implantação e do ponto de extremidade:

# 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 trecho a seguir 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 saber mais, consulte a página de referência para dimensionamento automático

Python

APLICA-SE A: Python SDK 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 

Defina variáveis para o espaço de trabalho, o ponto de extremidade e a implantação:

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

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

Obtenha os 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 de extremidade e implantação:

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

endpoint = ml_client.online_endpoints.get(
    endpoint_name
)

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

Estúdio

No estúdio do Azure Machine Learning, selecione seu espaço de trabalho e, em seguida, selecione Pontos de extremidade no lado esquerdo da página. Depois que os pontos de extremidade estiverem listados, selecione o que você deseja configurar.

Na guia Detalhes do ponto de extremidade, selecione Configurar dimensionamento automático.

Em Escolha como dimensionar seus recursos, selecione Dimensionamento automático personalizado para iniciar a configuração. Para a condição de escala padrão, use os seguintes valores:

• Defina o modo Escala como Escala com base em uma métrica.
• Defina Mínimo para 2.
• Defina o máximo para 5.
• Defina Padrão como 2.

Criar uma regra para expandir usando métricas de implantação

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

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (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 de seu condition argumento diz que a regra deve ser acionada quando "O consumo médio de CPU entre as instâncias de VM exceder 70% por cinco minutos". Quando essa condição é satisfeita, mais duas instâncias de VM são alocadas.

Nota

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

Python

APLICA-SE A: Python SDK 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_nametime_window , e time_aggregation. Quando o valor da métrica é maior que 70 threshold , mais duas instâncias de VM são alocadas.

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

Estúdio

Na seção Regras, selecione Adicionar uma regra. A página Regra de escala é exibida. Use as seguintes informações para preencher os campos nesta página:

• Defina Nome da métrica como Porcentagem de utilização da CPU.
• Defina Operador como Maior que e defina o limite Métrico como 70.
• Defina Duração (minutos) para 5. Deixe a estatística de grãos de tempo como Média.
• Defina Operation to Increase count by e defina Instance count como 2.

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

Criar uma regra para dimensionar usando métricas de implantação

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

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (atual)

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

Python

APLICA-SE A: Python SDK 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
                ]
            )
        ]
    }
)

Estúdio

Na seção Regras, selecione Adicionar uma regra. A página Regra de escala é exibida. Use as seguintes informações para preencher os campos nesta página:

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

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

Se você tiver regras de dimensionamento e dimensionamento, suas regras serão semelhantes à captura de tela a seguir. Você especificou que, se a carga média da CPU exceder 70% por 5 minutos, mais 2 nós devem ser alocados, até o limite de 5. Se a carga da CPU for inferior a 30% durante 5 minutos, um único nó deve ser libertado, até ao mínimo de 2.

Criar uma regra de dimensionamento com base em métricas de endpoint

As regras anteriores se aplicavam à implantação. Agora, adicione uma regra que se aplique ao ponto de extremidade. Neste exemplo, se a latência da solicitação for maior que uma média de 70 milissegundos por 5 minutos, aloque outro nó.

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (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: Python SDK azure-ai-ml v2 (atual)

Crie a definição da 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 agora se refere ao ponto de extremidade e não à implantaçã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
                ]
            )
        ]
    }
)

Estúdio

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

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

• Defina Origem da métrica como Outro recurso.
• Defina Tipo de recurso como Pontos de extremidade online do Aprendizado de Máquina.
• Defina Recurso como seu ponto de extremidade.
• Defina Nome da métrica como Latência da solicitação.
• Defina Operador como Maior que e defina Limite métrico como 70.
• Defina Duração (minutos) para 5.
• Defina Operação para aumentar a contagem em e defina a contagem de instâncias como 1

Encontrar IDs de métricas suportados

Se você quiser usar outras métricas no código (CLI ou SDK) para configurar regras de dimensionamento automático, consulte a tabela em Métricas disponíveis.

Criar regras de dimensionamento com base em uma agenda

Você também pode criar regras que se aplicam apenas em determinados dias ou horários. Neste exemplo, a contagem de nós é definida como 2 no fim de semana.

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (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: Python SDK 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 = []
                    )
                )
            )
        ]
    }
)

Estúdio

Na parte inferior da página, selecione + Adicionar uma condição de escala. Na nova condição de escala, use 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 para Repetir dias específicos.
• Defina o horário para Repetir todos os sábados e domingos.

Ativar ou desativar o dimensionamento automático

Você pode ativar ou desativar o perfil de dimensionamento automático específico.

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (atual)

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

Python

APLICA-SE A: Python SDK 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,
        "enabled" : False
    }
)

Estúdio

Para desativar o perfil de dimensionamento automático, basta escolher "Escala manual" e Salvar. Para ativar o perfil de escala automática, basta escolher "Escala automática personalizada". Se você já adicionou o perfil de escala automática antes, você os verá abaixo. Agora você pode clicar em Salvar para ativá-lo.

Eliminar recursos

Se você não vai usar suas implantações, exclua-as:

CLI do Azure

APLICA-SE A: Azure CLI ml extension v2 (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: Python SDK azure-ai-ml v2 (atual)

mon_client.autoscale_settings.delete(
    resource_group, 
    autoscale_settings_name
)

ml_client.online_endpoints.begin_delete(endpoint_name)

Estúdio

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

Como alternativa, você pode excluir um ponto de extremidade online gerenciado diretamente na página de detalhes do ponto final.

Próximos passos

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

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