Tutorial: Durchführen von Bildklassifizierungen im Edge-Bereich mit dem Custom Vision Service

Artikel
04/11/2024

Gilt für: IoT Edge 1.4

Wichtig

IoT Edge Version 1.4 wird unterstützt. Wenn Sie ein früheres Release verwenden, finden Sie weitere Informationen unter Aktualisieren von IoT Edge.

Azure IoT Edge kann Workloads aus der Cloud an den Edge-Bereich verlagern und so die Effizienz Ihrer IoT-Lösung steigern. Diese Funktion eignet sich besonders für Dienste, die große Datenmengen verarbeiten, beispielsweise Modelle für maschinelles Sehen. Mit Azure KI Custom Vision können Sie benutzerdefinierte Bildklassifizierungen erstellen und auf Geräten als Container bereitstellen. Die Kombination dieser beiden Dienste ermöglicht es Ihnen, Erkenntnisse aus Bildern oder Videostreams zu gewinnen, ohne zuvor sämtliche Daten an einen externen Ort zu übertragen. Custom Vision bietet eine Klassifizierung, die ein Bild mit einem trainierten Modell vergleicht, um Erkenntnisse zu generieren.

So kann mit Custom Vision auf einem IoT Edge-Gerät beispielsweise ermittelt werden, ob das Verkehrsaufkommen auf einer Autobahn höher ist als normal oder ob in einem Parkhaus noch Parkplätze in einer Reihe frei sind. Diese Erkenntnisse können an einen anderen Dienst weitergegeben werden, um Aktionen auszuführen.

In diesem Tutorial lernen Sie Folgendes:

Erstellen einer Bildklassifizierung mit Custom Vision
Entwickeln eines IoT Edge-Moduls, das den Custom Vision-Webserver auf Ihrem Gerät abfragt
Senden der Ergebnisse der Bildklassifizierung an IoT Hub

Diagram - Tutorial architecture, stage and deploy classifier

Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein kostenloses Azure-Konto, bevor Sie beginnen.

Voraussetzungen

Tipp

Bei diesem Tutorial handelt es sich um eine vereinfachte Version des Beispielprojekts Custom Vision + Azure IoT Edge on a Raspberry Pi 3 (Custom Vision und Azure IoT Edge auf einem Raspberry Pi 3). Das Tutorial wurde für die Ausführung auf einem virtuellen Cloudcomputer konzipiert und verwendet statische Bilder zum Trainieren und Testen der Bildklassifizierung. Dies ist hilfreich für Benutzer, die ihre ersten Erfahrungen mit Custom Vision in IoT Edge sammeln. Das Beispielprojekt verwendet physische Hardware und richtet einen Livekamerafeed zum Trainieren und Testen der Bildklassifizierung ein. Dies ist hilfreich für Benutzer, die sich an einem detaillierteren, praxisnahen Szenario versuchen möchten.

Konfigurieren Sie Ihre Umgebung für die Linux-Containerentwicklung mithilfe des Tutorial: Entwickeln von IoT Edge Modulen mithilfe von Visual Studio Code. Nach Abschluss des Tutorials sollten die folgenden Voraussetzungen in Ihrer Entwicklungsumgebung verfügbar sein:
- Eine IoT Hub-Instanz in Azure im Tarif „Free“ oder „Standard“.
- Ein Gerät, auf dem Azure IoT Edge mit Linux-Containern läuft. Mithilfe der Schnellstarts können Sie ein Linux-Gerät oder ein Windows-Gerät einrichten.
- Eine Containerregistrierung wie Azure Container Registry.
- Visual Studio Code, der mit den Azure IoT Edge- und Azure IoT Hub-Erweiterungen konfiguriert wurde. Die Erweiterung Azure IoT Edge-Tools für Visual Studio Code befindet sich im Wartungsmodus.
- Laden Sie ein Docker-kompatibles Containerverwaltungssystem auf Ihrem Entwicklungscomputer herunter, und installieren Sie es. Konfigurieren Sie es für die Ausführung von Linux-Containern.
Um ein IoT Edge-Modul mit dem Custom Vision-Dienst zu entwickeln, installieren Sie die folgenden zusätzlichen Voraussetzungen auf Ihrem Entwicklungscomputer:

Erstellen einer Bildklassifizierung mit Custom Vision

Um eine Bildklassifizierung zu erstellen, müssen Sie ein Custom Vision-Projekt erstellen und Trainingsbilder bereitstellen. Weitere Informationen zu den Schritten in diesem Abschnitt finden Sie unter Erstellen einer Klassifizierung mit Custom Vision.

Nachdem Sie Ihre Bildklassifizierung erstellt und trainiert haben, können Sie sie als Docker-Container exportieren und auf einem IoT Edge-Gerät bereitstellen.

Erstellen eines neuen Projekts

Navigieren Sie im Webbrowser zur Custom Vision-Webseite.
Wählen Sie Anmelden aus, und melden Sie sich mit dem Konto an, mit dem Sie auch auf Azure-Ressourcen zugreifen.
Wählen Sie Neues Projekt aus.

Erstellen Sie Ihr Projekt mit den folgenden Werten:

Feld	Wert
Name	Geben Sie einen Namen für Ihr Projekt an (beispielsweise EdgeTreeClassifier).
BESCHREIBUNG	Eine optionale Projektbeschreibung.
Resource	Wählen Sie eine Ihrer Azure-Ressourcengruppen aus, die eine Custom Vision-Dienstressource enthält, oder erstellen Sie eine neue, wenn Sie noch keine hinzugefügt haben.
Projekttypen	Klassifizierung
Klassifizierungstypen	Multiclass (single tag per image) (Multiklasse (einzelnes Tag pro Bild))
Domänen	General (compact) (Allgemein (kompakt))
Exportieren von Funktionen	Basisplattformen (Tensorflow, CoreML, ONNX...)

Wählen Sie Projekt erstellen aus.

Hochladen von Bildern und Trainieren Ihrer Klassifizierung

Zum Erstellen einer Bildklassifizierung ist eine Gruppe von Trainingsbildern und Testbildern erforderlich.

Klonen Sie Beispielbilder aus dem Repository Cognitive-CustomVision-Windows auf Ihrem lokalen Entwicklungscomputer, oder laden Sie sie herunter.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Kehren Sie zu Ihrem Custom Vision-Projekt zurück, und wählen Sie Bilder hinzufügen aus.
Navigieren Sie in dem lokal geklonten Git-Repository zum ersten Bildordner: Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Wählen Sie in dem Ordner alle zehn Bilder und anschließend Öffnen aus.
Fügen Sie dieser Gruppe von Bildern das Tag hemlock hinzu, und drücken Sie dieEINGABETASTE, um das Tag anzuwenden.
Wählen Sie 10 Dateien hochladen aus.
Klicken Sie nach dem erfolgreichen Hochladen der Bilder auf Fertig.
Wählen Sie erneut Bilder hinzufügen aus.
Navigieren Sie zum zweiten Bildordner: Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Wählen Sie in dem Ordner alle zehn Bilder und anschließend Öffnen aus.
Fügen Sie dieser Gruppe von Bildern das Tag japanese cherry hinzu, und drücken Sie dieEINGABETASTE, um das Tag anzuwenden.
Wählen Sie 10 Dateien hochladen aus. Klicken Sie nach dem erfolgreichen Hochladen der Bilder auf Fertig.
Wenn beide Gruppen von Bildern mit Tags versehen und hochgeladen wurden, wählen Sie Trainieren aus, um die Klassifizierung zu trainieren.

Exportieren Ihrer Klassifizierung

Wählen Sie nach dem Trainieren Ihrer Klassifizierung auf der Leistungsseite der Klassifizierung die Option Exportieren aus.
Wählen Sie für die Plattform die Option DockerFile aus.
Wählen Sie für die Version die Option Linux aus.
Wählen Sie Exportieren aus.
Wählen Sie nach Abschluss des Exportvorgangs Herunterladen aus, und speichern Sie das ZIP-Paket lokal auf Ihrem Computer. Extrahieren Sie alle Dateien aus dem Paket. Sie verwenden diese Dateien zum Erstellen eines IoT Edge-Moduls, das den Bildklassifizierungsserver enthält.

Sie haben Ihr Custom Vision-Projekt nun erstellt und trainiert. Die exportierten Dateien werden im nächsten Abschnitt verwendet. Die Arbeit an der Custom Vision-Webseite ist jedoch abgeschlossen.

Erstellen einer IoT Edge-Projektmappe

Die Dateien für eine Containerversion Ihrer Bildklassifizierung befinden sich nun auf Ihrem Entwicklungscomputer. In diesem Abschnitt konfigurieren Sie den Bildklassifizierungscontainer für die Ausführung als IoT Edge-Modul. Darüber hinaus erstellen Sie ein zweites Modul, das zusammen mit der Bildklassifizierung bereitgestellt wird. Das zweite Modul richtet Anforderungen an die Klassifizierung und sendet die Ergebnisse als Nachrichten an IoT Hub.

Erstellen einer neuen Lösung

Eine Projektmappe ist eine logische Methode, um mehrerer Module für eine einzelne IoT Edge-Bereitstellung zu entwickeln und zu strukturieren. Eine Lösung enthält Code für ein oder mehrere Module und das Bereitstellungsmanifest, das die Konfiguration der Module auf einem IoT Edgegerät deklariert.

Klicken Sie in Visual Studio Code auf Ansicht>Befehlspalette, um die Visual Studio Code-Befehlspalette zu öffnen.

Geben Sie in der Befehlspalette den folgenden Befehl ein, und führen Sie ihn aus: Azure IoT Edge: New IoT Edge Solution (Azure IoT Edge: Neue IoT Edge-Projektmappe) ein, und führen Sie ihn aus. Geben Sie in der Befehlspalette die folgenden Informationen an, um die Projektmappe zu erstellen:

Feld	Wert
Ordner auswählen	Wählen Sie den Speicherort auf Ihrem Entwicklungscomputer aus, an dem Visual Studio Code die Projektmappendateien erstellen soll.
Provide a solution name (Projektmappennamen angeben)	Geben Sie für Ihre Projektmappe einen aussagekräftigen Namen ein (beispielsweise CustomVisionSolution), oder übernehmen Sie den Standardnamen.
Select module template (Modulvorlage auswählen)	Wählen Sie Python-Modul aus.
Provide a module name (Modulname angeben)	Nennen Sie das Modul classifier. Wichtig: Der Name dieses Moduls muss in Kleinbuchstaben angegeben werden. Bei Modulverweisen von IoT Edge wird die Groß-/Kleinschreibung berücksichtigt, und in dieser Projektmappe wird eine Bibliothek verwendet, die alle Anforderungen in Kleinbuchstaben formatiert.
Provide Docker image repository for the module (Docker-Imagerepository für das Modul angeben)	Ein Imagerepository enthält den Namen Ihrer Containerregistrierung und den Namen Ihres Containerimages. Ihr Containerimage wird aus dem vorherigen Schritt übernommen. Ersetzen Sie localhost:5000 durch den Wert für Anmeldeserver aus Ihrer Azure-Containerregistrierung. Den Anmeldeserver können Sie im Azure-Portal auf der Übersichtsseite Ihrer Containerregistrierung ermitteln. Die endgültige Zeichenfolge sieht wie folgt aus: <Registrierungsname>.azurecr.io/classifier.

Provide Docker image repository

Das Visual Studio Code-Fenster lädt den Arbeitsbereich für Ihre IoT Edge-Projektmappe.

Hinzufügen von Registrierungsanmeldeinformationen

Die Umgebungsdatei speichert die Anmeldeinformationen für Ihre Containerregistrierung und gibt sie an die IoT Edge-Runtime weiter. Die Runtime benötigt diese Anmeldeinformationen, um Ihre privaten Images per Pull auf das IoT Edge-Gerät zu übertragen.

Die IoT Edge-Erweiterung versucht, Ihre Anmeldeinformationen für die Containerregistrierung aus Azure zu pullen und in die Umgebungsdatei einzufügen. Überprüfen Sie, ob Ihre Anmeldeinformationen bereits enthalten sind. Fügen Sie sie jetzt hinzu, wenn dies nicht der Fall ist:

Öffnen Sie die ENV-Datei im Visual Studio Code-Explorer.
Aktualisieren Sie die Felder mit den Werten für Benutzername und Kennwort, die Sie aus der Azure-Containerregistrierung kopiert haben.
Speichern Sie diese Datei.

Hinweis

In diesem Tutorial werden die Administratoranmeldeinformationen für die Azure Container Registry verwendet, die für Entwicklungs- und Testszenarien geeignet sind. Wenn Sie für die Produktionsszenarien bereit sind, empfehlen wir Ihnen, eine Authentifizierungsoption mit den geringstmöglichen Rechten, z. B. Dienstprinzipale, auszuwählen. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf die Containerregistrierung.

Auswählen Ihrer Zielarchitektur

Mit Visual Studio Code können derzeit Module für Linux AMD64- und Linux ARM32v7-Geräte entwickelt werden. Sie müssen bei jeder Projektmappe auswählen, welche Architektur Sie als Ziel verwenden möchten, weil der Container für jeden Architekturtyp unterschiedlich erstellt und ausgeführt wird. In diesem Tutorial wird die Standardoption „Linux AMD64“ verwendet.

Öffnen Sie die Befehlspalette, und suchen Sie nach Azure IoT Edge: Set Default Target Platform for Edge Solution (Standardzielplattform für Edge-Projektmappe festlegen), oder wählen Sie das Verknüpfungssymbol in der Seitenleiste unten im Fenster aus.
Wählen Sie in der Befehlspalette die Zielarchitektur aus der Liste mit Optionen aus. Weil in diesem Tutorial eine Ubuntu-VM als IoT Edgegerät verwendet wird, behalten Sie den Standardwert amd64 bei.

Hinzufügen Ihrer Bildklassifizierung

Die Python-Modulvorlage in Visual Studio Code enthält Beispielcode, den Sie zum Testen von IoT Edge ausführen können. Dieser Code wird allerdings in diesem Szenario nicht verwendet. Gehen Sie stattdessen wie in diesem Abschnitt beschrieben vor, um den Beispielcode durch den Bildklassifizierungscontainer zu ersetzen, den Sie zuvor exportiert haben.

Navigieren Sie in Ihrem Datei-Explorer zu dem Custom Vision-Paket, das Sie heruntergeladen und extrahiert haben. Kopieren Sie den gesamten Inhalt aus dem extrahierten Paket. Dieser sollte zwei Ordner (app und azureml) sowie zwei Dateien (Dockerfile und README) umfassen.
Navigieren Sie in Ihrem Datei-Explorer zu dem Verzeichnis, das Sie Visual Studio Code gegenüber als Zielverzeichnis für die Erstellung Ihrer IoT Edge-Projektmappe angegeben haben.
Öffnen Sie den Ordner des Klassifizierungsmoduls. Sofern Sie im vorherigen Abschnitt die vorgeschlagenen Namen verwendet haben, sieht die Ordnerstruktur wie folgt aus: CustomVisionSolution/modules/classifier.
Fügen Sie die Dateien in den Ordner classifier ein.
Wechseln Sie wieder zum Visual Studio Code-Fenster. Im Arbeitsbereich Ihrer Projektmappe sollten nun im Modulordner die Bildklassifizierungsdateien angezeigt werden.
Öffnen Sie im Ordner „classifier“ die Datei module.json.
Aktualisieren Sie den Parameter platform so, dass er auf das hinzugefügte neue Dockerfile verweist, und entfernen Sie alle Optionen bis auf „AMD64“, da in diesem Tutorial nur diese Architektur verwendet wird.
```
"platforms": {
    "amd64": "./Dockerfile"
}
```
Speichern Sie die Änderungen.

Erstellen eines simulierten Kameramoduls

Bei einer echten Custom Vision-Bereitstellung wäre eine Kamera vorhanden, die Livebilder oder Videostreams bereitstellt. In diesem Szenario simulieren Sie die Kamera, indem Sie ein Modul erstellen, das ein Testbild an die Bildklassifizierung sendet.

Hinzufügen und Konfigurieren eines neuen Moduls

In diesem Abschnitt fügen Sie der gleichen Custom Vision-Projektmappe (CustomVisionSolution) ein neues Modul hinzu und stellen Code bereit, um die simulierte Kamera zu erstellen.

Führen Sie im gleichen Visual Studio Code-Fenster über die Befehlspalette den Befehl Azure IoT Edge: Add IoT Edge Module (Azure IoT Edge: IoT Edge-Modul hinzufügen) aus. Geben Sie in der Befehlspalette die folgenden Informationen für Ihr neues Modul an:

Prompt	Wert
Select deployment template file (Bereitstellungsvorlagendatei auswählen)	Wählen Sie die Datei deployment.template.json aus dem Ordner „CustomVisionSolution“ aus.
Select module template (Modulvorlage auswählen)	Wählen Sie Python-Modul aus.
Provide a module name (Modulname angeben)	Nennen Sie Ihr Modul cameraCapture.
Provide Docker image repository for the module (Docker-Imagerepository für das Modul angeben)	Ersetzen Sie localhost:5000 durch den Wert von Anmeldeserver für Ihre Azure-Containerregistrierung. Die endgültige Zeichenfolge sieht wie folgt aus: <Registrierungsname>.azurecr.io/cameracapture.

Das Visual Studio Code-Fenster lädt Ihr neues Modul in den Arbeitsbereich der Lösung und aktualisiert die Datei „deployment.template.json“. Nun sollten zwei Modulordner angezeigt werden: „classifier“ und „cameraCapture“.

Öffnen Sie die Datei main.py im Ordner modules / cameraCapture.

Ersetzen Sie die gesamte Datei durch den folgenden Code. Dieser Beispielcode sendet POST-Anforderungen an den im Klassifizierungsmodul ausgeführten Bildverarbeitungsdienst. Für diesen Modulcontainer stellen wir ein Beispielbild bereit, das in den Anforderungen verwendet werden kann. Anschließend wird die Antwort als IoT Hub-Nachricht verpackt und an eine Ausgabewarteschlange gesendet.

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

Speichern Sie die Datei main.py.
Öffnen Sie die Datei requirements.txt.
Fügen Sie eine neue Zeile für eine Bibliothek hinzu, die in den Container aufgenommen werden soll.
```
requests
```
Speichern Sie die Datei requirements.txt .

Hinzufügen eines Testbilds zu dem Container

Wir verwenden in diesem Szenario keinen Bildfeed von einer echten Kamera, sondern ein einzelnes Testbild. Ein Testbild ist in dem GitHub-Repository enthalten, das Sie weiter oben in diesem Tutorial für die Trainingsbilder heruntergeladen haben.

Navigieren Sie zu dem Testbild. Es befindet sich unter Cognitive-CustomVision-Windows / Samples / Images / Test.
Kopieren Sie test_image.jpg.
Navigieren Sie zum Verzeichnis Ihrer IoT Edge-Projektmappe, und fügen Sie das Testbild in den Ordner modules / cameraCapture ein. Das Bild muss sich im gleichen Ordner befinden wie die Datei „main.py“, die Sie im vorherigen Abschnitt bearbeitet haben.
Öffnen Sie in Visual Studio Code die Datei Dockerfile.amd64 für das cameraCapture-Modul.
Fügen Sie nach der Zeile, die das Arbeitsverzeichnis (WORKDIR /app) festlegt, die folgende Codezeile hinzu:
```
ADD ./test_image.jpg .
```
Speichern Sie das Dockerfile.

Vorbereiten eines Bereitstellungsmanifests

Sie haben in diesem Tutorial ein Custom Vision-Modell trainiert, um Bilder von Bäumen zu klassifizieren, und dieses Modell als IoT Edge-Modul verpackt. Anschließend haben Sie ein zweites Modul erstellt, das den Bildklassifizierungsserver abfragen und die Ergebnisse an IoT Hub zurückgeben kann. Als Nächstes können Sie das Bereitstellungsmanifest erstellen, das gegenüber einem IoT Edge-Gerät angibt, wie diese beiden Module gestartet und gemeinsam ausgeführt werden.

Die IoT Edge-Erweiterung für Visual Studio Code stellt in jeder IoT Edge-Projektmappe eine Vorlage bereit, die Sie beim Erstellen eines Bereitstellungsmanifests unterstützt.

Öffnen Sie die Datei deployment.template.json aus dem Projektmappenordner.
Navigieren Sie zum Abschnitt modules. Er sollte drei Module enthalten: die beiden, die Sie erstellt haben (also „classifier“ und „cameraCapture“), und ein drittes (SimulatedTemperatureSensor), das standardmäßig vorhanden ist.
Löschen Sie das Modul SimulatedTemperatureSensor zusammen mit allen dazugehörigen Parametern. Dieses Modul dient zur Bereitstellung von Beispieldaten für Testszenarien und wird in dieser Bereitstellung nicht benötigt.
Sollten Sie das Bildklassifizierungsmodul nicht classifier genannt haben, überprüfen Sie nun den Namen, und vergewissern Sie sich, dass er vollständig in Kleinbuchstaben angegeben ist. Das Modul „cameraCapture“ ruft das Modul „classifier“ unter Verwendung einer Anforderungsbibliothek auf, die alle Anforderungen in Kleinbuchstaben formatiert, und von IoT Edge wird die Groß-/Kleinschreibung berücksichtigt.
Aktualisieren Sie den Parameter createOptions für das Modul „cameraCapture“ mit dem folgenden JSON-Code. Diese Informationen erstellen Umgebungsvariablen im Modulcontainer, die im Prozess „main.py“ abgerufen werden. Durch Einbeziehung dieser Informationen in das Bereitstellungsmanifest können Sie das Image oder den Endpunkt ändern, ohne das Modulimage neu zu erstellen.
```
"createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
```
Falls Sie Ihr Custom Vision-Modul nicht classifier genannt haben, aktualisieren Sie den Wert des Bildverarbeitungsendpunkts entsprechend.
Aktualisieren Sie am Ende der Datei den Parameter routes für das Modul „$edgeHub“. Die Vorhersageergebnisse sollen von „cameraCapture“ an IoT Hub weitergeleitet werden.
```
    "routes": {
      "cameraCaptureToIoTHub": "FROM /messages/modules/cameraCapture/outputs/* INTO $upstream"
    },
```
Falls Sie Ihr zweites Modul nicht cameraCapture genannt haben, aktualisieren Sie den Routenwert entsprechend.
Speichern Sie die Datei deployment.template.json.

Erstellen und Pushen Ihrer IoT Edge-Projektmappe

Nachdem Sie die beiden Module erstellt und die Bereitstellungsmanifestvorlage konfiguriert haben, können Sie die Containerimages erstellen und an Ihre Containerregistrierung pushen.

Sobald sich die Images in Ihrer Registrierung befinden, können Sie die Projektmappe auf einem IoT Edge-Gerät bereitstellen. Sie können über IoT Hub Module auf einem Gerät festlegen, können jedoch auch über Visual Studio Code auf IoT Hub und Geräte zugreifen. In diesem Abschnitt richten Sie den Zugriff auf Ihre IoT Hub-Instanz ein und stellen dann mithilfe von Visual Studio Code Ihre Projektmappe auf dem IoT Edge-Gerät bereit.

Erstellen Sie zunächst Ihre Projektmappe, und pushen Sie sie an Ihre Containerregistrierung.

Öffnen Sie das in Visual Studio Code integrierte Terminal, indem Sie Ansicht>Terminal wählen.
Melden Sie sich bei Docker an. Geben Sie dazu den nachstehenden Befehl im Terminal ein. Melden Sie sich mit dem Benutzernamen, Kennwort und Anmeldeserver aus Ihrer Azure-Containerregistrierung an. Diese Werte finden Sie im Azure-Portal im Abschnitt Zugriffsschlüssel Ihrer Registrierung.
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Möglicherweise wird Ihnen in einem Sicherheitshinweis die Verwendung von --password-stdin empfohlen. Diese bewährte Methode wird für Produktionsszenarien empfohlen, aber sie ist nicht Gegenstand dieses Tutorials. Weitere Informationen finden Sie in der docker login-Referenz.
Klicken Sie im Visual Studio Code-Explorer mit der rechten Maustaste auf die Datei deployment.template.json, und klicken Sie anschließend auf Build and Push IoT Edge solution (IoT Edge-Projektmappe erstellen und übertragen).

Der Befehl zum Erstellen und Übertragen per Push startet drei Vorgänge. Zuerst erstellt er in der Projektmappe einen neuen Ordner mit dem Namen config. Darin ist das vollständige Bereitstellungsmanifest gespeichert, das aus Informationen in der Bereitstellungsvorlage und anderen Projektmappendateien erstellt wurde. Danach führt er docker build zum Erstellen des Containerimages aus, das auf der entsprechenden Dockerfile-Datei für Ihre Zielarchitektur basiert. Und schließlich führt er docker push aus, um das Imagerepository per Push in Ihre Containerregistrierung zu übertragen.

Dieser Vorgang kann beim ersten Mal einige Minuten dauern, aber er ist bei der nächsten Ausführung von Befehlen schon schneller.

Bereitstellen von Modulen auf dem Gerät

Verwenden Sie den Visual Studio Code-Explorer und die Azure IoT Edge-Erweiterung, um das Modulprojekt auf Ihrem IoT Edge-Gerät bereitzustellen. Sie haben schon ein Bereitstellungsmanifest für Ihr Szenario vorbereitet: die Datei deployment.amd64.json im Ordner „config“. Nun müssen Sie nur noch ein Gerät auswählen, um die Bereitstellung zu empfangen.

Sorgen Sie dafür, dass Ihr IoT Edge-Gerät ordnungsgemäß ausgeführt wird.

Erweitern Sie im Visual Studio Code-Explorer im Abschnitt Azure IoT Hub den Bereich Geräte, um Ihre IoT-Geräteliste anzuzeigen.
Klicken Sie mit der rechten Maustaste auf den Namen Ihres IoT Edge-Geräts, und klicken Sie dann auf Create Deployment for Single Device (Bereitstellung für einzelnes Gerät erstellen).
Wählen Sie die Datei deployment.amd64.json im Konfigurationsordner config aus und wählen Sie dann Edge-Bereitstellungsmanifest auswählen. Verwenden Sie nicht die Datei „deployment.template.json“.
Erweitern Sie unter Ihrem Gerät den Bereich Module, um eine Liste mit bereitgestellten und ausgeführten Modulen anzuzeigen. Klicken Sie auf die Schaltfläche Aktualisieren. Nun sollten die neuen Module classifier und cameraCapture als ausgeführt angezeigt werden – zusammen mit $edgeAgent und $edgeHub.

Sie können auch direkt auf dem Gerät überprüfen, ob alle Module ausgeführt werden. Führen Sie auf dem IoT Edge-Gerät den folgenden Befehl aus, um den Status der Module anzuzeigen.

iotedge list

Es dauert ggf. einige Minuten, bis die Module gestartet werden. Die IoT Edge-Runtime muss das neue Bereitstellungsmanifest empfangen, die Modulimages per Pullvorgang aus der Containerruntime abrufen und dann jedes neue Modul starten.

Anzeigen der Klassifizierungsergebnisse

Die Ergebnisse Ihrer Module können auf zwei Arten angezeigt werden: auf dem Gerät selbst, wenn die Nachrichten generiert und gesendet werden, oder über Visual Studio Code, wenn die Nachrichten bei IoT Hub eingehen.

Zeigen Sie auf Ihrem Gerät die Protokolle des Moduls „cameraCapture“ an, um die gesendeten Nachrichten und die Empfangsbestätigung von IoT Hub zu sehen.

iotedge logs cameraCapture

Beispielsweise sollte Ihnen eine Ausgabe wie die folgende angezeigt werden:

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

Sie können auch Nachrichten aus Visual Studio Code anzeigen. Klicken Sie mit der rechten Maustaste auf den Namen Ihres IoT Edge-Geräts, und wählen Sie Start Monitoring Built-in Event Endpoint (Überwachung des integrierten Ereignisendpunkts starten) aus.

[IoTHubMonitor] [2:43:36 PM] Message received from [vision-device/cameraCapture]:
{
  "created": "2023-07-13T21:43:35.697782",
  "id": "",
  "iteration": "",
  "predictions": [
    {
      "boundingBox": null,
      "probability": 1,
      "tagId": "",
      "tagName": "hemlock"
    }
  ],
  "project": ""
}

Hinweis

Die Ausgabe des Moduls „cameraCapture“ enthält unter Umständen zunächst einige Verbindungsfehler. Dies ist auf die Verzögerung zwischen Modulen zurückzuführen, die bereitgestellt und gestartet werden.

Vom Modul „cameraCapture“ wird automatisch weiter versucht, eine Verbindung herzustellen, bis der Vorgang erfolgreich war. Danach werden die erwarteten Bildklassifizierungsnachrichten angezeigt.

Die Ergebnisse aus dem Custom Vision-Modul, die vom Modul „cameraCapture“ in Form von Nachrichten gesendet werden, enthalten die Angabe, mit welcher Wahrscheinlichkeit es sich bei dem Bild um das einer Hemlocktanne oder eines Kirschbaums handelt. Da auf dem Bild eine Hemlocktanne zu sehen ist, sollte die Wahrscheinlichkeit bei 1.0 liegen.

Bereinigen von Ressourcen

Falls Sie mit dem nächsten empfohlenen Artikel fortfahren möchten, können Sie die erstellten Ressourcen und Konfigurationen beibehalten und wiederverwenden. Sie können auch dasselbe IoT Edge-Gerät als Testgerät weiter nutzen.

Andernfalls können Sie die in diesem Artikel verwendeten lokalen Konfigurationen und die Azure-Ressourcen löschen, um Kosten zu vermeiden.

Löschen von Azure-Ressourcen

Das Löschen von Azure-Ressourcen und -Ressourcengruppen kann nicht rückgängig gemacht werden. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Wenn Sie den IoT-Hub in einer bereits vorhandenen Ressourcengruppe erstellt haben, die Ressourcen enthält, die Sie behalten möchten, löschen Sie nicht die Ressourcengruppe, sondern nur die IoT-Hub-Ressource.

So löschen Sie die Ressourcen:

Melden Sie sich beim Azure-Portal an, und wählen Sie anschließend Ressourcengruppen aus.
Wählen Sie den Namen der Ressourcengruppe aus, die Ihre IoT Edge-Testressourcen enthält.
Überprüfen Sie die Liste der Ressourcen, die in Ihrer Ressourcengruppe enthalten sind. Wenn Sie alle löschen möchten, klicken Sie auf Ressourcengruppe löschen. Wenn Sie nur einige Ressourcen löschen möchten, klicken Sie auf die jeweiligen Ressourcen, um sie einzeln zu löschen.

Nächste Schritte

In diesem Tutorial haben Sie ein Custom Vision-Modell trainiert und als Modul auf einem IoT Edge-Gerät bereitgestellt. Anschließend haben Sie ein Modul erstellt, das den Bildklassifizierungsdienst abfragen und die Ergebnisse an IoT Hub zurückgeben kann.

Sie können die nächsten Tutorials lesen, um andere Möglichkeiten kennenzulernen, wie Azure IoT Edge Ihnen beim Umwandeln von Daten in geschäftliche Erkenntnisse auf Edge-Ebene helfen kann.

Speichern von Daten im Edge-Bereich mit SQL Server-Datenbanken