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

2025-05-08

Aplica-se a: IoT Edge 1.5

Importante

O IoT Edge 1.5 LTS é a versão com suporte. O IoT Edge 1.4 LTS atingirá o fim da vida útil em 12 de novembro de 2024. Se você estiver em uma versão anterior, confira Atualizar o IoT Edge.

O 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. A Visão Personalizada de IA do Azure 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:

Criar um classificador de imagem com a Visão Personalizada.
Desenvolva um módulo do IoT Edge que consulta o servidor Web da Visão Personalizada no dispositivo.
Envie os resultados do classificador de imagem para o Hub IoT.

Diagrama – Arquitetura do tutorial, classificador de preparação e implantação

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

Pré-requisitos

Dica

Este tutorial é uma versão simplificada do projeto de exemplo Visão Personalizada e Azure IoT Edge em um Raspberry Pi 3. Ele é executado em uma VM de nuvem e usa imagens estáticas para treinar e testar o classificador de imagem, o que ajuda alguém novo na Visão Personalizada no IoT Edge. O projeto de exemplo usa hardware físico e configura um feed de câmera ao vivo para treinar e testar o classificador de imagem, o que é útil para alguém explorar um cenário mais detalhado e da vida real.

Configure seu ambiente para desenvolvimento de contêiner do Linux concluindo o Tutorial: Desenvolver módulos do IoT Edge usando o Visual Studio Code com a ferramenta de desenvolvimento de linha de comando (CLI) preferencial da Ferramenta de Desenvolvimento do Azure IoT Edge . Depois de concluir o tutorial, verifique se os seguintes pré-requisitos estão disponíveis em seu ambiente de desenvolvimento:
- Um Hub IoT gratuito ou de camada padrão no Azure
- Um dispositivo que executa o Azure IoT Edge com contêineres Linux. Use os guias de início rápido para configurar um dispositivo Linux ou dispositivo Windows.
- Um registro de contêiner, como o Registro de Contêiner do Azure.
- O Visual Studio Code foi configurado com a extensão do Hub IoT do Azure .
- 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 do 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:

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

No navegador da Web, navegue até a página da Web da Visão Personalizada.
Selecione Entrar e entre com a mesma conta usada para acessar recursos do Azure.
Selecione Novo projeto.

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 do Azure que inclua um recurso do Serviço de Visão Personalizada ou crie um novo se você 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.)

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.

Clone ou baixe as imagens de exemplo do repositório CustomVision-Windows-cognitivas em seu computador de desenvolvimento local.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Retorne ao projeto da Visão Personalizada e selecione Adicionar imagens.
Navegue até o repositório git que você clonou localmente e navegue até a primeira pasta de imagens, Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Selecione todas as 10 imagens na pasta e selecione Abrir.
Adicione a tag hemlock a esse grupo de imagens e então pressione enter para aplicar a tag.
Selecione Carregar 10 arquivos.
Quando as imagens forem carregadas com êxito, selecione Concluído.
Selecione Adicionar imagens novamente.
Navegue até a segunda pasta de imagens, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Selecione todas as dez imagens na pasta e selecione Abrir.
Adicione a marca japanese cherry a esse grupo de imagens e pressione Enter para aplicar a marca.
Selecione Carregar 10 arquivos. Quando as imagens forem carregadas com êxito, selecione Concluído.
Depois de marcar e carregar os dois conjuntos de imagens, selecione Treinar para treinar o classificador.

Exportar o classificador

Depois de treinar o classificador, selecione Exportar na página Desempenho do classificador.
Selecione DockerFile como a plataforma.
Selecione Linux como a versão.
Selecione Exportar.
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 do 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 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 do IoT Edge. Você também cria um segundo módulo que posta solicitações para o classificador e envia os resultados como mensagens para o Hub IoT.

Criar uma nova solução

Uma solução é uma maneira lógica de desenvolver e organizar vários módulos para uma mesma implantação do 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 do IoT Edge. Crie a solução usando a ferramenta de linha de comando (CLI) do Azure IoT Edge Dev Tool. A maneira mais simples de usar a ferramenta é executar o Contêiner de Desenvolvimento do IoT Edge com o Docker.

Criar um diretório chamado classificador e alterar para o diretório.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Execute o comando init da ferramenta iotedgedev para criar uma nova solução do IoT Edge. No contêiner Docker IoT Edge Dev, 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 do Azure
- Escolher ou criar um grupo de recursos
- Escolher ou criar um Hub IoT do Azure
- Escolher ou criar um dispositivo Azure IoT Edge
O comando cria uma nova solução do IoT Edge com um módulo chamado classificador no diretório de trabalho atual.
Abra a solução no Visual Studio Code.

Adicionar o classificador de imagem

O modelo do módulo Python no Visual Studio Code contém alguns exemplos de código que você pode executar para testar o 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.

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.
No explorador de arquivos, navegue até o diretório onde o Visual Studio Code foi instruído a criar sua solução IoT Edge.
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.
Cole os arquivos na pasta classifier.
Retorne para a janela do Visual Studio Code. O workspace da solução agora deve mostrar os arquivos do classificador de imagem na pasta do módulo.
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.
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.

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
```
Abra o arquivo main.py na pastacameracapture / .

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 do Hub IoT 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" )

Salve o arquivo main.py.
Abra o arquivo requirements.txt.
Adicione uma nova linha para uma biblioteca a ser incluída no contêiner.
```
requests
```
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 está incluída no repositório GitHub que você baixou para as imagens de treinamento neste tutorial.

Navegue até a imagem de teste, localizada em Cognitive-CustomVision-Windows / Samples / Images / Test.
Copie test_image.jpg
Navegue até o diretório da solução do IoT Edge e cole a imagem de teste na pastacameracapture / . A imagem deve estar na mesma pasta do arquivo main.py que você editou na seção anterior.
No Visual Studio Code, abra o arquivo Dockerfile.amd64 para o módulo cameracapture.
Após a linha que estabelece o diretório de trabalho, WORKDIR /app, adicione a seguinte linha de código:
```
ADD ./test_image.jpg .
```
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 do IoT Edge. Em seguida, você criou um segundo módulo que consulta o servidor de classificação de imagem e relata seus resultados para o Hub IoT. Agora, você está pronto para criar o manifesto de implantação que informa a um dispositivo do IoT Edge como iniciar e executar esses dois módulos juntos.

A extensão do 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.

Abra o arquivo deployment.template.json na pasta da solução.
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 do Azure e substitua< AcrUsername> e <AcrPassword> pelo nome de usuário e senha do registro. Você pode encontrar esses valores na seção chaves de acesso do registro de contêiner do Azure no portal Azure.
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.
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.
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.

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\"}]}}}"

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",
```

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\"}]}}}"

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\"]}"
        }
    }
}

Salve o arquivo deployment.template.json.

Compilar sua solução do IoT Edge e efetuar push dela

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 em seu registro, você poderá implantar a solução em um dispositivo do IoT Edge. Você pode definir módulos em um dispositivo por meio do Hub IoT. Nesta seção, você configurará o acesso ao Hub IoT e, em seguida, usará a CLI do Azure para implantar sua solução em seu dispositivo IoT Edge.

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

Abra o terminal integrado do Visual Studio Code selecionando Exibir>Terminal.
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 do Azure. É possível recuperar esses valores na seção Chaves de acesso no registro do 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.

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 do registro local ou de um registro de contêiner 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"

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.

Entre no Docker com as credenciais do Registro de Contêiner do Azure (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.
Entre no Registro de Contêiner do Azure. Você precisa instalar a CLI do Azure 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ê fizer logon em qualquer momento nesse tutorial, repita as etapas acima de entrada do Docker e do Registro de Contêiner do Azure para continuar.

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": {
          "sensorToclassifier": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/classifier/inputs/input1\")",
          "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 Hub IoT do Azure. Por exemplo, para implantar os módulos definidos no arquivo deployment.template.json no Hub IoT <IotHubName> para o dispositivo IoT Edge <DeviceName>, use o comando a seguir. Substitua os valores de nome do hub, id do dispositivo e logon Hub IoT cadeia de conexão por sua própria.

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>"

Dica

Você pode encontrar seu Hub IoT cadeia de conexão, incluindo a chave de acesso compartilhado no portal do Azure. Acesse as >Configurações de segurança>Políticas de acesso compartilhado>iothubowner no Hub IoT.

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. No 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 pelo Hub IoT.

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": ""}

Observação

Inicialmente, você poderá ver erros de conexão na saída do módulo cameracapture devido ao atraso entre a implantação e a inicialização dos módulos.

O módulo cameracapture tenta novamente a conexão automaticamente até que ela seja bem-sucedida. Depois de se conectar com êxito, você verá as mensagens de classificação de imagem esperadas.

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 do Azure usados neste artigo para evitar encargos.

Excluir recursos do Azure

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

Para excluir os recursos:

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

Próximas etapas

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

Continue nos próximos tutoriais para saber mais sobre outras maneiras pelas quais o Azure IoT Edge pode ajudá-lo a transformar dados em insights de negócios na borda.

Armazenar dados na borda com os bancos de dados do SQL Server