Tutorial: Clasificación de imágenes en el perímetro con Custom Vision Service

2025-05-08

Se aplica a: IoT Edge 1.5

Importante

IoT Edge 1.5 LTS es la versión compatible. IoT Edge 1.4 LTS finaliza su ciclo de vida el 12 de noviembre de 2024. Si está usando una versión anterior, consulte Actualización de IoT Edge.

Azure IoT Edge hace que las soluciones de IoT sean más eficaces moviendo las cargas de trabajo de la nube al perímetro. Esta funcionalidad resulta adecuada para servicios que procesan grandes cantidades de datos, como los modelos de Computer Vision. Custom Vision de Azure AI le permite crear clasificadores de imágenes personalizados e implementarlos en dispositivos como contenedores. Juntos, estos dos servicios permiten a los usuarios encontrar información de imágenes o secuencias de vídeo sin transferir primero todos los datos fuera del sitio. Custom Vision proporciona un clasificador que compara imágenes con un modelo entrenado para generar información.

Por ejemplo, Custom Vision en un dispositivo IoT Edge podría determinar si una autopista tiene tráfico mayor o menor que normal, o si un garaje de estacionamiento tiene puntos de estacionamiento disponibles en una fila. Esta información se puede compartir con otro servicio para tomar medidas.

En este tutorial, aprenderá a:

Crear un clasificador de imágenes con Custom Vision.
Desarrolle un módulo de IoT Edge que consulte el servidor web de Custom Vision en el dispositivo.
Envíe los resultados del clasificador de imágenes a IoT Hub.

Diagrama: Tutorial sobre la arquitectura, las fases y la implementación de clasificador

Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

Requisitos previos

Sugerencia

Este tutorial es una versión simplificada del proyecto de ejemplo de Custom Vision y Azure IoT Edge en un Raspberry Pi 3. Se ejecuta en una máquina virtual en la nube y usa imágenes estáticas para entrenar y probar el clasificador de imágenes, lo que ayuda a alguien nuevo a Custom Vision en IoT Edge. El proyecto de ejemplo utiliza hardware físico y configura una transmisión de cámara en directo para entrenar y probar el clasificador de imágenes, lo cual resulta útil para alguien que esté explorando un escenario más detallado y realista.

Configura tu entorno para el desarrollo de contenedores de Linux completando el Tutorial: Desarrollar módulos de IoT Edge usando Visual Studio Code con la herramienta de línea de comandos de desarrollo preferida Azure IoT Edge Dev Tool. Después de completar el tutorial, asegúrese de que los siguientes requisitos previos están disponibles en el entorno de desarrollo:
- Una instancia de IoT Hub gratuita o de nivel estándar en Azure
- Un dispositivo que ejecute Azure IoT Edge con contenedores de Linux. Use los inicios rápidos para configurar un dispositivo Linux o un dispositivo Windows.
- Un registro de contenedor, como Azure Container Registry.
- Visual Studio Code se configura con la extensión de Azure IoT Hub .
- Descargue e instale un sistema de administración de contenedores compatible con Docker en la máquina de desarrollo. Establézcalo para ejecutar contenedores de Linux.
Para desarrollar un módulo de IoT Edge con el servicio Custom Vision, asegúrese de que se instalan los siguientes requisitos previos adicionales en la máquina de desarrollo:

Creación de un clasificador de imágenes con Custom Vision

Para crear un clasificador de imágenes, cree un proyecto de Custom Vision y proporcione imágenes de entrenamiento. Para más información acerca de los pasos que se realizan en esta sección, consulte Cómo crear un clasificador con Custom Vision.

Después de compilar y entrenar el clasificador de imágenes, expórtelo como contenedor de Docker e impleméntelo en un dispositivo IoT Edge.

Creación de un nuevo proyecto

En el explorador web, vaya a la página web de Custom Vision.
Seleccione Sign in (Iniciar sesión) e inicie sesión con la misma cuenta que usa para acceder a los recursos de Azure.
Seleccione New project (Nuevo proyecto).

Cree el proyecto con los valores siguientes:

Campo	Valor
Nombre	Proporcione un nombre para el proyecto, como EdgeTreeClassifier.
Descripción	Descripción opcional del proyecto.
Recurso	Seleccione uno de sus grupos de recursos de Azure que incluye un recurso de Custom Vision Service o cree uno si aún no ha agregado ninguno.
Tipos de proyecto	Clasificación
Classification Types (Tipos de clasificación)	Multiclass (single tag per image) (Multiclase [etiqueta única por imagen])
Dominios	General (compact) (General [compacto])
Funcionalidades de exportación	Plataformas básicas (TensorFlow, CoreML, ONNX, ...)

Seleccione Create project (Crear proyecto).

Carga de imágenes y entrenamiento del clasificador

La creación de un clasificador de imágenes requiere un conjunto de imágenes de entrenamiento e imágenes de prueba.

Puede clonar o descargar imágenes de ejemplo desde el repositorio Cognitive-CustomVision-Windows en el equipo de desarrollo local.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Vuelva al proyecto de Custom Vision y seleccione Add images (Agregar imágenes).
Busque el repositorio de git que ha clonado localmente y vaya a la primera carpeta de imágenes, Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Seleccione las 10 imágenes de la carpeta y, a continuación, seleccione Abrir.
Agregue la etiqueta cicuta a este grupo de imágenes y presione enter para aplicar la etiqueta.
Seleccione Upload 10 files (Cargar 10 archivos).
Cuando las imágenes se hayan cargado correctamente, seleccione Done (Listo).
Seleccione Add images (Agregar imágenes) de nuevo.
Vaya a la segunda carpeta de imágenes, Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Seleccione las 10 imágenes de la carpeta y, a continuación, seleccione Open (Abrir).
Agregue la etiqueta japanese cherry (cerezo japonés) a este grupo de imágenes y presione Entrar para aplicar la etiqueta.
Seleccione Upload 10 files (Cargar 10 archivos). Cuando las imágenes se hayan cargado correctamente, seleccione Done (Listo).
Después de etiquetar y cargar ambos conjuntos de imágenes, seleccione Entrenar para entrenar el clasificador.

Exportación del clasificador

Después de entrenar el clasificador, seleccione Export (Exportar) en la página Performance (Rendimiento) del clasificador.
Seleccione DockerFile para la plataforma.
Seleccione Linux para la versión.
Seleccione Export (Exportar).
Una vez completada la exportación, seleccione Descargar y guarde el paquete de .zip localmente en el equipo. Extraiga todos los archivos del paquete. Use estos archivos para crear un módulo de IoT Edge que contenga el servidor de clasificación de imágenes.

En este punto, ha terminado de crear y entrenar su proyecto de Custom Vision. Los archivos exportados se utilizarán en la sección siguiente, pero ha terminado con la página web de Custom Vision.

Creación de una solución de IoT Edge

Ahora tiene los archivos para una versión en contenedor de su clasificador de imágenes en su equipo de desarrollo. En esta sección, configurará el contenedor clasificador de imágenes para que se ejecute como un módulo de IoT Edge. También se crea un segundo módulo que envía solicitudes al clasificador y envía los resultados como mensajes a IoT Hub.

Creación de una nueva solución

Una solución es una manera lógica de desarrollar y organizar varios módulos para una sola implementación de IoT Edge. Una solución contiene código para uno o varios módulos y el manifiesto de implementación que declara cómo configurarlos en un dispositivo IoT Edge. Cree la solución mediante la herramienta de desarrollo de línea de comandos (CLI) de Azure IoT Edge. La manera más sencilla de usar la herramienta es ejecutar el contenedor de desarrollo de IoT Edge con Docker.

Cree un directorio llamado clasificador y cambie a ese directorio.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Ejecute el comando iotedgedev tool init para crear una nueva solución de IoT Edge. En el contenedor Docker de IoT Edge Dev, escriba el siguiente comando:
```
iotedgedev solution init --template python --module classifier
```
El script iotedgedev solution init le pide que complete varios pasos, entre los que se incluyen:
- Autentíquese en Azure
- Elegir una suscripción de Azure
- Elegir o crear un grupo de recursos
- Elegir o crear una instancia de Azure IoT Hub
- Elegir o crear un dispositivo de Azure IoT Edge
El comando crea una nueva solución de IoT Edge con un módulo denominado clasificador en el directorio de trabajo actual.
Abra la solución en Visual Studio Code.

Adición del clasificador de imágenes

La plantilla del módulo de Python en Visual Studio Code contiene código de ejemplo que se puede ejecutar para probar IoT Edge. No vamos a usar ese código en este escenario. En su lugar, utilice los pasos de esta sección para reemplazar el código de ejemplo por el contenedor del clasificador de imágenes que exportó anteriormente.

En el Explorador de archivos, busque el paquete de Custom Vision que ha descargado y extraído. Copie todo el contenido del paquete extraído. Debería ser dos carpetas, app y azureml y dos archivos, Dockerfile y README.
En el Explorador de archivos, vaya al directorio que indicó a Visual Studio Code para crear la solución de IoT Edge.
Abra la carpeta del módulo clasificador. Si utilizó los nombres sugeridos en la sección anterior, la estructura de carpetas es similar a CustomVisionSolution / modules / classifier.
Pegue los archivos en la carpeta classifier.
Vuelva a la ventana de Visual Studio Code. El área de trabajo de la solución ahora debe mostrar los archivos del clasificador de imágenes en la carpeta del módulo.
Reemplace el archivo Dockerfile.amd64 original por el Dockerfile del paquete custom vision mediante la eliminación del dockerfile.amd64 original y el cambio de nombre de Dockerfile a Dockerfile.amd64.
Guarde los cambios.

Creación de un módulo de cámara simulada

En una implementación real de Custom Vision, una cámara proporciona imágenes en directo o secuencias de vídeo. En este escenario, se simula la cámara mediante la creación de un módulo que envía una imagen de prueba al clasificador de imágenes.

En esta sección, se agrega un nuevo módulo a la misma solución CustomVisionSolution y se proporciona código para crear la cámara simulada.

Use la herramienta iotedgedev para agregar un nuevo módulo a la solución. El comando crea una nueva carpeta denominada cameracapture en la carpeta modules de la solución.
```
iotedgedev solution add --template python cameracapture
```
Abra el archivo main.py en la carpetacameracapture / .

Reemplace todo el archivo por el código siguiente. Este código de ejemplo envía solicitudes POST al servicio de procesamiento de imágenes que se ejecuta en el módulo clasificador. Se proporciona este contenedor de módulo con una imagen de ejemplo para usar en las solicitudes. A continuación, se empaqueta la respuesta como un mensaje de IoT Hub y se envía a una cola de salida.

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

Guarde el archivo main.py.
Abra el archivo requirements.txt .
Agregue una nueva línea para una biblioteca que se va a incluir en el contenedor.
```
requests
```
Guarde el archivo requirements.txt .

Adición de una imagen de prueba al contenedor

En lugar de usar una cámara real para proporcionar fuente de imágenes, en este escenario vamos a usar una única imagen de prueba. En el repositorio de GitHub que descargó anteriormente en este tutorial para las imágenes de entrenamiento se incluye una imagen de prueba.

Vaya a la imagen de prueba, ubicada en Cognitive-CustomVision-Windows / Samples / Images / Test.
Copie test_image.jpg
Vaya al directorio de la solución de IoT Edge y pegue la imagen de prueba en la carpetacameracapture / . La imagen debe estar en la misma carpeta que el archivo main.py que modificó en la sección anterior.
En Visual Studio Code, abra el archivo Dockerfile.amd64 para el módulo cameracapture.
Después de la línea que establece el directorio de trabajo, WORKDIR /app, agregue la siguiente línea de código:
```
ADD ./test_image.jpg .
```
Guarde el archivo Dockerfile.

Preparación de un manifiesto de implementación

Hasta ahora en este tutorial, ha entrenado un modelo de Custom Vision para clasificar imágenes de árboles y empaquetado ese modelo como un módulo de IoT Edge. A continuación, ha creado un segundo módulo que consulta el servidor de clasificación de imágenes e informa de sus resultados a IoT Hub. Ahora, está listo para crear el manifiesto de implementación que indica a un dispositivo IoT Edge cómo iniciar y ejecutar estos dos módulos juntos.

La extensión de IoT Edge para Visual Studio Code proporciona una plantilla en cada solución de IoT Edge para ayudarle a crear un manifiesto de implementación.

Abra el archivo deployment.template.json de la carpeta de la solución.
Establezca las credenciales del Registro para los módulos en el manifiesto de implementación.
```
"registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}
```
Reemplace <registryName> por el nombre del registro de contenedor de Azure y reemplace <AcrUsername> y <AcrPassword> por el nombre de usuario y la contraseña del registro. Puede encontrar estos valores en la sección Claves de acceso del registro de contenedor de Azure en Azure Portal.
Busque la sección módulos, que contiene tres módulos : los dos que creó, clasificador y cameracapture, y un tercero incluido de forma predeterminada, tempSensor.
Elimine el módulo tempSensor con todos sus parámetros. Este módulo proporciona datos de ejemplo para escenarios de prueba, pero no es necesario en esta implementación.
Si ha asignado al módulo del clasificador de imágenes un nombre distinto de classifier, compruebe el nombre ahora y asegúrese de que está todo en minúsculas. El módulo cameracapture llama al módulo classifier mediante una biblioteca de solicitudes que da formato a todas las solicitudes en minúsculas e IoT Edge distingue mayúsculas de minúsculas.

Para cada módulo del sistema edgeAgent y edgeHub, cambie el valor createOptions a una versión con cadena. Por ejemplo:

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

Para cada módulo del sistema edgeAgent y edgeHub, cambie la versión de la imagen a la versión 1.5 más reciente. Por ejemplo:
```
"image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

Actualice el parámetro createOptions del módulo clasificador a una versión con cadena. Por ejemplo:

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

Actualice el parámetro createOptions para el módulo cameracapture con el siguiente json. Esta información crea variables de entorno en el contenedor del módulo que se recuperan en el proceso main.py. Incluir esta información en el manifiesto de implementación le permite cambiar la imagen o el punto de conexión sin volver a generar la imagen del módulo.

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

Si ha asignado al módulo de Custom Vision un nombre distinto de classifier, actualice el valor del punto de conexión de procesamiento de imágenes para que coincida.

Por ejemplo, la configuración de clasificador y cameracapture debe ser similar 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\"]}"
        }
    }
}

Guarde el archivo deployment.template.json.

Compilación e inserción de una solución IoT Edge

Después de crear módulos y configurar la plantilla de manifiesto de implementación, compile las imágenes de contenedor e insértelas en el registro de contenedor.

Una vez que las imágenes se encuentran en el registro, puede implementar la solución en un dispositivo IoT Edge. Puede establecer módulos en un dispositivo a través de IoT Hub. En esta sección, configurará el acceso a IoT Hub y, después, usará la CLI de Azure para implementar la solución en el dispositivo IoT Edge.

En primer lugar, compile e inserte la solución en el registro de contenedor.

Abra el terminal integrado de Visual Studio Code, para lo que debe seleccionar Ver>Terminal.
Inicie sesión en Docker escribiendo el siguiente comando en el terminal mediante el nombre de usuario, la contraseña y el servidor de inicio de sesión desde el registro de contenedor de Azure. Puede recuperar estos valores en la sección Claves de acceso del Registro en Azure Portal.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Podría recibir una advertencia de seguridad en la que se recomiende el uso de --password-stdin. Aunque ese procedimiento se recomienda para escenarios de producción, está fuera del ámbito de este tutorial. Para más información, consulte la referencia de docker login.

Use el Dockerfile del módulo para compilar y etiquetar la imagen de Docker del módulo.

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

Por ejemplo, para compilar la imagen del registro local o un registro de contenedor de Azure, use los siguientes 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"

Imagen de Docker del módulo de inserción

Especifique las credenciales del registro de contenedor a Docker para que pueda insertar la imagen de contenedor para que se almacene en el registro.

Inicie sesión en Docker con las credenciales de Azure Container Registry (ACR).
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Podría recibir una advertencia de seguridad en la que se recomiende el uso de --password-stdin. Aunque ese es un procedimiento recomendado para escenarios de producción, está fuera del ámbito de este tutorial. Para más información, consulte la referencia de docker login.
Inicie sesión en Azure Container Registry. Es necesario Instalar la CLI de Azure para usar el comando az. Este comando solicita el nombre de usuario y la contraseña que se encuentran en el registro de contenedor en Configuración>Claves de acceso.
```
az acr login -n <AcrRegistryName>
```
Sugerencia

Si cierra la sesión en cualquier momento de este tutorial, repita los pasos de inicio de sesión de Docker y Azure Container Registry para continuar.

Inserte la imagen del módulo en el registro local o en un registro de contenedor.

docker push <ImageName>

Por ejemplo:

# 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

Actualizar la plantilla de implementación

Actualice el archivo deployment.template.json con la ubicación de la imagen del registro de contenedor. Cambie el valor de imagen a la imagen que insertó en el registro. Por ejemplo, reemplace <AcrRegistryName> por su nombre de registro en los valores de imagen del clasificador y los módulos 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\"]}"
        }
    }
}

El manifiesto de implementación final es similar al siguiente:

{
  "$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
        }
      }
    }
  }
}

Implementación de módulos en el dispositivo

Compruebe que las imágenes de contenedor compiladas se almacenan en el registro de contenedor. A continuación, impleméntelos en un dispositivo mediante el manifiesto de implementación deployment.template.json preparado para su escenario.

Use el comando IoT Edge Azure CLI set-modules para implementar los módulos en Azure IoT Hub. Por ejemplo, para implementar los módulos definidos en el archivo deployment.template.json en el centro de IoT <IotHubName> para el dispositivo de IoT Edge <DeviceName>, use el siguiente comando. Sustituya los valores de cadena de conexión de loT Hub hub-name, device-id y login por los suyos propios.

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

Sugerencia

Puede encontrar la cadena de conexión de IoT Hub, incluida la clave de acceso compartido, en Azure Portal. Vaya a IoT Hub >Configuración de seguridad>Directivas de acceso compartido>iothubowner.

Asegúrese de que el dispositivo IoT Edge se está ejecutando.

En el dispositivo, expanda Módulos para ver una lista de módulos implementados y en ejecución. Seleccione el botón actualizar. Verá que los nuevos módulos clasificadores y cameracapture se ejecutan junto con $edgeAgent y $edgeHub.

También puede comprobar que todos los módulos están activados y en ejecución en el propio dispositivo. En el dispositivo IoT Edge, ejecute el siguiente comando para ver el estado de los módulos.

iotedge list

Los módulos podrían tardar unos minutos en iniciarse. El entorno de ejecución de Azure IoT Edge necesita recibir su nuevo manifiesto de implementación, extraer las imágenes de los módulos del entorno de ejecución del contenedor y, después, iniciar cada nuevo módulo.

Visualización de los resultados de la clasificación

En el dispositivo, vea los registros del módulo cameracapture para ver los mensajes enviados y confirmar que IoT Hub los recibe.

iotedge logs cameracapture

Por ejemplo, debería ver una salida similar a la siguiente:

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, es posible que vea errores de conexión en la salida del módulo cameracapture debido al retraso entre los módulos que se implementan e inician.

El módulo de captura de cámara intenta reconectar automáticamente hasta que tenga éxito. Después de conectarse correctamente, verá los mensajes de clasificación de imágenes esperados.

Los resultados del módulo Custom Vision, enviados como mensajes del módulo cameracapture, incluyen la probabilidad de que la imagen sea una cicuta o un cerezo. Como la imagen es un abeto, ve que la probabilidad es 1,0.

Limpieza de recursos

Si tiene previsto continuar con el siguiente artículo recomendado, mantenga los recursos y las configuraciones que creó y reutilícelas. También puede seguir usando el mismo dispositivo de IoT Edge como dispositivo de prueba.

De lo contrario, elimine las configuraciones locales y los recursos de Azure que usó en este artículo para evitar cargos.

Eliminación de recursos de Azure

La eliminación de los recursos de Azure y de los grupos de recursos es un proceso irreversible. Asegúrese de no eliminar por accidente el grupo de recursos o los recursos equivocados. Si creó ioT Hub dentro de un grupo de recursos existente que tiene recursos que desea conservar, elimine solo el propio recurso de IoT Hub, no el grupo de recursos.

Para eliminar los recursos:

Inicie sesión en Azure Portal y después seleccione Grupos de recursos.
Seleccione el nombre del grupo de recursos que contiene los recursos de prueba de IoT Edge.
Revise la lista de recursos que contiene el grupo de recursos. Si desea eliminar todos ellos, puede seleccionar Eliminar grupo de recursos. Si desea eliminar solo algunos de ellos, puede seleccionar cada recurso para eliminarlos individualmente.

Pasos siguientes

En este tutorial, ha entrenado un modelo de Custom Vision y lo ha implementado como un módulo en un dispositivo IoT Edge. A continuación, ha creado un módulo que puede consultar el servicio del clasificador de imágenes y notificar sus resultados a IoT Hub.

Puede continuar con los siguientes tutoriales para aprender otras formas en las que Azure IoT Edge puede ayudarle a convertir los datos en información empresarial en el perímetro.

Almacenamiento de datos en el perímetro con bases de datos de SQL Server

Compartir a través de