Implantar um modelo em um cluster do Serviço de Kubernetes do Azure com v1

Importante

Este artigo mostra como usar a CLI e o SDK v1 para implantar um modelo. Para obter a abordagem recomendada para v2, consulte Implantar e pontuar um modelo de machine learning usando um ponto de extremidade online.

Saiba como usar o Azure Machine Learning para implantar um modelo como um serviço Web no Serviço de Kubernetes do Azure (AKS). O Serviço de Kubernetes do Azure é bom para implantações de produção de grande escala. Use o Serviço de Kubernetes do Azure se você precisar de um ou mais dos seguintes recursos:

  • Tempo de resposta rápido
  • Dimensionamento automático do serviço implantado
  • Logging
  • Coleta de dados de modelo
  • Autenticação
  • Encerramento de TLS
  • Opções de aceleração de hardware, como GPU e matrizes de portas programáveis em campo (FPGA)

Ao implantar no Serviço de Kubernetes do Azure, você implanta em um cluster do AKS que está conectado ao seu workspace. Para obter informações sobre como conectar um cluster do AKS ao seu workspace, confira Criar e anexar um cluster do Serviço de Kubernetes do Azure.

Importante

Recomendamos depurar localmente antes de implantar no serviço Web. Para saber mais, consulte Depurar Localmente

Você também pode ver o Azure Machine Learning - Implantar no notebook local

Observação

Os Pontos de Extremidade do Azure Machine Learning (v2) fornecem uma experiência de implantação aprimorada e mais simples. Os pontos de extremidade dão suporte a cenários de inferência em tempo real e em lote. Os pontos de extremidade oferecem uma interface unificada para invocar e gerenciar implantações de modelo dentre os tipos de computação. Confira O que são os pontos de extremidade do Azure Machine Learning?.

Pré-requisitos

Compreender o processo de implantação

O termo "implantação" é usado no Kubernetes e no Azure Machine Learning. "Implantação" tem significados diferentes nesses dois contextos. No Kubernetes, uma Deployment é uma entidade concreta, especificada com um arquivo YAML declarativo. Um Kubernetes Deployment tem um ciclo de vida definido e relações concretas com outras entidades do Kubernetes, como Pods e ReplicaSets. Você pode aprender sobre o Kubernetes com documentos e vídeos em O que é o Kubernetes?.

No Azure Machine Learning, a "implantação" é usada no sentido mais geral de disponibilizar e limpar os recursos do projeto. As etapas que o Azure Machine Learning considera parte da implantação são:

  1. Compactar os arquivos na pasta do projeto, ignorando aqueles especificados em .amlignore ou .gitignore
  2. Dimensionar verticalmente o cluster de computação (relacionado ao Kubernetes)
  3. Criação ou fazer download do dockerfile no nó de computação (relacionado ao Kubernetes)
    1. O sistema calcula um hash:
    2. O sistema usa esse hash como chave em uma pesquisa do ACR (Registro de Contêiner do Azure) do workspace
    3. Se não for encontrado, ele procurará uma correspondência no ACR global
    4. Se não for encontrado, o sistema compilará uma nova imagem (que será armazenada em cache e enviada por push para o ACR do workspace)
  4. Fazer download do arquivo compactado do projeto em um armazenamento temporário no nó de computação
  5. Descompactar o arquivo do projeto
  6. O nó de computação que está executando o python <entry script> <arguments>
  7. Salvar os logs, os arquivos de modelo e outros arquivos gravados em ./outputs na conta de armazenamento associada ao workspace
  8. Dimensionar verticalmente a computação, incluindo a remoção do armazenamento temporário (relacionado ao Kubernetes)

Roteador do Azure Machine Learning

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

Importante

Ao usar um cluster configurado como dev-test, o dimensionamento automático é desabilitado. Mesmo para clusters FastProd/DenseProd, o Self-Scaler só é habilitado quando a telemetria mostra que ele é necessário.

Observação

O conteúdo máximo da solicitação é de 100MB.

O Azureml-fe é dimensionado verticalmente para usar mais núcleos e horizontalmente para usar mais pods. Ao tomar a decisão de dimensionar verticalmente, o tempo necessário para rotear solicitações de inferência de entrada é usado. Se esse tempo exceder o limite, ocorrerá um dimensionamento vertical. Se o tempo para rotear solicitações de entrada continuar a exceder o limite, ocorrerá uma expansão.

Ao dimensionar vertical e horizontalmente, o uso da CPU é empregado. Se o limite de uso da CPU for atingido, o front-end será dimensionado verticalmente primeiro. Se o uso da CPU cair para o limite de redução, ocorrerá uma operação de dimensionamento horizontal. O dimensionamento vertical ou horizontal somente ocorrerá se houver recursos de cluster suficientes disponíveis.

Ao aumentar ou reduzir verticalmente, os pods azureml-fe serão reiniciados para aplicar as alterações de CPU/memória. As solicitações de inferência não são afetadas pelas reinicializações.

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

Quando o Azure Machine Learning cria ou anexa um cluster do Serviço de Kubernetes do Azure, o cluster é implantado com um de dois modelos de rede:

  • Rede Kubenet – os recursos de rede normalmente são criados e configurados à medida que o cluster AKS é implantado.
  • Rede da CNI (Interface de rede de contêiner) do Azure – o cluster AKS é conectado a um recurso e configurações de rede virtual existentes.

No caso da rede do Kubernetes, ela é criada e configurada corretamente para o serviço do Azure Machine Learning. Para a rede de CNI, você precisa entender os requisitos de conectividade e garantir a resolução de DNS e a conectividade de saída para inferência do AKS. Por exemplo, talvez você esteja usando um firewall para bloquear o tráfego de rede.

O diagrama a seguir mostra os requisitos de conectividade para inferência do 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.

Connectivity Requirements for AKS Inferencing

Para requisitos gerais de conectividade do AKS, confira Controlar o tráfego de saída para nós de cluster no Serviço de Kubernetes do Azure.

Para acessar os serviços do Azure Machine Learning com a proteção de um firewall, confira Como acessar o azureml com a proteção de um firewall.

Requisitos gerais de resolução de DNS

A resolução de DNS na VNet existente está sob seu controle. Por exemplo, um firewall ou servidor DNS personalizado. Os hosts a seguir devem estar acessíveis:

Nome do host Usado por
<cluster>.hcp.<region>.azmk8s.io Servidor de API do AKS
mcr.microsoft.com MCR (Microsoft Container Registry)
<ACR name>.azurecr.io Seu ACR (Registro de Contêiner do Azure)
<account>.table.core.windows.net Conta de Armazenamento do Azure (armazenamento de tabelas)
<account>.blob.core.windows.net Conta de Armazenamento do Azure (armazenamento de blob)
api.azureml.ms autenticação do Microsoft Entra
ingest-vienna<region>.kusto.windows.net Ponto de extremidade do Kusto para carregar a telemetria
<leaf-domain-label + auto-generated suffix>.<region>.cloudapp.azure.com Nome de domínio do ponto de extremidade, se gerado automaticamente pelo Azure Machine Learning. Se você tiver usado um nome de domínio personalizado, não precisará dessa entrada.

Requisitos de conectividade em ordem cronológica: da criação do cluster à implantação do modelo

No processo de criação ou de anexação do AKS, o roteador do Azure Machine Learning (azureml-fe) é implantado no cluster do AKS. Para implantar o roteador do Azure Machine Learning, o nó do AKS deve ter a capacidade de:

  • Resolver o DNS para o servidor de API do Serviço de Kubernetes do Azure
  • Resolver o DNS para o MCR a fim de baixar as imagens do Docker para o roteador do Azure Machine Learning
  • Fazer download das imagens do MCR, em que a conectividade de saída é necessária

Logo após o azureml-fe ser implantado, ele tentará iniciar e esse projeto exigirá:

  • Resolver o DNS para o servidor de API do Serviço de Kubernetes do Azure
  • Consultar o servidor de API do Serviço de Kubernetes do Azure para descobrir outras instâncias próprias (é um serviço multipod)
  • Conectar-se a outras instâncias próprias

Quando o azureml-fe for iniciado, ele exigirá a seguinte conectividade para funcionar corretamente:

  • Conectar-se ao Armazenamento do Microsoft Azure para fazer download da configuração dinâmica
  • Resolva o DNS para o servidor de autenticação api.azureml.ms do Microsoft Entra e comunique-se com ele quando o serviço implantado usar a autenticação do Microsoft Entra.
  • Consultar o servidor de API do Serviço de Kubernetes do Azure para descobrir os modelos implantados
  • Comunicar-se com os PODs de modelo implantados

Na hora da implantação do modelo, para ela ser bem-sucedida, o nó de AKS deve poder:

  • Resolver o DNS para o ACR do cliente
  • Fazer download das imagens do ACR do cliente
  • Resolver o DNS para os blobs do Azure em que o modelo é armazenado
  • Fazer download dos modelos de blobs do Azure

Depois da implantação do modelo e da inicialização do serviço, o azureml-fe o descobrirá automaticamente usando a API do Serviço de Kubernetes do Azure e estará pronto para rotear a solicitação para ele. Ele deve poder se comunicar com os PODs de modelo.

Observação

Se o modelo implantado exigir conectividade (por exemplo, consultar o banco de dados externo ou outro serviço REST, baixar um blob etc.), a resolução do DNS e a comunicação de saída para esses serviços deverão ser habilitadas.

Implantar no AKS

Para implantar um modelo no Serviço de Kubernetes do Azure, 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 a 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, confira Como e onde implantar modelos.

Observação

O número de modelos a serem implantados é limitado a 1.000 modelos por implantação (por contêiner).

APLICA-SE A:azureml do SDK do Python v1

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

Para obter mais informações sobre as classes, os métodos e os parâmetros usados neste exemplo, confira os seguintes documentos de referência:

Dimensionamento automático

APLICA-SE A:azureml do SDK do Python v1

O componente que lida com o dimensionamento automático das implantações de modelo do Azure Machine Learning é o azureml-fe, que é um roteador de solicitações inteligente. Como todas as solicitações de inferência passam por ela, ela contém os dados necessários para dimensionar automaticamente os modelos implantados.

Importante

  • Não habilite o dimensionamento automático de pod horizontal do Kubernetes (HPA) para implantações de modelo. Isso faz os dois componentes de dimensionamento automático concorrerem entre si. O azureml-fe foi projetado para escalar automaticamente os modelos implantados pelo Azure Machine Learning, em que o HPA precisará estimar ou aproximar a utilização do modelo com base em uma métrica genérica, como o uso da CPU ou uma configuração de métrica personalizada.

  • O Azureml-fe não dimensiona o número de nós em um cluster do Serviço de Kubernetes do Azure, pois isso pode levar a um aumento de custos inesperado. Em vez disso, ele dimensiona o número de réplicas para o modelo dentro dos limites do cluster físico. Se você precisar dimensionar o número de nós dentro do cluster, poderá dimensionar manualmente o cluster ou configurar o dimensionamento automático do cluster do Serviço de Kubernetes do Azure.

O dimensionamento automático pode ser controlado ao configurar autoscale_target_utilization, autoscale_min_replicas e autoscale_max_replicas para o serviço Web do Serviço de Kubernetes do Azure. 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 para dimensionar verticalmente/horizontalmente baseiam-se na utilização das réplicas de contêiner. O número de réplicas ocupadas (com o processamento de uma solicitação) dividido pelo número total de réplicas é a utilização atual. Se esse número exceder autoscale_target_utilization, mais réplicas serão criadas. Se for menor, as réplicas serão reduzidas. Por padrão, a utilização de destino é de 70%.

As decisões para adicionar réplicas são adiantadas 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 como definir autoscale_target_utilization, autoscale_max_replicas e autoscale_min_replicas, confira a referência do módulo AksWebservice.

Autenticação de serviço Web

Ao implantar no Serviço de Kubernetes do Azure, a autenticação baseada em chave é habilitada por padrão. Você também pode habilitar a autenticação baseada em token. A autenticação baseada em token exige que os clientes usem uma conta do Microsoft Entra para solicitar um token de autenticação, que é usado para fazer solicitações ao serviço implantado.

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

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

Para obter informações sobre como autenticar um aplicativo cliente, confira Consumir um modelo do Azure Machine Learning implantado como um serviço Web.

Autenticação com chaves

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

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

Importante

Se você precisar regenerar uma chave, use service.regen_key.

Autenticação com tokens

Para habilitar a autenticação do token, defina o parâmetro token_auth_enabled=True ao criar ou atualizar uma implantação. O exemplo a seguir habilita a autenticação do token usando o SDK:

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

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

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

Importante

Será necessário solicitar um novo token depois do período de refresh_by do token.

A Microsoft recomenda fortemente criar seu workspace do Azure Machine Learning na mesma região que o cluster do Serviço de Kubernetes do Azure. Para autenticar com um token, o serviço Web fará uma chamada para a região em que o workspace do Azure Machine Learning foi criado. Se a região do workspace não estiver disponível, não será possível buscar um token para o serviço Web, mesmo que o cluster esteja em uma região diferente do workspace. Isso resulta na indisponibilidade da Autenticação Baseada em Token até que a região do seu workspace esteja disponível novamente. Além disso, quanto maior a distância entre a região do cluster e a região do workspace, mais tempo será necessário para buscar o token.

Para recuperar um token, você deve usar o SDK do Azure Machine Learning ou o comando az ml service get-access-token.

Verificação de vulnerabilidade

O Microsoft Defender para nuvem fornece um gerenciamento de segurança unificado e proteção avançada contra ameaças nas cargas de trabalho de nuvem híbrida. Você deve permitir que o Microsoft Defender para nuvem verifique seus recursos e siga suas recomendações. Para obter mais informações, confira Integração do Serviço de Kubernetes do Azure com o Defender para nuvem.

Próximas etapas