Tutorial: Classificar imagens na periferia com o Serviço de Visão Personalizada

Aplica-se a: IoT Edge 1.5

O Azure IoT Edge torna as soluções IoT mais eficientes ao transferir cargas de trabalho da cloud para a edge. Essa capacidade se presta bem a serviços que processam grandes quantidades de dados, como modelos de visão computacional. Azure AI Custom Vision permite-lhe construir classificadores de imagem personalizados e implementá-los em dispositivos como contentores. Juntos, esses dois serviços permitem que os usuários encontrem informações de imagens ou fluxos de vídeo sem transferir todos os dados para fora do local primeiro. O Custom Vision fornece um classificador que compara imagens com um modelo treinado para gerar insights.

Por exemplo, o Custom Vision num dispositivo IoT Edge pode determinar se uma autoestrada tem mais ou menos tráfego do que o normal, ou se um parque de estacionamento tem lugares de estacionamento disponíveis em fila. Essas informações podem ser partilhadas com outro serviço, o que possibilita realizar ações.

Neste tutorial, irá aprender a:

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

Pré-requisitos

• Configure o seu ambiente para o desenvolvimento de contentores Linux completando Tutorial: Desenvolva módulos de IoT Edge usando Visual Studio Code com a ferramenta de desenvolvimento de linha de comandos (CLI) preferida 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 versão gratuita ou de nível padrão IoT Hub em Azure
  • Dispositivo a executar Azure IoT Edge com contentores Linux. Usa os quickstarts para configurar um dispositivo Linux ou Windows dispositivo.
  • Um registo de contentores, como Azure Container Registry.
  • Visual Studio Code configurado com a extensão Azure IoT Hub.
  • Baixe e instale um sistema de gerenciamento de contêineres compatível com o Docker em sua máquina de desenvolvimento. Configure-o para executar contêineres Linux.

• Para desenvolver um módulo IoT Edge com o serviço Custom Vision, assegure que os seguintes pré-requisitos adicionais estão instalados na sua máquina de desenvolvimento:

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

Compilar um classificador de imagens 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 executadas nesta seção, consulte Como criar um classificador com a Visão Personalizada.

Depois de construir e treinar o seu classificador de imagens, exporte-o como um contentor Docker e implemente-o num dispositivo IoT Edge.

Criar um novo projeto

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

2. Selecione Iniciar sessão e inicie sessão com a mesma conta que usa para aceder aos Azure recursos.

3. Selecione Novo projeto.

4. Crie o projeto com os valores seguintes:

   Campo	Valor
   Nome	Forneça um nome para seu projeto, como EdgeTreeClassifier.
   Descrição	Descrição do projeto opcional.
   Recurso	Selecione um dos seus grupos de recursos Azure que inclua um recurso de Serviço de Visão Personalizado ou criar novo se ainda não adicionou um.
   Tipos de Projetos	Classificação
   Tipos de Classificações	Multiclasse (etiqueta única por imagem)
   Domínios	General (compact) (Geral [compacto])
   Capacidades de exportação	Plataformas básicas (TensorFlow, CoreML, ONNX, ...)

5. Selecione Criar projeto.

Carregar imagens e treinar o seu classificador

Criar um classificador de imagens requer um conjunto de imagens de treinamento e imagens de teste.

1. Clone ou descarregue imagens de exemplo do repositório Cognitive-CustomVision-Windows para a sua máquina local de desenvolvimento.

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

2. Volte ao seu projeto de Visão Personalizada e selecione Adicionar imagens.

3. Navegue até ao repositório git que clonou localmente e navegue até à primeira pasta de imagens, Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Selecione todas as 10 imagens na pasta e, em seguida, selecione Abrir.

4. Adicione a tag cicuta a este grupo de imagens e, em seguida, prima Enter para aplicar a etiqueta.

5. Selecione Carregar 10 arquivos.

   

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

7. Selecione Adicionar imagens novamente.

8. Navegue até à segunda pasta de imagens, Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Selecione todas as 10 imagens na pasta e, em seguida, Abrir.

9. Adicione a tag japanese cherry a este grupo de imagens e pressione enter para aplicar a tag.

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

11. Depois de marcar e carregar ambos os 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 para a plataforma.

3. Selecione Linux para a versão.

4. Selecione Exportar.

5. Após a conclusão da exportação, selecione Baixar e salve o pacote .zip localmente no seu computador. Extraia todos os ficheiros do pacote. Use estes ficheiros para criar um módulo IoT Edge que contenha o servidor de classificação de imagens.

Quando chegar a esta fase, terá concluído a criação e a preparação do projeto de Visão Personalizada. Vai precisar dos ficheiros exportados na próxima secção, mas já não vai utilizar a página Web da Visão Personalizada.

Criar uma solução IoT Edge

Agora você tem os arquivos para uma versão de contêiner do seu classificador de imagem em sua máquina de desenvolvimento. Nesta secção, configura o contentor classificador de imagens para funcionar como um módulo IoT Edge. Também crias um segundo módulo que envia pedidos para o classificador e envia os resultados como mensagens para o IoT Hub.

Criar uma nova solução

Uma solução é uma forma lógica de desenvolver e organizar múltiplos módulos para uma única implementação IoT Edge. Uma solução contém código para um ou mais módulos e o manifesto de implementação que declara como os configurar num dispositivo IoT Edge. Crie a solução usando a ferramenta de desenvolvimento de linha de comandos (CLI) Azure IoT Edge Dev Tool. A forma mais simples de usar a ferramenta é Executar o IoT Edge Dev Container com Docker.

1. Crie um diretório chamado classificador e mude para o diretório.

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Execute o comando iotedgedev tool init para criar uma nova solução IoT Edge. No contentor Docker IoT Edge Dev, introduza o seguinte comando:

   iotedgedev solution init --template python --module classifier
   

   O script init da solução iotedgedev solicita que você conclua várias etapas, incluindo:

   • Autenticar no Azure
   • Escolha uma subscrição do Azure
   • Escolher ou criar um grupo de recursos
   • Escolha ou crie um Azure IoT Hub
   • Escolha ou crie um dispositivo Azure IoT Edge

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

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

Adicionar o classificador de imagens

O modelo de módulo Python no Visual Studio Code contém algum código de exemplo que pode executar para testar o IoT Edge. Esse código não vai ser utilizado neste cenário. Em vez disso, utilize os passos nesta secção para substituir o código de exemplo pelo contentor do classificador de imagens que exportou anteriormente.

1. No explorador de ficheiros, navegue para o pacote da Visão Personalizada que transferiu e extraiu. Copie todos os conteúdos do pacote extraído. Devem ser duas pastas, app e azureml, e dois arquivos, Dockerfile e README.

2. No explorador de ficheiros, navegue até ao diretório onde disse ao Visual Studio Code para criar a sua solução IoT Edge.

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

4. Cole os arquivos na pasta do classificador .

5. Voltar à janela do Visual Studio Code. A área de trabalho da solução deverá agora mostrar os ficheiros do classificador de imagens 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. Guardar as suas alterações.

Criar um módulo de câmara 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, a câmara vai ser simulada mediante a compilação de um módulo que envia uma imagem de teste para o classificador de imagens.

Nesta secção, vai adicionar um módulo novo à mesma CustomVisionSolution e fornecer código para criar a câmara simulada.

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

   iotedgedev solution add --template python cameracapture
   

2. Abra o arquivo main.py na pasta modules / , cameracapture .

3. Substitua todo o ficheiro pelo código abaixo: Este código de exemplo envia pedidos POST para o serviço de processamento de imagens que está a ser executado no módulo do classificador. Este contentor de módulo é fornecido com uma imagem de exemplo que vai ser utilizada nos pedidos. Depois, empacota a resposta como uma mensagem do IoT Hub e envia-a 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. Guarde o ficheiro main.py.

5. Abra o arquivo requirements.txt .

6. Adicione uma linha nova para uma biblioteca, para inclusão no contentor.

   requests
   

7. Salve o arquivo requirements.txt .

Adicionar uma imagem de teste ao contentor

Neste cenário, em vez de utilizarmos uma câmara real para fornecer um feed de imagens, vamos utilizar uma imagem de teste individual. Uma imagem de teste está incluída no repositório GitHub que descarregou para as imagens de treino anteriormente neste tutorial.

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

2. Copiar test_image.jpg

3. Navegue até ao diretório da sua solução IoT Edge e cole a imagem de teste na pasta modules / cameracapture. A imagem deverá estar na mesma pasta que o ficheiro main.py que foi editado na última secção.

4. No Visual Studio Code, abra o ficheiro Dockerfile.amd64 para o módulo de captura da câmara.

5. Adicione a linha de código abaixo a seguir à linha que estabelece o diretório de trabalho, WORKDIR /app:

   ADD ./test_image.jpg .
   

6. Guarde o Dockerfile.

Preparar um manifesto de implementação

Até agora, neste tutorial, treinaste um modelo de visão personalizado para classificar imagens de árvores e empacotaste esse modelo como um módulo IoT Edge. Depois, criaste um segundo módulo que consulta o servidor de classificação de imagens e reporta os seus resultados ao IoT Hub. Agora, está pronto para criar o manifesto de implementação que indica a um dispositivo IoT Edge como iniciar e executar estes dois módulos em conjunto.

A extensão IoT Edge para Visual Studio Code fornece um modelo em cada solução IoT Edge para ajudar a criar um manifesto de implementaçã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 <NomeRegisto> pelo nome do seu registo de contentores de Azure e substitua <NomeUtilizador Acr> e <AcrPassword> pelo nome de utilizador e palavra-passe do seu registo. Pode encontrar estes valores na secção acesso do seu registo de contentores de Azure no portal Azure.

3. Encontre a seção de módulos , que contém três módulos: os dois que você criou, classificador e captura de câmera, 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ê nomeou o módulo de classificação de imagem como algo diferente de classificador, verifique o nome agora e verifique se está tudo em minúsculas. O módulo cameracapture chama o módulo classificador usando uma biblioteca de requisições que formata todas as requisições em minúsculas, e o IoT Edge é sensível a diferenças de capitalização.

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

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

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

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

8. Atualize o parâmetro createOptions do módulo classificador para uma versão convertida em formato 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 seguinte JSON. Esta informação cria variáveis de ambiente no contentor do módulo que são obtidas no processo main.py. A inclusão dessas informações no manifesto de implantação permite alterar a imagem ou o ponto de extremidade sem reconstruir a imagem do módulo.

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

   Se você nomeou seu módulo Visão Personalizada como algo diferente de classificador, atualize o valor do ponto de extremidade de processamento de imagem para corresponder.

   Por exemplo, a configuração do classificador e da captura de câmera 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. Guarde o ficheiro deployment.template.json.

Construa e desenvolva a sua solução IoT Edge

Depois de criar ambos os 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 de as imagens estarem no seu registo, pode implementar a solução num dispositivo IoT Edge. Pode configurar módulos num dispositivo através do IoT Hub. Nesta secção, configura o acesso ao seu IoT Hub e depois usa o Azure CLI para implementar a sua solução no seu dispositivo IoT Edge.

Primeiro, crie e envie a solução para o registro do contêiner.

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

2. Inicie sessão no Docker introduzindo o seguinte comando no terminal usando o nome de utilizador, palavra-passe e servidor de login do registo de contentores do Azure. Pode recuperar estes valores na secção Chaves de Acesso do seu registo no portal Azure.

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

   Poderá receber um aviso de segurança a recomendar a utilização do --password-stdin. Embora essa prática recomendada seja recomendada para cenários de produção, ela está fora do escopo deste tutorial. Para obter mais informações, consulte a referência docker login.

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

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

   Por exemplo, para construir a imagem para o registo local ou para um registo de contentores do 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"
   

Imagem do Docker do módulo Push

Forneça suas credenciais de registro de contêiner ao Docker para que ele possa enviar sua imagem de contêiner para armazenamento no registro.

1. Iniciar sessão no Docker com as credenciais do Azure Container Registry (ACR).

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

   Poderá receber um aviso de segurança a recomendar a utilização do --password-stdin. Embora essa seja uma prática recomendada para cenários de produção, está fora do escopo deste tutorial. Para obter mais informações, consulte a referência docker login.

2. Iniciar sessão no Azure Container Registry. Tens de Install Azure CLI para usar o comando az. Este comando solicita o seu nome de utilizador e palavra-passe encontrados no registo de contentores em Definições>Chaves de acesso.

   az acr login -n <AcrRegistryName>
   

   Gorjeta

   Se, em algum momento deste tutorial, for desconectado, repita os passos de login do Docker e do Azure Container Registry para continuar.

3. Envie a 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 do contêiner. Altere o valor da imagem para a imagem carregada para o registo. Por exemplo, substitua <AcrRegistryName> pelo seu nome de registo nos valores de imagem para os módulos de classificador e cameracapture:

"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 de implantação final é 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 em seu 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 implementar os módulos definidos no ficheiro deployment.template.json para IoT Hub <IotHubName> para o dispositivo IoT Edge <DeviceName>, use o seguinte comando. Substitua os valores de nome-hub, device-id e login IoT Hub connection string pelos 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>"

Certifique-se de que o seu dispositivo IoT Edge está a funcionar.

No dispositivo, expanda Módulos para ver uma lista de módulos implantados e em execução. Selecione o botão Atualizar. Você vê o novo classificador e os módulos de captura de câmera funcionando junto com $edgeAgent e $edgeHub.

Também pode verificar se todos os módulos estão em execução no seu dispositivo. No seu dispositivo IoT Edge, execute o seguinte comando para ver o estado dos módulos.

iotedge list

Pode levar alguns minutos para que os módulos sejam iniciados. O runtime do IoT Edge precisa de receber o seu novo manifesto de implementação, puxar as imagens dos módulos do contentor e depois iniciar cada novo módulo.

Ver os resultados da classificação

No seu dispositivo, veja os registos do módulo de captura da câmara para ver as mensagens enviadas e confirmar que foram recebidas pelo IoT Hub.

iotedge logs cameracapture

Por exemplo, deverá ver uma saída como o exemplo abaixo:

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 do módulo de captura de câmera, incluem a probabilidade de que a imagem seja uma cicuta ou cerejeira. Como a imagem é de cicuta, vê-se a probabilidade como sendo 1,0.

Limpar recursos

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

Caso contrário, elimine as configurações locais e os recursos do Azure que utilizou neste artigo para evitar cobranças.

Eliminar recursos do Azure

Não podes desfazer a eliminação de recursos e grupos de recursos do Azure. Certifique-se de que não elimina acidentalmente o grupo de recursos ou recursos errados. Se criaste o IoT Hub dentro de um grupo de recursos existente que tem recursos que queres manter, elimina apenas o próprio recurso do IoT Hub, não o grupo de recursos.

Para eliminar os recursos:

1. Inicie sessão no portal Azure e depois selecione Resource groups.
2. Selecione o nome do grupo de recursos que contém os seus recursos de teste IoT Edge.
3. Reveja a lista de recursos que o seu grupo de recursos contém. Se quiser excluir todos eles, selecione Excluir grupo de recursos. Se quiseres eliminar apenas alguns, seleciona cada recurso para os eliminar individualmente.

Próximos passos

Neste tutorial, treinaste um modelo Custom Vision e implementaste-o como módulo num dispositivo IoT Edge. Depois criaste um módulo que pode consultar o serviço de classificação de imagens e reportar os seus resultados ao IoT Hub.

Continue para os próximos tutoriais para aprender outras formas como o Azure IoT Edge pode ajudá-lo a transformar dados em insights de negócio na edge.