Tutorial: Realizar a classificação de imagem na borda com o Serviço de Visão Personalizada

Aplica-se a: IoT Edge 1.5

Azure IoT Edge torna as soluções de IoT mais eficientes movendo cargas de trabalho da nuvem para a borda. Essa capacidade funciona bem para serviços que processam grandes quantidades de dados, como modelos de visão computacional. Azure AI Custom Vision permite criar classificadores de imagem personalizados e implantá-los em dispositivos como contêineres. Juntos, esses dois serviços permitem que os usuários encontrem insights de imagens ou transmissões de vídeo sem primeiro transferir todos os dados para fora do local. A Visão Personalizada fornece um classificador que compara imagens com um modelo treinado para gerar insights.

Por exemplo, a Visão Personalizada em um dispositivo IoT Edge pode determinar se uma rodovia tem tráfego maior ou menor do que o normal ou se um estacionamento tem vagas de estacionamento disponíveis em uma linha. Essas informações podem ser compartilhadas com outro serviço que atuará em relação a elas.

Neste tutorial, você aprenderá como:

Se você não tiver uma conta Azure, crie uma conta free antes de começar.

Pré-requisitos

• Configure seu ambiente para o desenvolvimento de contêineres Linux, concluindo o Tutorial: desenvolver módulos IoT Edge usando o Visual Studio Code com a ferramenta de desenvolvimento de linha de comando (CLI) Azure IoT Edge Dev Tool. Depois de concluir o tutorial, verifique se os seguintes pré-requisitos estão disponíveis em seu ambiente de desenvolvimento:

  • Uma camada gratuita ou padrão IoT Hub em Azure
  • Um dispositivo que executa Azure IoT Edge com contêineres do Linux. Use os guias de início rápido para configurar um dispositivo Linux ou dispositivo Windows.
  • Um registro de contêiner, como Azure Container Registry.
  • Visual Studio Code configurado com a extensão Azure IoT Hub.
  • Baixe e instale um sistema de gerenciamento de contêiner compatível com Docker em seu computador de desenvolvimento. Configure-o para executar contêineres do Linux.

• Para desenvolver um módulo IoT Edge com o serviço de Visão Personalizada, verifique se os seguintes pré-requisitos adicionais estão instalados em seu computador de desenvolvimento:

  • Python
  • Git
  • extensão Python para Visual Studio Code

Criar um classificador de imagem com a Visão Personalizada

Para criar um classificador de imagem, crie um projeto de Visão Personalizada e forneça imagens de treinamento. Para obter mais informações sobre as etapas que você seguirá nesta seção, consulte Como criar um classificador com a Visão Personalizada.

Depois de compilar e treinar o classificador de imagem, exporte-o como um contêiner do Docker e implante-o em um dispositivo IoT Edge.

Criar um novo projeto

1. No navegador da Web, navegue até a página da Web da Visão Personalizada.

2. Selecione Sign in e entre com a mesma conta que você usa para acessar Azure recursos.

3. Selecione Novo projeto.

4. Crie seu projeto com os seguintes valores:

   Campo	Valor
   Nome	Forneça um nome para o projeto, como EdgeTreeClassifier.
   Descrição	Descrição do projeto opcional.
   Recurso	Selecione um de seus grupos de recursos Azure que inclua um recurso do Serviço de Visão Personalizada ou criar novo se ainda não tiver adicionado um.
   Tipos de projeto	Classificação
   Tipos de classificação	Multiclasses (uma marca por imagem)
   Domínios	Geral (compacto)
   Exportar funcionalidades	Plataformas básicas (TensorFlow, CoreML, ONNX etc.)

5. Selecione Criar projeto.

Carregar imagens e treinar o classificador

A criação de um classificador de imagem requer um conjunto de imagens de treinamento e imagens de teste.

1. Clone ou baixe imagens de exemplo do repositório Cognitive-CustomVision-Windows para seu computador de desenvolvimento local.

   git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
   

2. Retorne ao projeto da Visão Personalizada e selecione Adicionar imagens.

3. Navegue até o repositório git clonado localmente e navegue até a primeira pasta de imagem, Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Selecione todas as 10 imagens na pasta e selecione Abrir.

4. Adicione a tag hemlock a esse grupo de imagens e então pressione enter para aplicar a tag.

5. Selecione Carregar 10 arquivos.

   

6. Quando as imagens forem carregadas com êxito, selecione Concluído.

7. Selecione Adicionar imagens novamente.

8. Navegue até a segunda pasta de imagem, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Selecione todas as dez imagens na pasta e selecione Abrir.

9. Adicione a marca japanese cherry a esse grupo de imagens e pressione Enter para aplicar a marca.

10. Selecione Carregar 10 arquivos. Quando as imagens forem carregadas com êxito, selecione Concluído.

11. Depois de marcar e carregar os dois conjuntos de imagens, selecione Treinar para treinar o classificador.

Exportar o classificador

1. Depois de treinar o classificador, selecione Exportar na página Desempenho do classificador.

   

2. Selecione DockerFile como a plataforma.

3. Selecione Linux como a versão.

4. Selecione Exportar.

5. Depois que a exportação for concluída, selecione Baixar e salvar o pacote .zip localmente em seu computador. Extraia todos os arquivos do pacote. Use esses arquivos para criar um módulo IoT Edge que contém o servidor de classificação de imagem.

Quando você chegar a este ponto, terá concluído a criação e o treinamento de seu projeto da Visão Personalizada. Você usará os arquivos exportados na próxima seção, mas terminou de usar a página da Web da Visão Personalizada.

Criar uma solução de IoT Edge

Agora você tem os arquivos para uma versão de contêiner do classificador de imagem no computador de desenvolvimento. Nesta seção, você configurará o contêiner do classificador de imagem para ser executado como um módulo de IoT Edge. Você também cria um segundo módulo que posta solicitações ao classificador e envia os resultados como mensagens para IoT Hub.

Criar uma nova solução

Uma solução é uma maneira lógica de desenvolver e organizar vários módulos para uma única implantação IoT Edge. Uma solução contém código para um ou mais módulos e o manifesto de implantação que declara como configurá-los em um dispositivo IoT Edge. Crie a solução usando a ferramenta Azure IoT Edge Dev Tool ferramenta de desenvolvimento da CLI (linha de comando). A maneira mais simples de usar a ferramenta é Run the IoT Edge Dev Container with Docker.

1. Criar um diretório chamado classificador e alterar para o diretório.

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Execute o comando init da ferramenta iotedgedev para criar uma nova solução IoT Edge. No contêiner IoT Edge Dev Docker, insira o seguinte comando:

   iotedgedev solution init --template python --module classifier
   

   O script iotedgedev solution init solicita que você conclua várias etapas, incluindo:

   • Autenticar no Azure
   • Escolher uma assinatura Azure
   • Escolher ou criar um grupo de recursos
   • Escolher ou criar um Azure IoT Hub
   • Escolher ou criar um dispositivo Azure IoT Edge

   O comando cria uma nova solução IoT Edge com um módulo chamado classifier no diretório de trabalho atual.

3. Abra a solução no Visual Studio Code.

Adicionar o classificador de imagem

O modelo de módulo Python no Visual Studio Code contém algum código de exemplo que você pode executar para testar IoT Edge. Você não usará esse código neste cenário. Use as etapas nesta seção para substituir o código de exemplo pelo contêiner de classificador de imagem que você exportou anteriormente.

1. No explorador de arquivos, navegue até o pacote da Visão Personalizada que você baixou e extraiu. Copie todo o conteúdo do pacote extraído. Ele deve incluir duas pastas, app e azureml, e dois arquivos, Dockerfile e README.

2. No explorador de arquivos, navegue até o diretório onde o Visual Studio Code foi instruído a criar sua solução IoT Edge.

3. Abra a pasta do módulo classificador. Se você usou os nomes sugeridos na seção anterior, a estrutura de pasta se parecerá com CustomVisionSolution/modules/classifier.

4. Cole os arquivos na pasta classifier.

5. Retorne à janela do Visual Studio Code. O workspace da solução agora deve mostrar os arquivos do classificador de imagem na pasta do módulo.

6. Substitua o arquivo Dockerfile.amd64 original pelo Dockerfile do pacote de visão personalizada excluindo o Dockerfile.amd64 original e renomeando Dockerfile para Dockerfile.amd64.

7. Salve suas alterações.

Criar um módulo de câmera simulada

Em uma implantação de visão personalizada real, uma câmera fornece imagens ao vivo ou fluxos de vídeo. Neste cenário, você pode simular a câmera criando um módulo que envia uma imagem de teste para o classificador de imagem.

Nesta seção, você adiciona um novo módulo ao mesmo CustomVisionSolution e fornece o código para criar a câmera simulada.

1. Use a ferramenta iotedgedev para adicionar um novo módulo à solução. O comando cria uma nova pasta chamada cameracapture na pasta módulos da sua solução.

   iotedgedev solution add --template python cameracapture
   

2. Abra o arquivo main.py na pastacameracapture / .

3. Substitua o aquivo inteiro pelo código a seguir. Esse código de exemplo envia solicitações POST para o serviço de processamento de imagens em execução no módulo do classificador. Nós fornecemos a esse contêiner de módulo uma imagem de exemplo para usar nas solicitações. Em seguida, ele empacota a resposta como uma mensagem IoT Hub e a envia para uma fila de saída.

   # Copyright (c) Microsoft. All rights reserved.
   # Licensed under the MIT license. See LICENSE file in the project root for
   # full license information.
   
   import time
   import sys
   import os
   import requests
   import json
   from azure.iot.device import IoTHubModuleClient, Message
   
   # global counters
   SENT_IMAGES = 0
   
   # global client
   CLIENT = None
   
   # Send a message to IoT Hub
   # Route output1 to $upstream in deployment.template.json
   def send_to_hub(strMessage):
       message = Message(bytearray(strMessage, 'utf8'))
       CLIENT.send_message_to_output(message, "output1")
       global SENT_IMAGES
       SENT_IMAGES += 1
       print( "Total images sent: {}".format(SENT_IMAGES) )
   
   # Send an image to the image classifying server
   # Return the JSON response from the server with the prediction result
   def sendFrameForProcessing(imagePath, imageProcessingEndpoint):
       headers = {'Content-Type': 'application/octet-stream'}
   
       with open(imagePath, mode="rb") as test_image:
           try:
               response = requests.post(imageProcessingEndpoint, headers = headers, data = test_image)
               print("Response from classification service: (" + str(response.status_code) + ") " + json.dumps(response.json()) + "\n")
           except Exception as e:
               print(e)
               print("No response from classification service")
               return None
   
       return json.dumps(response.json())
   
   def main(imagePath, imageProcessingEndpoint):
       try:
           print ( "Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit." )
   
           try:
               global CLIENT
               CLIENT = IoTHubModuleClient.create_from_edge_environment()
           except Exception as iothub_error:
               print ( "Unexpected error {} from IoTHub".format(iothub_error) )
               return
   
           print ( "The sample is now sending images for processing and will indefinitely.")
   
           while True:
               classification = sendFrameForProcessing(imagePath, imageProcessingEndpoint)
               if classification:
                   send_to_hub(classification)
               time.sleep(10)
   
       except KeyboardInterrupt:
           print ( "IoT Edge module sample stopped" )
   
   if __name__ == '__main__':
       try:
           # Retrieve the image location and image classifying server endpoint from container environment
           IMAGE_PATH = os.getenv('IMAGE_PATH', "")
           IMAGE_PROCESSING_ENDPOINT = os.getenv('IMAGE_PROCESSING_ENDPOINT', "")
       except ValueError as error:
           print ( error )
           sys.exit(1)
   
       if ((IMAGE_PATH and IMAGE_PROCESSING_ENDPOINT) != ""):
           main(IMAGE_PATH, IMAGE_PROCESSING_ENDPOINT)
       else: 
           print ( "Error: Image path or image-processing endpoint missing" )
   

4. Salve o arquivo main.py.

5. Abra o arquivo requirements.txt.

6. Adicione uma nova linha para uma biblioteca a ser incluída no contêiner.

   requests
   

7. Salve o arquivo requirements.txt .

Adicionar uma imagem de teste ao contêiner

Em vez de usar uma câmera real para fornecer uma imagem de feed para este cenário, vamos usar uma única imagem de teste. Uma imagem de teste é incluída no repositório GitHub que você baixou para as imagens de treinamento anteriormente neste tutorial.

1. Navegue até a imagem de teste, localizada em Cognitive-CustomVision-Windows / Samples > / Images / Test.

2. Copie test_image.jpg

3. Navegue até o diretório da solução IoT Edge e cole a imagem de teste na pasta modules / cameracapture. A imagem deve estar na mesma pasta do arquivo main.py que você editou na seção anterior.

4. Em Visual Studio Code, abra o arquivo Dockerfile.amd64 para o módulo cameracapture.

5. Após a linha que estabelece o diretório de trabalho, WORKDIR /app, adicione a seguinte linha de código:

   ADD ./test_image.jpg .
   

6. Salve o Dockerfile.

Preparar um manifesto de implantação

Até agora neste tutorial, você treinou um modelo de visão personalizada para classificar imagens de árvores e empacotou esse modelo como um módulo IoT Edge. Em seguida, você criou um segundo módulo que consulta o servidor de classificação de imagem e relata seus resultados para IoT Hub. Agora, você está pronto para criar o manifesto de implantação que informa a um dispositivo IoT Edge como iniciar e executar esses dois módulos juntos.

A extensão IoT Edge para Visual Studio Code fornece um modelo em cada solução IoT Edge para ajudá-lo a criar um manifesto de implantação.

1. Abra o arquivo deployment.template.json na pasta da solução.

2. Defina as credenciais do Registro para os módulos no manifesto de implantação.

   "registryCredentials": {
       "<registryName>": {
           "username": "<AcrUsername>",
           "password": "<AcrPassword>",
           "address": "<registryName>.azurecr.io"
       }
   }
   

   Substitua <registryName> pelo nome do registro de contêiner Azure, e substitua <AcrUsername> e <AcrPassword> pelo nome de usuário e senha do registro. Você pode encontrar esses valores na seção Access keys do registro de contêiner Azure no portal do Azure.

3. Localize a seção módulos , que contém três módulos: os dois que você criou, o classificador e a cameracapture e um terceiro incluído por padrão, tempSensor.

4. Exclua o módulo tempSensor com todos os seus parâmetros. Este módulo fornece dados de exemplo para cenários de teste, mas não é necessário nesta implantação.

5. Se você não nomeou o módulo de classificação de imagem classifier, verifique agora se o nome está todo em minúsculas. O módulo cameracapture chama o módulo classificador usando uma biblioteca de solicitações que formata todas as solicitações em minúsculas e o IoT Edge diferencia maiúsculas de minúsculas.

6. Para cada módulo do sistema edgeAgent e edgeHub, altere o valor createOptions para uma versão em cadeia de caracteres. Por exemplo:

   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
   

7. Para cada módulo do sistema edgeAgent e edgeHub, altere a versão da imagem para a versão mais recente 1.5. Por exemplo:

   "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
   "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   

8. Atualize o parâmetro createOptions para o módulo classifier para uma versão em forma de string. Por exemplo:

   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
   

9. Atualize o parâmetro createOptions para o módulo cameracapture com o JSON a seguir. Essas informações criam variáveis de ambiente no contêiner do módulo que são recuperadas no processo main.py. Incluir essas informações no manifesto de implantação permite alterar a imagem ou o endpoint sem recriar a imagem do módulo.

   "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
   

   Se você não nomeou seu módulo de Visão Personalizada classifier, atualize o valor do ponto de extremidade de processamento de imagens para corresponder ao nome usado.

   Por exemplo, a configuração do classificador e da cameracapture deve ser semelhante a:

   "modules": {
       "classifier": {
           "version": "1.0",
           "type": "docker",
           "status": "running",
           "restartPolicy": "always",
           "settings": {
               "image": "${MODULES.classifier}",
               "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
           }
       },
       "cameracapture": {
           "version": "1.0",
           "type": "docker",
           "status": "running",
           "restartPolicy": "always",
           "settings": {
               "image": "${MODULES.cameracapture}",
               "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
           }
       }
   }
   

10. Salve o arquivo deployment.template.json.

Criar e publicar sua solução de IoT Edge

Depois de criar os dois módulos e configurar o modelo de manifesto de implantação, crie as imagens de contêiner e envie-as por push para o registro de contêiner.

Depois que as imagens estiverem no registro, você poderá implantar a solução em um dispositivo IoT Edge. Você pode definir módulos em um dispositivo por meio do IoT Hub. Nesta seção, você configurará o acesso ao seu IoT Hub e depois usará o Azure CLI para implantar sua solução no seu dispositivo IoT Edge.

Primeiro, crie e envie a solução para o registro de contêineres.

1. Abra o terminal integrado Visual Studio Code selecionando View>Terminal.

2. Entre no Docker inserindo o seguinte comando no terminal usando o nome de usuário, a senha e o servidor de logon do registro de contêiner Azure. Você pode recuperar esses valores da seção Access keys do registro no portal do Azure.

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Talvez você receba um aviso de segurança recomendando usar --password-stdin. Embora essa prática seja recomendada para cenários de produção, ela não serve para este tutorial. Para saber mais, confira a referência de logon do docker.

3. Use o Dockerfile do módulo para criar e marcar a imagem do Docker do módulo.

   docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>" 
   

   Por exemplo, para criar a imagem para o registro local ou um registro de contêiner Azure, use os seguintes comandos:

   
   # Build and tag the image for an Azure Container Registry. Replace <AcrRegistryName> with your own registry name.
   
   docker build --rm -f "./modules/classifier/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64 "./modules/classifier"
   docker build --rm -f "./modules/cameracapture/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64 "./modules/cameracapture"
   

Enviar por push a imagem do Docker do módulo

Forneça suas credenciais de registro de contêiner para o Docker para que ele possa efetuar push de sua imagem de contêiner para ser armazenada no registro.

1. Entre no Docker com as credenciais de Azure Container Registry (ACR).

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Talvez você receba um aviso de segurança recomendando usar --password-stdin. Embora essa melhor prática seja recomendada para cenários de produção, ela não serve para este tutorial. Para saber mais, confira a referência de logon do docker.

2. Entre no Azure Container Registry. Você precisa Instalar Azure CLI para usar o comando az. Esse comando solicita o nome de usuário e a senha encontrados no registro de contêiner em Configurações>Chaves de acesso.

   az acr login -n <AcrRegistryName>
   

   Dica

   Se você for desconectado em algum momento neste tutorial, repita as etapas de entrada do Docker e Azure Container Registry para continuar.

3. Efetue push da imagem do módulo para o registro local ou para um registro de contêiner.

   docker push <ImageName>
   

   Por exemplo:

   # Push the Docker image to an Azure Container Registry. Replace <AcrRegistryName> with your Azure Container Registry name.
   
   az acr login --name <AcrRegistryName>
   docker push <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64
   docker push <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64
   

Atualizar o modelo de implantação

Atualize o arquivo deployment.template.json com o local da imagem do registro de contêiner. Altere o valor da imagem para a imagem carregada no registro. Por exemplo, substitua <AcrRegistryName> pelo nome do registro nos valores de imagem para os módulos de classificador e captura de câmera:

"classifier": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    },
    "cameracapture": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
            "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
        }
    }
}

O manifesto final da implantação é semelhante ao seguinte:

{
  "$schema-template": "4.0.0",
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "schemaVersion": "1.1",
        "runtime": {
          "type": "docker",
          "settings": {
            "minDockerVersion": "v1.25",
            "loggingOptions": "",
            "registryCredentials": {
              "<AcrRegistryName>": {
                "username": "<AcrUserName>",
                "password": "<AcrPassword>",
                "address": "<AcrRegistryName>.azurecr.io"
              }
            }
          }
        },
        "systemModules": {
          "edgeAgent": {
            "type": "docker",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "edgeHub": {
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          }
        },
        "modules": {
          "classifier": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "cameracapture": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
              "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "schemaVersion": "1.2",
        "routes": {
          "classifierToIoTHub": "FROM /messages/modules/classifier/outputs/* INTO $upstream",
          "cameracaptureToIoTHub": "FROM /messages/modules/cameracapture/outputs/* INTO $upstream"
        },
        "storeAndForwardConfiguration": {
          "timeToLiveSecs": 7200
        }
      }
    }
  }
}

Implantar módulos no dispositivo

Verifique se as imagens de contêiner criadas estão armazenadas no registro de contêiner. Em seguida, implante-os em um dispositivo usando o manifesto de implantação deployment.template.json preparado para seu cenário.

Use o comando IoT Edge Azure CLI set-modules para implantar os módulos no Azure IoT Hub. Por exemplo, para implantar os módulos definidos no arquivo deployment.template.json para IoT Hub <IotHubName> para o dispositivo IoT Edge <DeviceName>, use o comando a seguir. Substitua os valores de hub-name, device-id e login na cadeia de conexão do IoT Hub com os seus próprios.

az iot edge set-modules --hub-name <IotHubName> --device-id <DeviceName> --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Verifique se o dispositivo IoT Edge está em execução.

No dispositivo, expanda Módulos para ver uma lista de módulos implantados e em execução. Selecione o botão Atualizar. Você verá os novos módulos de classificação e cameracapture em execução junto com $edgeAgent e $edgeHub.

Você também pode verificar se todos os módulos estão em execução no próprio dispositivo. Em seu dispositivo IoT Edge, execute o comando a seguir para ver o status dos módulos.

iotedge list

Os módulos podem demorar alguns minutos para iniciar. O runtime do IoT Edge precisa receber seu novo manifesto de implantação, obter as imagens de módulo do runtime do contêiner e iniciar cada novo módulo.

Exibir resultados de classificação

Em seu dispositivo, exiba os logs do módulo cameracapture para ver as mensagens enviadas e confirmar que elas são recebidas por IoT Hub.

iotedge logs cameracapture

Por exemplo, você deve ver um resultado como o seguinte:

admin@vm:~$ iotedge logs cameracapture
Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit.
The sample is now sending images for processing and will indefinitely.
Response from classification service: (200) {"created": "2023-07-13T17:38:42.940878", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

Total images sent: 1
Response from classification service: (200) {"created": "2023-07-13T17:38:53.444884", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

Os resultados do módulo Visão Personalizada, enviados como mensagens pelo módulo cameracapture, incluem a probabilidade de a imagem ser de um pinheiro canadense ou de uma cerejeira. Como a imagem é de um pinheiro canadense, a probabilidade exibida é 1,0.

Limpar os recursos

Se você planeja continuar para o próximo artigo recomendado, mantenha os recursos e configurações criados e reutilize-os. Você também pode continuar usando o mesmo dispositivo IoT Edge como um dispositivo de teste.

Caso contrário, exclua as configurações locais e os recursos Azure usados neste artigo para evitar encargos.

Excluir recursos de Azure

Não é possível desfazer a exclusão dos recursos do Azure e grupos de recursos. Não exclua acidentalmente grupo de recursos ou recursos incorretos. Se você criou o IoT Hub dentro de um grupo de recursos existente que tem recursos que deseja manter, exclua apenas o recurso IoT Hub em si, não o grupo de recursos.

Para excluir os recursos:

1. Entre no Azure portal e selecione Resource groups.
2. Selecione o nome do grupo de recursos que contém seus recursos de teste IoT Edge.
3. Examine a lista de recursos que seu grupo de recursos contém. Se você deseja excluir todos eles, selecione Excluir grupo de recursos. Se você quiser excluir apenas alguns deles, selecione cada recurso para excluí-los individualmente.

Próximas etapas

Neste tutorial, você treinou um modelo de Visão Personalizada e o implantou como um módulo em um dispositivo IoT Edge. Em seguida, você criou um módulo que pode consultar o serviço de classificação de imagem e relatar seus resultados para IoT Hub.

Continue com os próximos tutoriais para aprender sobre outras maneiras que o Azure IoT Edge pode ajudá-lo a transformar dados em insights de negócios na extremidade.