Dimensionamento automático de ponto de extremidade online

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

O dimensionamento automático executa automaticamente a quantidade certa de recursos para lidar com a carga em seu aplicativo. 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 conjunto avançado de regras. Você pode configurar o dimensionamento baseado em métricas (por exemplo, utilização da CPU >70%), o dimensionamento baseado em agendamento (por exemplo, regras de dimensionamento para horário comercial de pico) ou uma combinação deles. Para saber mais, confira a Visão geral do dimensionamento automático no Microsoft Azure.

Hoje, você pode gerenciar o dimensionamento automático com a CLI do Azure, REST, ARM ou o portal do Azure em um navegador. Outros SDKs do Azure Machine Learning, como o SDK do Python, adicionarão suporte mais adiante.

Pré-requisitos

• Um ponto de extremidade implantado. Implantar e pontuar 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 diretrizes 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 autoescala

Para habilitar o dimensionamento automático em um ponto de extremidade, primeiro você definirá um perfil de dimensionamento automático. Esse perfil define a capacidade padrão, mínima e máxima 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:Extensão de ML da CLI do Azure v2 (atual)

O trecho abaixo define os nomes do ponto de extremidade e da implantação:

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

Em seguida, obtenha o ID do Azure Resource Manager para a implantação e o 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 abaixo 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

Observação

Para saber mais, confira a página de referência do dimensionamento automático

Python

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

Defina variáveis para o workspace, 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 o workspace e escolha Pontos de extremidade no lado esquerdo da página. Depois que os pontos de extremidade aparecerem na lista, selecione aquele que você deseja configurar.

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

Em Escolher 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 de escala como Escala com base em uma métrica.
• Defina Mínimo como 2.
• Defina Máximo como 5.
• Defina Padrão como 2.

Criar uma regra para escalar horizontalmente com métricas

Uma regra comum de colocação em escala horizontal é aquela que aumenta o número de instâncias de VM quando a carga de CPU média está alta. O seguinte exemplo alocará mais dois nós (até o máximo) se a média da CPU tiver uma carga maior que 70% por cinco minutos:

CLI do Azure

APLICA-SE A:Extensão de ML da CLI do Azure 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 perfil my-scale-settings (autoscale-name corresponde ao name do perfil). O valor do argumento condition dessa regra diz que ela deverá disparar quando "O consumo médio de CPU entre as instâncias de VM exceder 70% por cinco minutos". Quando essa condição é atendida, duas instâncias adicionais de VM são alocadas.

Observação

Para saber mais sobre a sintaxe da CLI, confira az monitor autoscale.

Python

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

Crie a definição de 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)
    )
)

Essa regra se refere à última média de 5 minutos de CPUUtilizationpercentage dos argumentos metric_name, time_window e time_aggregation. Quando o valor da métrica é maior que o threshold de 70, mais duas instâncias de VM são alocadas.

Atualize o perfil my-scale-settings 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 informações abaixo para preencher os campos nesta página:

• Defina o Nome da métrica como Porcentagem de utilização da CPU.
• Defina o Operador como Maior que e defina o Limite de métrica como 70.
• Defina Duração (minutos) como 5. Deixe a Estatística de granularidade de tempo como Média.
• Defina a Operação como Aumentar a contagem em e defina a 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 redução horizontal pode diminuir o número de instâncias de VM. O exemplo a seguir liberará um único nó, até um mínimo de dois, se a carga da CPU for inferior a 30% por cinco minutos:

CLI do Azure

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

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

Python

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

Crie a definição de 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 perfil my-scale-settings 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 informações abaixo para preencher os campos nesta página:

• Defina o Nome da métrica como Porcentagem de utilização da CPU.
• Defina Operador como Menor que e Limite de métrica como 30.
• Defina Duração (minutos) como 5.
• Defina a Operação como Reduzir a contagem em e defina a Contagem de instâncias como 1.

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

Se você tiver regras tanto de expansão quanto de redução horizontal, suas regras serão semelhantes à captura de tela a seguir. Você especificou que, se a carga média da CPU exceder 70% por cinco minutos, mais dois nós deverão ser alocados até o limite de cinco. Se a carga da CPU for inferior a 30% por cinco minutos, um único nó deverá ser liberado até o mínimo de dois.

Criar uma regra de colocação em escala com base nas métricas do ponto de extremidade

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 cinco minutos, aloque outro nó.

CLI do Azure

APLICA-SE A:Extensão de ML da CLI do Azure 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: SDK do 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 metric_resource_uri dessa regra agora se refere ao ponto de extremidade, em vez da implantação.

Atualize o perfil my-scale-settings 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 Escalar com base na métricae escolha Adicionar uma regra. A página Regra de escala é exibida. Use as informações abaixo para preencher os campos nesta página:

• Defina a Origem da métrica como Outro recurso.
• Defina o Tipo de recurso como Pontos de extremidade do Machine Learning.
• Defina o Recurso para o ponto de extremidade.
• Defina o Nome da métrica como Latência de solicitação.
• Defina o Operador como Maior que e defina o Limite de métrica como 70.
• Defina Duração (minutos) como 5.
• Defina a Operação como Aumentar a contagem em e defina a Contagem de instâncias como 1

Criar regras de colocação em escala com base em um agendamento

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

CLI do Azure

APLICA-SE A:Extensão de ML da CLI do Azure 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: SDK do 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 = []
                    )
                )
            )
        ]
    }
)

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 Escalar segundo uma contagem de instâncias específica.
• Defina a Contagem de instâncias como 2.
• Defina o Agendamento como Repetir em dias específicos.
• Defina o agendamento como Repetir a cadaSábado e Domingo.

Excluir recursos

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

CLI do Azure

APLICA-SE A:Extensão de ML da CLI do Azure 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: SDK do Python 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 Excluir.

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

Próximas etapas

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

• Compreender configurações de dimensionamento automático
• Visão geral dos padrões comuns de dimensionamento automático
• Práticas recomendadas para dimensionamento automático
• Solução de problemas de dimensionamento automático do Azure