Implantar um modelo de machine learning para o Azure Functions com o Cache do Azure para Redis

Artigo
06/01/2023

Neste artigo, você implantará um modelo do Azure Machine Learning como um aplicativo de funções no Azure Functions, usando uma instância do Cache do Azure para Redis.

O Cache do Azure para Redis é de alto desempenho e escalonável. Ao emparelhar com um modelo do Azure Machine Learning, você ganha latência baixa e alta taxa de transferência em seu aplicativo. Alguns cenários em que um cache é benéfico: na inferência de dados e nos resultados de inferência de modelo real. Em ambos os cenários, os metadados ou os resultados são armazenados na memória, o que leva a um desempenho maior.

Observação

Embora o Azure Machine Learning e o Azure Functions estejam geralmente disponíveis, a capacidade de empacotar um modelo do serviço do Machine Learning para o Functions está em versão preliminar.

Pré-requisitos

Assinatura do Azure – Crie uma gratuitamente.
Um Workspace do Azure Machine Learning. Para obter mais informações, consulte o artigo Criar um espaço de trabalho.
CLI do Azure.
Um modelo de machine learning treinado registrado em seu espaço de trabalho. Se você não tiver um modelo, use o Tutorial de classificação de imagem: treinar modelo para treinar e registrar um.

Importante

Os snippets de código neste artigo pressupõem que você definiu as seguintes variáveis:

ws - seu workspace do Azure Machine Learning.
model - o modelo registrado que será implantado.
inference_config - a configuração de inferência do modelo.

Para obter mais informações sobre a configuração dessas variáveis, consulte Implantar modelos com o Azure Machine Learning.

Criar uma instância de Cache do Azure para Redis

Você poderá implantar um modelo de machine learning para o Azure Functions com qualquer instância de cache Básico, Standard ou Premium. Para criar uma instância de cache, siga estas etapas.

Volte para a página inicial do portal do Azure ou abra o menu da barra lateral e selecione Criar um recurso.
Na página Novo, selecione Bancos de dados e, em seguida, Cache do Azure para Redis.

Na página Novo Cache Redis, defina as configurações para o novo cache.

Configuração	Valor sugerido	DESCRIÇÃO
Nome DNS	Insira um nome global exclusivo.	O nome do cache deve ser uma cadeia de caracteres entre 1 e 63 caracteres. A cadeia de caracteres deve conter apenas números, letras ou hifens. O nome precisa começar e terminar com um número ou uma letra e não pode conter hifens consecutivos. O nome do host da instância de cache será o <nome DNS>.redis.cache.windows.net.
Assinatura	Clique na lista suspensa e selecione sua assinatura.	A assinatura na qual essa nova instância do Cache do Azure para Redis será criada.
Grupo de recursos	Clique na lista suspensa e selecione um grupo de recursos ou selecione Criar e insira um novo nome de grupo de recursos.	Nome do grupo de recursos no qual o cache e outros recursos serão criados. Ao colocar todos os seus recursos de aplicativos em um só grupo de recursos, você pode gerenciá-los ou excluí-los juntos com facilidade.
Localidade	Clique na lista suspensa e selecione uma localização.	Selecione uma região perto de outros serviços que usarão o cache.
Tipo de preços	Clique na lista suspensa e selecione um Tipo de preço.	O tipo de preço determina o tamanho, o desempenho e os recursos disponíveis para o cache. Para obter mais informações, confira Visão geral do Cache do Azure para Redis.

Selecione a guia Rede ou o botão Rede na parte inferior da página.
Na guia Rede, escolha o método de conectividade.
Selecione a guia Próximo: Avançado ou o botão Próximo: Avançado na parte inferior da página.
Na guia Avançado de uma instância de cache Básico ou Standard, selecione a alternância Habilitar se desejar habilitar uma porta não TLS.
Na guia Avançado de uma instância de cache Premium, defina as configurações da porta não TLS, do clustering e da persistência de dados.
Selecione a guia Próximo: Marcas ou o botão Próximo: Marcas na parte inferior da página.
Opcionalmente, na guia Marcas, insira o nome e o valor caso deseje categorizar o recurso.
Selecione Examinar + criar. Você será levado para a guia Examinar + criar, na qual o Azure valida sua configuração.
Depois que a mensagem em verde Validação aprovada for exibida, selecione Criar.

A criação do cache demora um pouco. Monitore o progresso na página Visão Geral do Cache do Azure para Redis. Quando o Status for mostrado como Em execução, o cache estará pronto para uso.

Preparar para a implantação

Antes de implantar, você deve definir o que é necessário para executar o modelo como um serviço Web. A lista a seguir descreve os principais itens necessários para uma implantação:

Um script de entrada. Esse script aceita solicitações, pontua a solicitação usando o modelo e retorna os resultados.

Importante

O script de entrada é específico para seu modelo e ele deve reconhecer o formato dos dados de solicitação de entrada, o formato dos dados esperados pelo seu modelo e o formato dos dados retornados aos clientes.

Se os dados da solicitação estiverem em um formato que não pode ser usado pelo seu modelo, o script poderá transformá-lo em um formato aceitável. Ele também pode transformar a resposta antes de retorná-la ao cliente.

Por padrão, ao empacotar para funções, a entrada é tratada como texto. Se você tiver interesse em consumir os bytes brutos da entrada (por exemplo, para gatilhos de BLOB), deverá usar AMLRequest para aceitar dados brutos.

Para a função de execução, verifique se ela se conecta a um ponto de extremidade Redis.

import json
import numpy as np
import os
import redis
from sklearn.externals import joblib

def init():
    global model
    global azrediscache
    azrediscache = redis.StrictRedis(host='<host_url>', port=6380, password="<access_key>", ssl=True)
    model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'sklearn_mnist_model.pkl')
    model = joblib.load(model_path)

@input_schema('data', NumpyParameterType(input_sample))
@output_schema(NumpyParameterType(output_sample))
def run(data):
    try:
        input = azrediscache.get(data)
        result = model.predict(input)
        data = np.array(json.loads(data))
        result = model.predict(data)
        # You can return any data type, as long as it is JSON serializable.
        return result.tolist()
    except Exception as e:
        error = str(e)
        return error

Para obter mais informações sobre o script de entrada, consulte Definir código de pontuação.

Dependências, como scripts auxiliares ou pacotes Python/Conda necessários para executar o modelo ou o script de entrada

Essas entidades são encapsuladas em uma configuração de inferência. A configuração de inferência faz referência ao script de entrada e a outras dependências.

Importante

Ao criar uma configuração de inferência para uso com o Azure Functions, você deve usar um objeto de Ambiente. Observe que, se estiver definindo um ambiente personalizado, você deverá adicionar azureml-defaults com versão >= 1.0.45 como dependência pip. Esse pacote contém a funcionalidade necessária para hospedar o modelo como um serviço Web. O exemplo a seguir demonstra como criar um objeto de ambiente e usá-lo com uma configuração de inferência:

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

# Create an environment and add conda dependencies to it
myenv = Environment(name="myenv")
# Enable Docker based environment
myenv.docker.enabled = True
# Build conda dependencies
myenv.python.conda_dependencies = CondaDependencies.create(conda_packages=['scikit-learn'],
                                                           pip_packages=['azureml-defaults', 'redis'])
inference_config = InferenceConfig(entry_script="score.py", environment=myenv)

Para obter mais informações sobre ambientes, confira Criar e gerenciar ambientes para treinamento e implantação.

Para obter mais informações sobre configuração de inferência, confira Implantar modelos com o Azure Machine Learning.

Importante

Ao implantar para o Azure Functions, você não precisa criar uma configuração de implantação.

Instalar o pacote de versão preliminar do SDK para suporte do Azure Functions

Para criar pacotes para o Azure Functions, você deve instalar o pacote de versão preliminar do SDK.

pip install azureml-contrib-functions

Criar a imagem

Para criar a imagem Docker que será implantada no Azure Functions, use azureml.contrib.functions.package ou a função de pacote específica para o gatilho que você quiser usar. O snippet de código a seguir demonstra como criar um novo pacote com um gatilho HTTP, a partir do modelo e da configuração de inferência:

Observação

O snippet de código pressupõe que model contém um modelo registrado e que inference_config contém a configuração para o ambiente de inferência. Para saber mais, consulte Implantar modelos com o Azure Machine Learning.

from azureml.contrib.functions import package
from azureml.contrib.functions import HTTP_TRIGGER
model_package = package(ws, [model], inference_config, functions_enabled=True, trigger=HTTP_TRIGGER)
model_package.wait_for_creation(show_output=True)
# Display the package location/ACR path
print(model_package.location)

Quando show_output=True, a saída do processo de build do Docker é mostrada. Quando o processo for concluído, a imagem terá sido criada no Registro de Contêiner do Azure para seu espaço de trabalho. Depois que a imagem tiver sido criada, o local no Registro de Contêiner do Azure será exibido. no formato <acrinstance>.azurecr.io/package@sha256:<imagename>.

Observação

O empacotamento para o Azure Functions atualmente dá suporte a gatilhos HTTP, gatilhos de BLOB e gatilhos do barramento de serviço. Para obter mais informações sobre gatilhos, consulte associações do Azure Functions.

Importante

Salve as informações de local, pois elas são usadas durante a implantação da imagem.

Implantar imagem como um aplicativo Web

Use o comando a seguir para obter as credenciais de logon para o Registro de Contêiner do Azure que contém a imagem. Substitua <myacr> pelo valor retornado anteriormente de package.location:
```
az acr credential show --name <myacr>
```
A saída desse comando é semelhante ao documento JSON a seguir:
```
{
"passwords": [
    {
    "name": "password",
    "value": "abcdefghijklmmopqrstuv1234567890"
    },
    {
    "name": "password2",
    "value": "1234567890abcdefghijklmmopqrstuv"
    }
],
"username": "charlie.roy"
}
```
Copie os valores de nome de usuário e uma dassenhas.
Caso você ainda não tenha um grupo de recursos ou um plano de serviço do aplicativo para implantar o serviço, utilize os comandos a seguir, que demonstram como criar ambos:
```
az group create --name myresourcegroup --location "West Europe"
az appservice plan create --name myplanname --resource-group myresourcegroup --sku B1 --is-linux
```
Neste exemplo, um tipo de preço básico do Linux (--sku B1) é usado.

Importante

As imagens criadas peplo Azure Machine Learning usam o Linux, portanto, você deve usar o parâmetro --is-linux.

Crie a conta de armazenamento a ser usada para o armazenamento de trabalhos da Web e obtenha sua cadeia de conexão. Substitua <webjobStorage> pelo nome que deseja usar.

az storage account create --name <webjobStorage> --location westeurope --resource-group myresourcegroup --sku Standard_LRS

az storage account show-connection-string --resource-group myresourcegroup --name <webJobStorage> --query connectionString --output tsv

Para criar o aplicativo de funções, use o comando a seguir. Substitua <app-name> pelo nome de usuário que deseja usar. Substitua <acrinstance> e <imagename> pelos valores package.location retornados anteriormente. Substitua <webjobStorage> pelo nome da conta de armazenamento criada na etapa anterior:
```
az functionapp create --resource-group myresourcegroup --plan myplanname --name <app-name> --deployment-container-image-name <acrinstance>.azurecr.io/package:<imagename> --storage-account <webjobStorage>
```
Importante

Neste ponto, o aplicativo de funções foi criado. No entanto, como você não forneceu a cadeia de conexão para o gatilho HTTP ou as credenciais para o Registro de Contêiner do Azure que contém a imagem, o aplicativo de funções não está ativo. Nas próximas etapas, você fornecerá a cadeia de conexão e as informações de autenticação para o registro de contêiner.

Para fornecer ao aplicativo de funções as credenciais necessárias para acessar o registro de contêiner, use o comando a seguir. Substitua <app-name> pelo nome do aplicativo de funções. Substitua <acrinstance> e <imagetag> pelos valores da chamada AZ CLI na etapa anterior. Substitua <username> e <password> pelas informações de logon do ACR recuperadas anteriormente:

az functionapp config container set --name <app-name> --resource-group myresourcegroup --docker-custom-image-name <acrinstance>.azurecr.io/package:<imagetag> --docker-registry-server-url https://<acrinstance>.azurecr.io --docker-registry-server-user <username> --docker-registry-server-password <password>

Esse comando retorna informações semelhantes ao seguinte documento JSON:

[
{
    "name": "WEBSITES_ENABLE_APP_SERVICE_STORAGE",
    "slotSetting": false,
    "value": "false"
},
{
    "name": "DOCKER_REGISTRY_SERVER_URL",
    "slotSetting": false,
    "value": "[server-name].azurecr.io"
},
{
    "name": "DOCKER_REGISTRY_SERVER_USERNAME",
    "slotSetting": false,
    "value": "[username]"
},
{
    "name": "DOCKER_REGISTRY_SERVER_PASSWORD",
    "slotSetting": false,
    "value": null
},
{
    "name": "DOCKER_CUSTOM_IMAGE_NAME",
    "value": "DOCKER|[server-name].azurecr.io/package:20190827195524"
}
]

Neste ponto, o aplicativo de funções começa a carregar a imagem.

Importante

Pode levar vários minutos para que a imagem seja carregada. Você pode monitorar o progresso usando o portal do Azure.

Testar o gatilho HTTP do Azure Functions

Agora, vamos executar e testar nosso gatilho HTTP do Azure Functions.

Vá para seu aplicativo de funções no portal do Azure.
Em desenvolvedor, selecione Código + teste.
No lado direito, selecione a guia Entrada.
Clique no botão Executar para testar o gatilho HTTP do Azure Functions.

Agora você implantou, com êxito, um modelo do Azure Machine Learning como um aplicativo de funções, usando uma instância do Cache do Azure para Redis. Saiba mais sobre o Cache do Azure para Redis navegando até os links na seção abaixo.

Limpar recursos

Se você pretende continuar até o próximo tutorial, pode manter os recursos criados neste início rápido e reutilizá-los.

Caso contrário, se você concluiu o início rápido, pode excluir os recursos do Azure criados neste início rápido para evitar cobranças.

Importante

A exclusão de um grupo de recursos é irreversível. Ao excluir o grupo de recursos, todos os recursos nele são excluídos permanentemente. Não exclua acidentalmente o grupo de recursos ou os recursos incorretos. Se tiver criado os recursos para hospedar este exemplo dentro de um grupo de recursos existente que contém recursos que quer manter, exclua cada recurso individualmente à esquerda, em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

Entre no portal do Azure e selecione Grupos de recursos.
Na caixa Filtrar por nome..., digite o nome do seu grupo de recursos. Em seu grupo de recursos, na lista de resultados, selecione ..., depois selecione Excluir grupo de recursos.

Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Digite o nome do grupo de recursos para confirmar e selecione Excluir.

Após alguns instantes, o grupo de recursos, e todos os recursos nele são excluídos.

Próximas etapas

Saiba mais sobre o Cache do Azure para Redis
Saiba como configurar seu aplicativo de funções na documentação do Azure Functions.
Referência da API
Crie um aplicativo Python que usa um Cache do Azure para Redis

Compartilhar via

Implantar um modelo de machine learning para o Azure Functions com o Cache do Azure para Redis

Pré-requisitos

Criar uma instância de Cache do Azure para Redis

Preparar para a implantação

Instalar o pacote de versão preliminar do SDK para suporte do Azure Functions

Criar a imagem

Implantar imagem como um aplicativo Web

Testar o gatilho HTTP do Azure Functions

Limpar recursos

Para excluir um grupo de recursos

Próximas etapas

Comentários

Recursos adicionais