Tutoriel : Effectuer la classification d'images en périphérie avec le service Vision personnalisée

2025-05-08

S’applique à : IoT Edge 1.5

Important

IoT Edge 1.5 LTS est la version prise en charge. IoT Edge 1.4 LTS est en fin de vie depuis le 12 novembre 2024. Si vous utilisez une version antérieure, consultez l’article Mettre à jour IoT Edge.

Azure IoT Edge rend les solutions IoT plus efficaces en déplaçant les charges de travail du cloud vers la périphérie. Cette fonctionnalité s’avère particulièrement utile pour les services qui traitent de grandes quantités de données, comme les modèles de vision par ordinateur. Azure AI Custom Vision vous permet de créer des classifieurs d’images personnalisés et de les déployer en tant que conteneurs sur des appareils. Ensemble, ces deux services permettent aux utilisateurs de trouver des insights à partir d’images ou de flux vidéo sans transférer d’abord toutes les données hors site. Custom Vision fournit un classifieur qui compare les images à un modèle entraîné pour générer des insights.

Par exemple, Custom Vision sur un appareil IoT Edge peut déterminer si une autoroute a un trafic supérieur ou inférieur à la normale, ou si un parking a des places de stationnement disponibles dans une ligne. Ces insights peuvent être partagés avec un autre service pour entreprendre des actions.

Dans ce tutoriel, vous allez apprendre à :

Créer un classifieur d’images avec Custom Vision.
Développez un module IoT Edge qui interroge le serveur web Custom Vision sur l’appareil.
Envoyez les résultats du classifieur d’image à IoT Hub.

Diagramme - Tutoriel : Structurer, mettre en lots et déployer un classifieur

Si vous ne disposez pas d’un compte Azure, créez-en un gratuitement avant de commencer.

Prérequis

Conseil

Ce tutoriel est une version simplifiée de l’exemple de projet Custom Vision and Azure IoT Edge on a Raspberry Pi 3. Il s’exécute sur une machine virtuelle cloud et utilise des images statiques pour entraîner et tester le classifieur d’images, ce qui aide quelqu’un de nouveau à Custom Vision sur IoT Edge. L’exemple de projet utilise du matériel physique et configure un flux de caméra en direct pour entraîner et tester le classifieur d’image, ce qui est utile pour quelqu’un qui explore un scénario plus détaillé et réel.

Configurez votre environnement pour le développement de conteneurs Linux en suivant le tutoriel : Développer des modules IoT Edge à l’aide de Visual Studio Code avec l’outil de développement en ligne de commande (CLI) Azure IoT Edge préféré. Une fois le tutoriel terminé, vérifiez que les conditions préalables suivantes sont disponibles dans votre environnement de développement :
- IoT Hub de niveau gratuit ou standard dans Azure
- Un appareil exécutant Azure IoT Edge avec des conteneurs Linux. Utilisez les guides de démarrage rapide pour configurer un appareil Linux ou un appareil Windows.
- Un registre de conteneurs, tel qu’Azure Container Registry.
- Visual Studio Code configuré avec l’extension Azure IoT Hub .
- Téléchargez et installez un système de gestion de conteneurs compatible Docker sur votre ordinateur de développement. Configurez-le pour exécuter des conteneurs Linux.
Pour développer un module IoT Edge avec le service Custom Vision, vérifiez que les prérequis supplémentaires suivants sont installés sur votre ordinateur de développement :

Créer un classifieur d’images avec Custom Vision

Pour créer un classifieur d’images, créez un projet Custom Vision et fournissez des images d’apprentissage. Pour plus d’informations sur la procédure à suivre dans cette section, consultez Comment créer un classifieur avec Custom Vision.

Après avoir généré et entraîné votre classifieur d’image, exportez-le en tant que conteneur Docker et déployez-le sur un appareil IoT Edge.

Création d'un projet

Dans votre navigateur Web, accédez à la page web Custom Vision.
Sélectionnez Se connecter et connectez-vous avec le même compte que celui utilisé pour accéder aux ressources Azure.
Sélectionnez Nouveau projet.

Créez votre projet avec les valeurs suivantes :

Champ	Valeur
Nom	Donnez un nom à votre projet, par exemple EdgeTreeClassifier.
Descriptif	Description facultative du projet.
Ressource	Sélectionnez l’un de vos groupes de ressources Azure contenant une ressource de service Custom Vision ou créez-en un si vous n’en avez pas encore ajouté un.
Types de projet	Classification
Classification Types (Types de classification)	Multiclass (single tag per image) (Multiclasse (une balise par image))
Domaines	General (compact) (Général (compact))
Fonctionnalités d’exportation	Plateformes de base (TensorFlow, CoreML, ONNX, etc.)

Sélectionnez Créer un projet.

Charger des images et entraîner votre classifieur

La création d’un classifieur d’images nécessite un ensemble d’images d’entraînement et d’images de test.

Clonez ou téléchargez des exemples d’images à partir du référentiel Cognitive-CustomVision-Windows sur votre machine de développement locale.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Revenez à votre projet Custom Vision et sélectionnez Ajouter des images.
Accédez au référentiel git que vous avez cloné en local et accédez au premier dossier d’images, Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Sélectionnez toutes les 10 images dans le dossier, puis sélectionnez Ouvrir.
Ajoutez la balise hemlock à ce groupe d'images, puis appuyez sur Entrée pour appliquer la balise.
Sélectionnez Upload 10 files (Charger 10 fichiers).
Une fois les images chargées, sélectionnez Terminé.
Sélectionnez une nouvelle fois Ajouter des images.
Accédez au deuxième dossier d’images Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Sélectionnez les 10 images dans le dossier, puis cliquez sur Ouvrir.
Ajoutez la balise japanese cherry à ce groupe d’images, et appuyez sur Entrée pour appliquer la balise.
Sélectionnez Upload 10 files (Charger 10 fichiers). Une fois les images chargées, sélectionnez Terminé.
Après avoir marqué et chargé les deux ensembles d’images, sélectionnez Entraîner pour entraîner le classifieur.

Exporter votre classifieur

Après l’entraînement de votre classifieur, sélectionnez Exporter sur la page Performances du classifieur.
Sélectionnez DockerFile pour la plateforme.
Sélectionnez Linux pour la version.
Sélectionnez Exporter.
Une fois l’exportation terminée, sélectionnez Télécharger et enregistrer le package .zip localement sur votre ordinateur. Extrayez tous les fichiers du package. Utilisez ces fichiers pour créer un module IoT Edge qui contient le serveur de classification d’images.

Une fois cette étape atteinte, vous avez terminé la création et l’entraînement de votre projet Custom Vision. Vous allez utiliser les fichiers exportés dans la section suivante, mais vous en avez terminé avec la page web Custom Vision.

Créer une solution IoT Edge

Vous disposez maintenant des fichiers pour une version conteneur de votre classifieur d’image sur votre ordinateur de développement. Dans cette section, vous allez configurer le conteneur de classifieur d’images pour qu’il s’exécute en tant que module IoT Edge. Vous créez également un deuxième module qui publie des demandes au classifieur et envoie les résultats sous forme de messages à IoT Hub.

Créer une solution

Une solution est une méthode logique de développement et d’organisation de plusieurs modules pour un déploiement IoT Edge unique. Une solution contient le code correspondant à un ou plusieurs modules, ainsi que le manifeste de déploiement qui déclare de quelle façon les configurer sur un appareil IoT Edge. Créez la solution à l’aide de l’outil de développement en ligne de commande Azure IoT Edge Dev Tool (CLI). La façon la plus simple d’utiliser l’outil consiste à exécuter le conteneur de développement IoT Edge avec Docker.

Créez un répertoire nommé classifier et accédez au répertoire.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Exécutez la commande init de l’outil iotedgedev pour créer une solution IoT Edge. Dans le conteneur Docker ioT Edge Dev , entrez la commande suivante :
```
iotedgedev solution init --template python --module classifier
```
Le script init de la solution iotedgedev vous invite à effectuer plusieurs étapes, notamment :
- Authentification auprès d’Azure
- Choisir un abonnement Azure
- Choisir ou créer un groupe de ressources
- Choisir ou créer un hub IoT Azure
- Choisir ou créer un appareil Azure IoT Edge
La commande crée une solution IoT Edge avec un module nommé classifieur dans le répertoire de travail actuel.
Ouvrez la solution dans Visual Studio Code.

Ajouter votre classifieur d’images

Le modèle de module Python dans Visual Studio Code contient des exemples de code que vous pouvez exécuter pour tester IoT Edge. Vous n’allez pas utiliser ce code dans ce scénario. Vous allez plutôt suivre la procédure décrite dans cette section pour remplacer l’exemple de code par le conteneur de classifieur d’images que vous avez exporté précédemment.

Dans votre explorateur de fichiers, accédez au package Custom Vision que vous avez téléchargé et extrait. Copiez tout le contenu du package extrait. Vous devez avoir deux dossiers app et azureml, et deux fichiers Dockerfile et README.
Dans votre explorateur de fichiers, accédez au répertoire où vous avez demandé à ce que Visual Studio Code crée votre solution IoT Edge.
Ouvrez le dossier du module classifier. Si vous avez utilisé les suggestions de noms dans la section précédente, la structure de dossiers ressemble à CustomVisionSolution / modules / classifier.
Collez les fichiers dans le dossierclassifier.
Revenez à la fenêtre Visual Studio Code. L’espace de travail de votre solution doit désormais afficher les fichiers de classifieur d’images dans le dossier du module.
Remplacez le fichier Dockerfile.amd64 d’origine par le fichier Dockerfile à partir du package de vision personnalisée en supprimant le fichier Dockerfile.amd64 d’origine et en renommant Dockerfile.amd64.
Enregistrez vos modifications.

Créer un module de caméra simulée

Dans un déploiement de vision personnalisée réelle, une caméra fournit des images en direct ou des flux vidéo. Pour ce scénario, vous simulez la caméra en créant un module qui envoie une image de test au classifieur d’images.

Dans cette section, vous ajoutez un nouveau module au même dossier CustomVisionSolution et fournissez du code pour créer la caméra simulée.

Utilisez l’outil iotedgedev pour ajouter un nouveau module à la solution. La commande crée un dossier nommé cameracapture dans le dossier modules de votre solution.
```
iotedgedev solution add --template python cameracapture
```
Ouvrez le fichier main.py dans le dossiercameracapture des / .

Remplacez l’intégralité du fichier par le code suivant. Cet exemple de code envoie des requêtes POST au service de traitement d’images s’exécutant dans le module classifier. Nous proposons ce conteneur de modules avec un exemple d’image à utiliser dans les requêtes. Il empaquette ensuite la réponse sous la forme d’un message IoT Hub et l’envoie à une file d’attente de sortie.

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

Enregistrez le fichier main.py.
Ouvrez le fichier requirements.txt.
Ajoutez une nouvelle ligne pour qu’une bibliothèque l’inclue dans le conteneur.
```
requests
```
Enregistrez le fichier requirements.txt .

Ajouter une image de test au conteneur

Au lieu d’utiliser une caméra réelle pour fournir un flux d’images pour ce scénario, nous allons utiliser une seule image de test. Une image de test est incluse dans le référentiel GitHub que vous avez téléchargé pour les images d’entraînement, plus haut dans ce didacticiel.

Accédez à l’image de test, située dans Cognitive-CustomVision-Windows / Samples / Images / Test.
Copiez test_image.jpg
Accédez à votre répertoire de solution IoT Edge et collez l’image de test dans le dossiercameracapture / . L’image doit être dans le même dossier que le fichier main.py que vous avez modifié dans la section précédente.
Dans Visual Studio Code, ouvrez le fichier Dockerfile.amd64 pour le module cameracapture.
Après la ligne qui établit le répertoire de travail, WORKDIR /app, ajoutez la ligne de code suivante :
```
ADD ./test_image.jpg .
```
Enregistrez le fichier Dockerfile.

Préparer un manifeste de déploiement

Jusqu’à présent dans ce tutoriel, vous avez formé un modèle de vision personnalisée pour classifier des images d’arborescences et empaqueter ce modèle en tant que module IoT Edge. Ensuite, vous avez créé un deuxième module qui interroge le serveur de classification d’images et signale ses résultats à IoT Hub. À présent, vous êtes prêt à créer le manifeste de déploiement qui indique à un appareil IoT Edge comment démarrer et exécuter ces deux modules ensemble.

L’extension IoT Edge pour Visual Studio Code fournit un modèle dans chaque solution IoT Edge pour vous aider à créer un manifeste de déploiement.

Ouvrez le fichier deployment.template.json dans le dossier de la solution.
Définissez les informations d’identification du Registre pour les modules dans le manifeste de déploiement.
```
"registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}
```
Remplacez registryName< par le nom de votre registre de conteneurs Azure, puis remplacez><AcrUsername> et <AcrPassword> par le nom d’utilisateur et le mot de passe de votre registre. Vous trouverez ces valeurs dans la section Clés d’accès de votre registre de conteneurs Azure dans le portail Azure.
Recherchez la section modules , qui contient trois modules : les deux que vous avez créés, classifieur et caméracapture, et un troisième inclus par défaut, tempSensor.
Supprimez le module tempSensor avec tous ses paramètres. Ce module fournit des exemples de données pour les scénarios de test, mais il n’est pas nécessaire dans ce déploiement.
Si vous avez nommé le module de classification d’images autrement que classifier, vérifiez le nom maintenant et assurez-vous qu’il est écrit en minuscules. Le module cameracapture appelle le module classifier à l’aide d’une bibliothèque de requêtes qui met en forme toutes les requêtes en minuscules, et IoT Edge respecte la casse.

Pour chaque module système edgeAgent et edgeHub, remplacez la valeur createOptions par une version chaîne. Par exemple:

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

Pour chaque module système edgeAgent et edgeHub, remplacez la version de l’image par la dernière version 1.5. Par exemple:
```
"image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

Mettez à jour le paramètre createOptions pour le module classifieur vers une version stringified. Par exemple:

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

Mettez à jour le paramètre createOptions pour le module cameracapture avec le code JSON suivant. Ces informations créent des variables d’environnement dans le conteneur de modules, qui sont récupérées dans le processus main.py. L’inclusion de ces informations dans le manifeste de déploiement vous permet de modifier l’image ou le point de terminaison sans regénérer l’image de module.

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

Si vous avez nommé votre module Custom Vision autrement que classifier, mettez à jour la valeur de point de terminaison de traitement d’images pour que les valeurs correspondent.

Par exemple, la configuration du classifieur et de la caméracapture doit être similaire à :

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

Enregistrez le fichier deployment.template.json.

Créer et envoyer (push) votre solution IoT Edge

Après avoir créé les deux modules et configuré le modèle de manifeste de déploiement, générez les images conteneur et envoyez-les à votre registre de conteneurs.

Une fois les images dans votre registre, vous pouvez déployer la solution sur un appareil IoT Edge. Vous pouvez définir des modules sur un appareil via IoT Hub. Dans cette section, vous configurez l’accès à votre IoT Hub, puis utilisez Azure CLI pour déployer votre solution sur votre appareil IoT Edge.

Tout d’abord, générez et envoyez (push) la solution au registre de conteneurs.

Ouvrez le terminal intégré Visual Studio Code en sélectionnant Affichage>Terminal.
Connectez-vous à Docker en entrant la commande suivante dans le terminal à l’aide du nom d’utilisateur, du mot de passe et du serveur de connexion à partir du registre de conteneurs Azure. Vous pouvez récupérer ces valeurs dans la section Clés d’accès de votre registre dans le portail Azure.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Il se peut que vous receviez un avertissement de sécurité recommandant d’utiliser --password-stdin. Bien qu’il s’agisse de la bonne pratique recommandée pour les scénarios de production, elle n’est pas pertinente pour ce tutoriel. Pour plus d’informations, consultez les informations de référence sur docker login.

Utilisez le fichier Dockerfile du module pour générer et baliser l’image Docker du module.

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

Par exemple, pour générer l’image pour le registre local ou un registre de conteneurs Azure, utilisez les commandes suivantes :


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

Pousser (push) l’image Docker du module

Fournissez les informations d’identification du registre de conteneurs à Docker afin qu’il puisse envoyer (push) votre image du conteneur à stocker dans le registre.

Connectez-vous à Docker avec les informations d’identification ACR (Azure Container Registry).
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
Il se peut que vous receviez un avertissement de sécurité recommandant d’utiliser --password-stdin. Nous recommandons cette meilleure pratique pour les scénarios de production, mais elle sort de l’étendue de ce tutoriel. Pour plus d’informations, consultez les informations de référence sur docker login.
Connectez-vous à Azure Container Registry. Vous devez installer Azure CLI pour utiliser la az commande. Cette commande demande votre nom d’utilisateur et votre mot de passe trouvés dans votre registre de conteneurs dans lesclés d’accès>.
```
az acr login -n <AcrRegistryName>
```
Conseil

Si vous vous déconnectez à un moment quelconque de ce tutoriel, répétez les étapes de connexion Docker et Azure Container Registry pour continuer.

Poussez votre image de module vers le registre local ou un registre de conteneurs.

docker push <ImageName>

Par exemple:

# 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

Mettre à jour le modèle de déploiement

Mettez à jour le fichier deployment.template.json avec l’emplacement de l’image du registre de conteneurs. Remplacez la valeur de l’image par l’image que vous avez envoyée au Registre. Par exemple, remplacez <AcrRegistryName> par votre nom de Registre dans les valeurs d’image des modules classifieur et 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\"]}"
        }
    }
}

Le manifeste de déploiement final ressemble à ce qui suit :

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

Déployer des modules sur un appareil

Vérifiez que les images conteneur générées sont stockées dans votre registre de conteneurs. Ensuite, déployez-les sur un appareil à l’aide du manifeste de déploiement deployment.template.json préparé pour votre scénario.

Utilisez la commande Azure CLI set-modules IoT Edge pour déployer les modules sur Azure IoT Hub. Par exemple, pour déployer les modules définis dans le fichier deployment.template.json sur IoT Hub <IotHubName pour l’appareil >IoT Edge DeviceName<>, utilisez la commande suivante. Remplacez les valeurs de nom du hub, ID d’appareil et login dans la chaîne de connexion IoT Hub par vos propres valeurs.

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

Conseil

Vous pouvez trouver votre chaîne de connexion IoT Hub, y compris la clé d’accès partagé dans le Portail Azure. Accédez à votre IoT Hub >paramètres de sécurité>Stratégies d’accès partagé>iothubowner.

Vérifiez que votre périphérique IoT Edge est en cours d’exécution.

Développez la section Modules sous votre appareil pour voir la liste des modules déployés et en cours d’exécution. Sélectionnez le bouton actualiser. Vous voyez les nouveaux modules classifieur et caméracapture s’exécutant avec $edgeAgent et $edgeHub.

Vous pouvez également vérifier que tous les modules sont opérationnels sur votre appareil. Sur votre appareil IoT Edge, exécutez la commande suivante pour afficher l’état des modules.

iotedge list

Le démarrage des modules peut prendre quelques minutes. Le runtime IoT Edge doit recevoir son nouveau manifeste de déploiement, extraire les images de module à partir du runtime du conteneur, puis démarrer chaque nouveau module.

Afficher les résultats de la classification

Sur votre périphérique, affichez les journaux du module cameracapture pour voir les messages envoyés et confirmer qu’ils sont reçus parIoT Hub.

iotedge logs cameracapture

Par exemple, un résultat similaire à ce qui suit s’affiche :

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

Notes

Au départ, vous pouvez voir des erreurs de connexion dans la sortie du module cameracapture en raison du délai entre les modules déployés et le démarrage.

Le module cameracapture réattempte automatiquement la connexion jusqu’à ce qu’elle réussisse. Une fois la connexion établie, vous voyez les messages de classification d’images attendus.

Les résultats du module Custom Vision, envoyés sous forme de messages par le module de capture d'images, incluent la probabilité que l'image représente un ciguë ou un cerisier. Étant donné que l’image est hemlock, vous voyez la probabilité sous la forme 1.0.

Nettoyer les ressources

Si vous envisagez de passer à l’article recommandé suivant, conservez les ressources et les configurations que vous avez créées et réutilisées. Vous pouvez également continuer à utiliser le même appareil IoT Edge comme appareil de test.

Sinon, supprimez les configurations locales et les ressources Azure que vous avez utilisées dans cet article pour éviter les frais.

Supprimer les ressources Azure

La suppression des ressources et des groupes de ressources Azure est irréversible. Veillez à ne pas supprimer accidentellement les mauvaises ressources ou le mauvais groupe de ressources. Si vous avez créé le hub IoT à l’intérieur d’un groupe de ressources existant qui a des ressources que vous souhaitez conserver, supprimez uniquement la ressource IoT Hub elle-même, et non le groupe de ressources.

Pour supprimer les ressources :

Connectez-vous au Portail Azure, puis sélectionnez Groupes de ressources.
Sélectionnez le nom du groupe de ressources contenant vos ressources de test de IoT Edge.
Passez en revue la liste des ressources contenues dans votre groupe de ressources. Si vous souhaitez toutes les supprimer, vous pouvez sélectionner Supprimer le groupe de ressources. Si vous souhaitez en supprimer seulement quelques-unes, vous pouvez sélectionner chaque ressource pour la supprimer individuellement.

Étapes suivantes

Dans ce didacticiel, vous avez entraîné un modèle Custom Vision et l’avez déployé en tant que module sur un appareil IoT Edge. Vous avez ensuite créé un module qui peut interroger le service de classification d’images et renvoyer ses résultats à IoT Hub.

Passez aux tutoriels suivants pour en savoir plus sur les autres façons dont Azure IoT Edge peut vous aider à transformer des données en informations métier « at the edge » (« en périphérie »).

Stocker des données en périphérie avec les bases de données SQL Server

Partager via