Partilhar via

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

Aplica-se a:Marca de verificação IoT Edge 1.5 IoT Edge 1.5

Importante

O IoT Edge 1.5 LTS é a versão suportada. O IoT Edge 1.4 LTS está em fim de vida útil a partir de 12 de novembro de 2024. Se você estiver em uma versão anterior, consulte 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 se presta bem a serviços que processam grandes quantidades de dados, como modelos de visão computacional. A Visão Personalizada do Azure AI permite-lhe criar 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, 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 uma garagem tem vagas de estacionamento disponíveis em uma fila. Essas informações podem ser partilhadas com outro serviço, o que possibilita realizar ações.

Neste tutorial, irá aprender a:

  • Compilar um classificador de imagens com a Visão Personalizada.
  • Desenvolva um módulo IoT Edge que consulte o servidor Web Custom Vision no dispositivo.
  • Envie os resultados do classificador de imagens para o Hub IoT.

Diagrama - Tutorial de arquitetura, classificador para estágio e implementação

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

Pré-requisitos

Gorjeta

Este tutorial é uma versão simplificada da Visão Personalizada e do Azure IoT Edge em um projeto de exemplo do Raspberry Pi 3 . Ele é executado em uma VM na nuvem e usa imagens estáticas para treinar e testar o classificador de imagens, 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 da vida real.

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 criar e treinar seu 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 de internet, navegue até a página Visão Personalizada.

  2. Selecione Entrar e entrar com a mesma conta que você usa para acessar os recursos do Azure.

  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 do Azure que inclua um recurso do Serviço de Visão Personalizada ou crie um novo se ainda não tiver adicionado um.
    Tipos de Projetos Classificação
    Tipos de Classificações Multiclasse (etiqueta única por imagem)
    Domínios Geral (compacto)
    Capacidades de exportação Plataformas básicas (TensorFlow, CoreML, ONNX, ...)

  5. Selecione Criar projeto.

Carregar imagens e preparar o classificador

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

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

    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é o repositório git que você clonou localmente e navegue até a primeira pasta de imagem, 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.

    Carregar ficheiros etiquetados com cicuta para o Custom Vision

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

  7. Selecione Adicionar imagens novamente.

  8. Navegue até a 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.

    Exporte seu classificador de imagens treinado

  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 esses arquivos para criar um módulo IoT Edge que contenha o servidor de classificação de imagem.

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 do 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 seção, você configura 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 forma lógica de desenvolver e organizar vários módulos para uma implementação do IoT Edge individual. 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 de desenvolvimento de linha de comando (CLI) da Ferramenta de Desenvolvimento do Azure IoT Edge . A maneira mais simples de usar a ferramenta é executar o IoT Edge Dev Container com o 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 contêiner do IoT Edge Dev Docker, digite 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
    • Escolher uma subscrição 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 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 você 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 para o diretório que instruiu o Visual Studio Code para criar a solução do 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. Regresse à 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 Hub IoT 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. Salve o arquivo 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. Está incluída uma imagem de teste no repositório do GitHub que transferiu para as imagens de preparação no início do tutorial.

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

  2. Copiar test_image.jpg

  3. Navegue até o diretório da solução IoT Edge e cole a imagem de teste na pasta cameracapture dos módulos / . 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 arquivo Dockerfile.amd64 para o módulo cameracapture.

  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, você treinou um modelo de visão personalizado 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 imagens e relata seus resultados para o Hub IoT. 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 o Visual Studio Code disponibiliza um modelo em cada solução do IoT Edge que o ajuda 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 <registryName> pelo nome do seu registro de contêiner do Azure e substitua <AcrUsername> e <AcrPassword> pelo nome de usuário e senha do seu registro. Você pode encontrar esses valores na seção Chaves de acesso do seu registro de contêiner do Azure no portal do 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 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 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. Salve o arquivo deployment.template.json .

Crie e envie 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.

Quando as imagens estiverem no registo, pode implementar a solução num dispositivo IoT Edge. Você pode definir módulos em um dispositivo por meio do Hub IoT. Nesta seção, você configura o acesso ao seu Hub IoT e usa a CLI do Azure para implantar sua solução em seu dispositivo IoT Edge.

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

  1. Abra o terminal integrado do 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 do Azure. Você pode recuperar esses valores na seção Chaves de acesso do seu registro no portal do 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 do docker login.

  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 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. Entre 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 do docker login.

  2. Entre no Registro de Contêiner do Azure. Você precisa instalar a CLI do Azure para usar o az comando. Este comando solicita o seu nome de utilizador e palavra-passe encontrados no registo do contentor em Definições>de chaves de acesso.

    az acr login -n <AcrRegistryName>

    Gorjeta

    Se você sair em qualquer momento deste tutorial, repita as etapas de entrada do Docker e do Registro de Contêiner do Azure 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": {
          "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 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 Hub IoT do Azure. Por exemplo, para implantar os módulos definidos no arquivo deployment.template.json no Hub IoT <DeviceName> para o dispositivo IoT Edge <IotHubName>, use o seguinte comando. Substitua os valores para nome do hub, ID do dispositivo e cadeia de conexão do Hub IoT de login pela sua.

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

Gorjeta

Você pode encontrar sua cadeia de conexão do Hub IoT, incluindo a chave de acesso compartilhada no portal do Azure. Vá para suas configurações>>

Verifique se seu 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ê 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 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 tempo de execução do IoT Edge precisa receber seu novo manifesto de implantação, extrair as imagens do módulo do tempo de execução do contêiner e iniciar cada novo módulo.

Ver os resultados da classificação

No seu dispositivo, visualize 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 a saída como a 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": ""}

Nota

Inicialmente, você pode ver erros de conexão na saída do módulo cameracapture devido ao atraso entre os módulos serem implantados e iniciados.

O módulo de captura de câmera tenta automaticamente a conexão até que seja bem-sucedido. 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 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.

Clean up resources (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 utilizar 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 cobranças.

Eliminar recursos do Azure

A eliminação de recursos e grupos de recursos do Azure é irreversível. Confirme que não elimina acidentalmente o grupo de recursos ou recursos errados. 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 eliminar os recursos:

  1. Entre no portal do Azure e selecione Grupos de recursos.
  2. Selecione o nome do grupo de recursos que contém os recursos de teste do 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 você quiser excluir apenas alguns deles, você pode selecionar cada recurso para excluí-los individualmente.

Próximos passos

Neste tutorial, preparou um modelo de Visão Personalizada e implementou-o como um módulo num dispositivo IoT Edge. Depois, compilou um módulo que pode consultar o servidor de classificação de imagens e comunicar os resultados ao Hub IoT.

Continue para os 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.

Armazene dados na periferia com bases de dados do SQL Server

  • Last updated on