Implante um modelo em um cluster do serviço de Kubernetes do Azure com v1

Aprenda a usar o Azure Machine Learning para implementar um modelo como serviço web no Azure Kubernetes Service (AKS). O AKS é bom para implantações de produção em alta escala. Use o AKS se precisar de um ou mais dos seguintes recursos:

• Tempo de resposta rápido
• Dimensionamento automático do serviço implantado
• Registo
• Modelo de recolha de dados
• Authentication
• Terminação TLS
• Opções de aceleração de hardware, como GPU e FPGA (field-programmable gate arrays)

Ao implantar no AKS, você implanta em um cluster AKS conectado ao seu espaço de trabalho. Para informações sobre como ligar um cluster AKS ao seu espaço de trabalho, veja Criar e anexar um cluster Azure Kubernetes Service.

Pré-requisitos

• Um espaço de trabalho de Azure Machine Learning. Para mais informações, consulte Criar um espaço de trabalho Azure Machine Learning.

• Um modelo de aprendizagem automática registado na sua área de trabalho. Se não tiver um modelo registado, veja Deploy machine learning models to Azure.

• A extensão Azure CLI (v1) para o serviço de Machine Learning, Azure Machine Learning Python SDK, ou a extensão do Azure Machine Learning para o Visual Studio Code.

  Importante

  Alguns dos comandos Azure CLI neste artigo utilizam a extensão azure-cli-ml, ou v1, para Azure Machine Learning. O suporte para CLI v1 terminou em 30 de setembro de 2025. A Microsoft deixará de fornecer suporte técnico ou atualizações para este serviço. Seus fluxos de trabalho existentes usando a CLI v1 continuarão a operar após a data de fim do suporte. No entanto, eles podem estar expostos a riscos de segurança ou alterações disruptivas no caso de alterações arquitetônicas no produto.

  Recomendamos que você faça a transição para a mlextensão , ou v2, o mais rápido possível. Para mais informações sobre a extensão v2, veja Azure Machine Learning extensão CLI e Python SDK v2.

• Os excertos de código em Python neste artigo assumem que as seguintes variáveis estão definidas:

  • ws - Defina o seu espaço de trabalho.
  • model - Ajuste para o seu modelo registado.
  • inference_config - Defina a configuração de inferência do modelo.

  Para obter mais informações sobre como definir essas variáveis, consulte Como e onde implantar modelos.

• Os trechos da CLI neste artigo pressupõem que você já criou um documento inferenceconfig.json . Para mais informações sobre a criação deste documento, consulte Deploy machine learning models to Azure.

• Um cluster AKS conectado ao seu espaço de trabalho. Para mais informações, consulte Criar e anexar um cluster de Azure Kubernetes Service.

  • Se você quiser implantar modelos em nós de GPU ou nós FPGA (ou qualquer produto específico), deverá criar um cluster com o produto específico. Não há suporte para criar um pool de nós secundários em um cluster existente e implantar modelos no pool de nós secundários.

Compreender os processos de implantação

A palavra deployment é usada tanto no Kubernetes como no Azure Machine Learning. A implantação tem significados diferentes nesses dois contextos. No Kubernetes, uma implantação é uma entidade concreta, especificada com um arquivo YAML declarativo. Uma implantação do Kubernetes tem um ciclo de vida definido e relacionamentos concretos com outras entidades do Kubernetes, como Pods e ReplicaSets. Você pode aprender sobre o Kubernetes em documentos e vídeos em O que é o Kubernetes?.

No Azure Machine Learning, a implementação é usada no sentido mais geral de disponibilizar e limpar os recursos do seu projeto. Os passos que o Azure Machine Learning considera parte da implementação são:

1. Compactar os arquivos na pasta do projeto, ignorando os especificados em .amlignore ou .gitignore
2. Dimensionando seu cluster de computação (relacionado ao Kubernetes)
3. Construindo ou baixando o Dockerfile no nó de computação (relacionado ao Kubernetes)
   1. O sistema calcula um hash de:
      • A imagem base
      • Etapas personalizadas do docker (consulte Implantar um modelo usando uma imagem base personalizada do Docker)
      • A definição conda YAML (ver Criar e usar ambientes de desenvolvimento em Azure Machine Learning)
   2. O sistema utiliza este hash como chave numa pesquisa do workspace Azure Container Registry (ACR)
   3. Se não for encontrado, procura um correspondente no ACR global
   4. Se não for encontrado, o sistema cria uma nova imagem que é armazenada em cache e enviada para o ACR do espaço de trabalho
4. Baixando seu arquivo de projeto compactado para armazenamento temporário no nó de computação
5. Descompactando o arquivo de projeto
6. O nó de computação em execução python <entry script> <arguments>
7. Salvar logs, arquivos de modelo e outros arquivos gravados em ./outputs na conta de armazenamento associada ao espaço de trabalho
8. Redução da computação, incluindo a remoção de armazenamento temporário (relacionado ao Kubernetes)

Azure Machine Learning router

O componente front-end (azureml-fe) que roteia solicitações de inferência de entrada para serviços implantados é dimensionado automaticamente conforme necessário. O dimensionamento do azureml-fe é baseado na finalidade e no tamanho do cluster AKS (número de nós). A finalidade e os nós do cluster são configurados quando você cria ou anexa um cluster AKS. Há um serviço azureml-fe por cluster, que pode ser executado em vários pods.

Azureml-fe escalona verticalmente para usar mais núcleos e horizontalmente para usar mais pods. Ao tomar a decisão de aumentar a escala, o tempo necessário para rotear as solicitações de inferência de entrada é usado. Se esse tempo exceder o limite, ocorrerá uma expansão. Se o tempo para encaminhar as solicitações de entrada continuar excedendo o limiar, ocorrerá um escalonamento horizontal.

Ao reduzir a escala e concentrar internamente, utiliza-se a capacidade da CPU. Se o limite de uso da CPU for atingido, o front-end será reduzido primeiro. Se o uso da CPU cair para o limite de redução de escala, ocorrerá uma operação de redução de escala. A expansão e redução só ocorre se houver recursos de cluster suficientes disponíveis.

Quando se escala para cima ou para baixo, os pods azureml-fe são reiniciados para aplicar as alterações de CPU/memória. As reinicializações não afetam as solicitações de inferência.

Entender os requisitos de conectividade para o cluster de inferência do AKS

Quando o Azure Machine Learning cria ou anexa um cluster AKS, o cluster AKS é implementado com um dos seguintes dois modelos de rede:

• Rede Kubenet: Os recursos de rede são normalmente criados e configurados à medida que o cluster AKS é implantado.
• Rede Azure Container Networking Interface (CNI): O cluster AKS está ligado a um recurso e configurações de rede virtual existentes.

Para redes Kubenet, a rede é criada e configurada corretamente para o serviço Azure Machine Learning. Para a rede CNI, é necessário compreender os requisitos de conectividade e garantir a resolução de DNS e a conectividade de saída para a inferência em AKS. Por exemplo, você pode estar usando um firewall para bloquear o tráfego de rede.

O diagrama a seguir mostra os requisitos de conectividade para inferência AKS. As setas pretas representam a comunicação real e as setas azuis representam os nomes de domínio. Talvez seja necessário adicionar entradas para esses hosts ao firewall ou ao servidor DNS personalizado.

Para requisitos gerais de conectividade do AKS, veja Limitar o tráfego de rede com Azure Firewall no AKS.

Para aceder a Azure Machine Learning serviços atrás de um firewall, veja Configurar tráfego de rede de entrada e saída.

Requisitos gerais de resolução de DNS

A resolução de DNS dentro de uma rede virtual existente está sob seu controle. Por exemplo, um firewall ou servidor DNS personalizado. Os seguintes hosts devem estar acessíveis:

Requisitos de conectividade por ordem cronológica

No processo de criação ou ligação do AKS, o router Azure Machine Learning (azureml-fe) é implementado no cluster AKS. Para implementar um encaminhador do Azure Machine Learning, o nó do AKS deve ser capaz de:

• Resolução de DNS para servidor de API do AKS
• Resolva o DNS para o MCR a fim de transferir imagens do Docker para o router de Azure Machine Learning
• Descarregue imagens do MCR, onde é necessário ter conectividade externa

Logo após a implantação do azureml-fe, ele tenta iniciar e isso requer que você:

• Resolução de DNS para servidor de API do AKS
• Consulte o servidor da API do AKS para descobrir outras instâncias do serviço (é um serviço multi-pod)
• Conecte-se a outras instâncias dele próprio

Uma vez iniciado o azureml-fe, ele requer a seguinte conectividade para funcionar corretamente:

• Ligue-se ao Azure Storage para descarregar a configuração dinâmica
• Resolve o DNS para o servidor de autenticação da Microsoft Entra api.azureml.ms e comunique-se com ele quando o serviço implementado estiver a utilizar autenticação da Microsoft Entra.
• Consulte o servidor da API do AKS para descobrir modelos implantados
• Comunique-se com PODs de modelo implementados

No momento da implantação do modelo, para uma implantação bem-sucedida do modelo, o nó AKS deve ser capaz de:

• Gestão de DNS para ACR do cliente
• Download de imagens do ACR do cliente
• Resolver DNS nos BLOBs do Azure onde o modelo está armazenado
• Descarregue modelos a partir dos BLOBs do Azure

Depois que o modelo é implantado e o serviço é iniciado, o azureml-fe o descobre automaticamente usando a API do AKS e está pronto para rotear a solicitação para ele. Deve ser capaz de comunicar com modelos POD.

Implementar para AKS

Para implantar um modelo no AKS, crie uma configuração de implantação que descreva os recursos de computação necessários. Por exemplo, o número de núcleos e memória. Você também precisa de uma configuração de inferência, que descreve o ambiente necessário para hospedar o modelo e o serviço Web. Para obter mais informações sobre como criar a configuração de inferência, consulte Como e onde implantar modelos.

from azureml.core.webservice import AksWebservice, Webservice
from azureml.core.model import Model
from azureml.core.compute import AksCompute

aks_target = AksCompute(ws,"myaks")
# If deploying to a cluster configured for dev/test, ensure that it was created with enough
# cores and memory to handle this deployment configuration. Note that memory is also used by
# things such as dependencies and Azure Machine Learning components.
deployment_config = AksWebservice.deploy_configuration(cpu_cores = 1, memory_gb = 1)
service = Model.deploy(ws, "myservice", [model], inference_config, deployment_config, aks_target)
service.wait_for_deployment(show_output = True)
print(service.state)
print(service.get_logs())

az ml model deploy --ct myaks -m mymodel:1 -n myservice --ic inferenceconfig.json --dc deploymentconfig.json

{
    "computeType": "aks",
    "autoScaler":
    {
        "autoscaleEnabled": true,
        "minReplicas": 1,
        "maxReplicas": 3,
        "refreshPeriodInSeconds": 1,
        "targetUtilization": 70
    },
    "dataCollection":
    {
        "storageEnabled": true
    },
    "authEnabled": true,
    "containerResourceRequirements":
    {
        "cpu": 0.5,
        "memoryInGB": 1.0
    }
}

Dimensionamento automático

APLICA-SE A: Azure Machine Learning SDK v1 para Python

O componente que gere o autoescalonamento para implementações de modelos de Azure Machine Learning é o azureml-fe, que é um router de pedidos inteligente. Como todas as solicitações de inferência passam por ele, ele tem os dados necessários para dimensionar automaticamente os modelos implantados.

O dimensionamento automático pode ser controlado definindo autoscale_target_utilization, autoscale_min_replicase autoscale_max_replicas para o serviço Web AKS. O exemplo a seguir demonstra como habilitar o dimensionamento automático:

aks_config = AksWebservice.deploy_configuration(autoscale_enabled=True, 
                                                autoscale_target_utilization=30,
                                                autoscale_min_replicas=1,
                                                autoscale_max_replicas=4)

As decisões de aumentar ou diminuir a escala baseiam-se na utilização das réplicas de contêiner atuais. O número de réplicas que estão em uso (processando uma solicitação), dividido pelo total de réplicas em operação, é a utilização atual. Caso esse número exceda autoscale_target_utilization, mais réplicas serão criadas. Se for menor, as réplicas serão reduzidas. Por padrão, a utilização-alvo é de 70%.

As decisões para adicionar réplicas são decisivas e rápidas (cerca de 1 segundo). As decisões para remover réplicas são conservadoras (cerca de 1 minuto).

Você pode calcular as réplicas necessárias usando o seguinte código:

from math import ceil
# target requests per second
targetRps = 20
# time to process the request (in seconds)
reqTime = 10
# Maximum requests per container
maxReqPerContainer = 1
# target_utilization. 70% in this example
targetUtilization = .7

concurrentRequests = targetRps * reqTime / targetUtilization

# Number of container replicas
replicas = ceil(concurrentRequests / maxReqPerContainer)

Para obter mais informações sobre a configuração de autoscale_target_utilization, autoscale_max_replicas e autoscale_min_replicas, consulte o módulo de referência AksWebservice.

Autenticação do serviço Web

Ao implementar para Azure Kubernetes Service, a autenticação baseada em chaves está ativada por defeito. Você também pode habilitar a autenticação baseada em token. A autenticação baseada em token exige que os clientes utilizem uma conta Microsoft Entra para solicitar um token de autenticação, que é usado para fazer pedidos ao serviço implementado.

Para desabilitar a autenticação, defina o auth_enabled=False parâmetro ao criar a configuração de implantação. O exemplo a seguir desabilita a autenticação usando o SDK:

deployment_config = AksWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, auth_enabled=False)

Para informações sobre autenticação a partir de uma aplicação cliente, consulte o modelo Consume an Azure Machine Learning implementado como serviço web.

Autenticação com chaves

Se a autenticação de chave estiver habilitada, você poderá usar o get_keys método para recuperar uma chave de autenticação primária e secundária:

primary, secondary = service.get_keys()
print(primary)

Autenticação com tokens

Para habilitar a autenticação de token, defina o token_auth_enabled=True parâmetro quando estiver criando ou atualizando uma implantação. O exemplo a seguir habilita a autenticação de token usando o SDK:

deployment_config = AksWebservice.deploy_configuration(cpu_cores=1, memory_gb=1, token_auth_enabled=True)

Se a autenticação de token estiver habilitada, você poderá usar o get_token método para recuperar um JWT e o tempo de expiração desse token:

token, refresh_by = service.get_token()
print(token)

Análise de vulnerabilidades

O Microsoft Defender for Cloud oferece gestão unificada de segurança e proteção avançada contra ameaças em cargas de trabalho híbridas de cloud. Deve permitir que o Microsoft Defender for Cloud analise os seus recursos e siga as suas recomendações. Para mais informações, veja Segurança dos contentores em Microsoft Defender para contentores.

Conteúdos relacionados

• Use o controlo de acesso baseado em funções do Azure (RBAC) para autorização no Kubernetes
• Secure um ambiente de inferência Azure Machine Learning com redes virtuais
• Usar um contentor personalizado para desdobrar um modelo num endpoint online
• Solução de problemas de implantação de modelo remoto
• Atualizar um serviço Web implementado
• Usa TLS para proteger um serviço web através de Azure Machine Learning
• Consume um modelo Azure Machine Learning implementado como serviço web
• Monitorizar e recolher dados de endpoints de serviço web de Machine Learning