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

2025-05-08

Gilt für: IoT Edge 1.5

Wichtig

IoT Edge 1.5 LTS ist das unterstützte Release. IoT Edge 1.4 LTS wurde am 12. November 2024 eingestellt. Wenn Sie ein früheres Release verwenden, finden Sie weitere Informationen unter Aktualisieren von IoT Edge.

Azure IoT Edge macht IoT-Lösungen effizienter, indem Workloads von der Cloud zum Edge verschoben werden. 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. Zusammen ermöglichen diese beiden Dienste Benutzern, Erkenntnisse aus Bildern oder Videostreams zu finden, ohne zuerst alle Daten außerhalb der Website zu übertragen. Custom Vision bietet einen Klassifizierer, der Bilder mit einem trainierten Modell vergleicht, um Erkenntnisse zu generieren.

Beispielsweise kann benutzerdefinierte Vision auf einem IoT Edge-Gerät ermitteln, ob eine Autobahn über einen höheren oder niedrigeren Verkehr als normal verfügt oder ob eine Parkgarage in einer Reihe Parkplätze zur Verfügung stellt. 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 Sie ein IoT Edge-Modul, das den Custom Vision-Webserver auf dem Gerät abfragt.
Senden Sie die Bildklassifiziererergebnisse an IoT Hub.

Architekturdiagramm des Tutorials: Staging und Bereitstellung der Klassifizierung

Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses 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). Es wird auf einer Cloud-VM ausgeführt und verwendet statische Bilder, um den Imageklassifizierer zu trainieren und zu testen, was jemandem hilft, der neu in Custom Vision auf IoT Edge ist. Das Beispielprojekt verwendet physische Hardware und richtet einen Livekamerafeed ein, um den Bildklassifizierer zu trainieren und zu testen, der für jemanden hilfreich ist, der ein detaillierteres, reales Szenario untersucht.

Richten Sie Ihre Umgebung für die Entwicklung von Linux-Containern ein, indem Sie das Tutorial: Entwickeln von IoT Edge-Modulen mit Visual Studio Code unter Verwendung des bevorzugten Befehlszeilen-Entwicklungstools (CLI) von Azure IoT Edge Dev Tool abschließen. Stellen Sie nach Abschluss des Lernprogramms sicher, dass die folgenden Voraussetzungen in Ihrer Entwicklungsumgebung verfügbar sind:
- Ein kostenloser oder standardstufiger IoT-Hub in Azure
- Ein Gerät, auf dem Azure IoT Edge mit Linux-Containern läuft. Verwenden Sie die Schnellstarts zum Einrichten eines Linux-Geräts oder Windows-Geräts.
- Eine Containerregistrierung, z. B. Azure Container Registry.
- Visual Studio Code mit Azure IoT Hub-Erweiterung konfiguriert.
- Laden Sie ein Docker-kompatibles Containerverwaltungssystem auf Ihrem Entwicklungscomputer herunter, und installieren Sie es. Richten Sie es ein, um Linux-Container auszuführen.
Um ein IoT Edge-Modul mit dem Custom Vision-Dienst zu entwickeln, stellen Sie sicher, dass die folgenden zusätzlichen Voraussetzungen auf Ihrem Entwicklungscomputer installiert sind:

Erstellen einer Bildklassifizierung mit Custom Vision

Um einen Bildklassifizierer zu erstellen, erstellen Sie ein Projekt "Custom Vision", und stellen Sie Schulungsbilder bereit. Weitere Informationen zu den Schritten in diesem Abschnitt finden Sie unter Erstellen einer Klassifizierung mit Custom Vision.

Nachdem Sie Ihren Imageklassifizierer erstellt und trainiert haben, exportieren Sie ihn als Docker-Container, und stellen Sie ihn auf einem IoT Edge-Gerät bereit.

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.
Ressource	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 alle 10 Bilder im Ordner aus, und wählen Sie dann "Öffnen" aus.
Fügen Sie der Gruppe von Bildern das Tag hemlock hinzu, und drücken Sie dann die EINGABETASTE , 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.
Wählen Sie nach dem Kategorisieren und Hochladen beider Bildergruppen " Trainieren " aus, um den Klassifizierer 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.
Nachdem der Export abgeschlossen ist, wählen Sie "Herunterladen" aus, und speichern Sie das .zip Paket lokal auf Ihrem Computer. Extrahieren Sie alle Dateien aus dem Paket. Verwenden Sie diese Dateien, um ein IoT Edge-Modul zu erstellen, das den Imageklassifizierungsserver 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

Sie verfügen jetzt über die Dateien für eine Containerversion Ihres Imageklassifizierers auf Ihrem Entwicklungscomputer. In diesem Abschnitt richten Sie den Imageklassifizierercontainer so ein, dass er als IoT Edge-Modul ausgeführt wird. Sie erstellen auch ein zweites Modul, das Anforderungen an den Klassifizierer sendet und die Ergebnisse als Nachrichten an IoT Hub sendet.

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. Erstellen Sie die Lösung mithilfe des Befehlszeilentools (Cli) des Azure IoT Edge Dev Tools . Die einfachste Möglichkeit zum Verwenden des Tools besteht darin, den IoT Edge Dev Container mit Docker auszuführen.

Erstellen Sie ein Verzeichnis mit dem Namen classifier und wechseln Sie in das Verzeichnis.
```
mkdir CustomVisionSolution
cd CustomVisionSolution
```
Führen Sie das Iotedgedev-Tool init-Befehl aus, um eine neue IoT Edge-Lösung zu erstellen. Geben Sie im IoT Edge Dev Docker-Container den folgenden Befehl ein:
```
iotedgedev solution init --template python --module classifier
```
Die Iotedgedev-Lösung init fordert Sie auf, mehrere Schritte auszuführen, darunter:
- Für Azure authentifizieren
- Ein Azure-Abonnement auswählen
- Eine Ressourcengruppe auswählen oder erstellen
- Einen Azure IoT Hub auswählen oder erstellen
- Ein Azure IoT Edge-Gerät auswählen oder erstellen
Der Befehl erstellt eine neue IoT Edge-Lösung mit einem Modul namens Klassifizierer im aktuellen Arbeitsverzeichnis.
Öffnen Sie die Lösung in Visual Studio Code.

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.
Ersetzen Sie die ursprüngliche Dockerfile.amd64-Datei durch die Dockerfile aus dem benutzerdefinierten Vision-Paket, indem Sie die ursprüngliche Dockerfile.amd64 löschen und Dockerfile in Dockerfile.amd64 umbenennen.
Speichern Sie die Änderungen.

Erstellen eines simulierten Kameramoduls

In einer echten benutzerdefinierten Vision-Bereitstellung stellt eine Kamera Livebilder oder Videostreams bereit. In diesem Szenario simulieren Sie die Kamera, indem Sie ein Modul erstellen, das ein Testbild an die Bildklassifizierung sendet.

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.

Verwenden Sie das Iotedgedev-Tool , um der Lösung ein neues Modul hinzuzufügen. Der Befehl erstellt einen neuen Ordner namens "cameracapture " im Modulordner Ihrer Lösung.
```
iotedgedev solution add --template python cameracapture
```
Öffnen Sie die main.py Datei im Ordner "Module / 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 zu Ihrem IoT Edge-Lösungsverzeichnis, und fügen Sie das Testbild in denOrdner "Module / 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 Kameracapture-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

Bisher in diesem Lernprogramm haben Sie ein benutzerdefiniertes Vision-Modell trainiert, um Bilder von Bäumen zu klassifizieren und dieses Modell als IoT Edge-Modul zu verpacken. Anschließend haben Sie ein zweites Modul erstellt, das den Bildklassifizierungsserver abfragt und die Ergebnisse an IoT Hub meldet. Jetzt können Sie das Bereitstellungsmanifest erstellen, das ein 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.
Legen Sie die Registrierungsanmeldeinformationen für die Module im Bereitstellungsmanifest fest.
```
"registryCredentials": {
    "<registryName>": {
        "username": "<AcrUsername>",
        "password": "<AcrPassword>",
        "address": "<registryName>.azurecr.io"
    }
}
```
Ersetzen Sie <"registryName>" durch den Namen Ihrer Azure-Containerregistrierung, und ersetzen Sie <AcrUsername> und<AcrPassword> durch den Benutzernamen und das Kennwort für Ihre Registrierung. Sie finden diese Werte im Abschnitt "Zugriffstasten " Ihrer Azure-Containerregistrierung im Azure-Portal.
Suchen Sie den Abschnitt "Module ", der drei Module enthält: die beiden Erstellten, Klassifizierer und Kameracapture sowie ein dritter, standardmäßig enthaltener tempSensor.
Löschen Sie das tempSensor-Modul mit allen Parametern. Dieses Modul stellt Beispieldaten für Testszenarien bereit, ist in dieser Bereitstellung jedoch nicht erforderlich.
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.

Ändern Sie für alle edgeAgent- und edgeHub-Systemmodule den Wert von createOptions, um ihn in eine Zeichenfolge umzuwandeln. Beispiel:

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

Ändern Sie für jedes Systemmodul EdgeAgent und EdgeHub die Imageversion in die neueste Version 1.5. Beispiel:
```
"image": "mcr.microsoft.com/azureiotedge-agent:1.5",
"image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

Aktualisieren Sie den Parameter createOptions für das Modul classifier, um ihn in eine Zeichenfolge umzuwandeln. Beispiel:

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

Aktualisieren Sie den parameter createOptions für das Kameracapture-Modul mit dem folgenden JSON. Diese Informationen erstellen Umgebungsvariablen im Modulcontainer, die im Prozess „main.py“ abgerufen werden. Wenn Sie diese Informationen in das Bereitstellungsmanifest einschließen, 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.

Die Klassifizierer - und Kamerakapselkonfiguration sollte z. B. ähnlich sein wie:

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

Speichern Sie die Datei deployment.template.json.

Erstellen und Pushen Ihrer IoT Edge-Projektmappe

Nachdem Sie beide Module erstellt und die Bereitstellungsmanifestvorlage konfiguriert haben, erstellen Sie die Containerimages, und übertragen Sie sie in die Containerregistrierung.

Sobald sich die Images in Ihrer Registrierung befinden, können Sie die Projektmappe auf einem IoT Edge-Gerät bereitstellen. Sie können Module auf einem Gerät über den IoT Hub festlegen. In diesem Abschnitt richten Sie den Zugriff auf Ihren IoT Hub ein und verwenden dann Azure CLI, um Ihre Lösung auf Ihrem IoT Edge-Gerät bereitzustellen.

Erstellen Sie zunächst die Lösung, und übertragen Sie sie an die Containerregistrierung.

Öffnen Sie das in Visual Studio Code integrierte Terminal, indem Sie Ansicht>Terminal wählen.
Melden Sie sich bei Docker an, indem Sie den folgenden Befehl im Terminal mithilfe des Benutzernamens, des Kennworts und des Anmeldeservers aus der Azure-Containerregistrierung eingeben. Diese Werte finden Sie im Azure-Portal im Abschnitt Zugriffsschlüssel Ihrer Registrierung.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
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.

Verwenden Sie das Dockerfile des Moduls, um das Modul-Docker-Image zu erstellen und zu taggen.

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

Verwenden Sie beispielsweise die folgenden Befehle, um das Image für die lokale Registrierung oder eine Azure-Containerregistrierung zu erstellen:


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

Pushen des Moduls „Docker-Image“

Geben Sie Ihre Anmeldeinformationen für die Containerregistrierung für Docker an, damit Ihr Containerimage per Pushvorgang übertragen und in der Registrierung gespeichert werden kann.

Melden Sie sich in Docker mit den Anmeldeinformationen für die Azure Container Registry (ACR) an.
```
docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
```
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.
Melden Sie sich bei Azure Container Registry an. Sie müssen Azure CLI installieren, um den az Befehl zu verwenden. Dieser Befehl fordert Ihren Benutzernamen und Ihr Kennwort an, die Sie in Ihrer Containerregistrierung unter Einstellungen>Zugriffsschlüssel finden.
```
az acr login -n <AcrRegistryName>
```
Tipp

Wenn Sie an irgendeinem Punkt in diesem Tutorial abgemeldet werden, wiederholen Sie die Schritte für die Docker- und Azure Container Registry-Anmeldung, um fortzufahren.

Pushen Sie Ihr Modulimage in die lokale Registrierung oder eine Containerregistrierung.

docker push <ImageName>

Beispiel:

# 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

Aktualisieren der Bereitstellungsvorlage

Aktualisieren Sie die deployment.template.json Datei mit dem Speicherort des Containerregistrierungsimages. Ändern Sie den Bildwert in das Bild, das Sie an die Registrierung übertragen haben. Ersetzen Sie <beispielsweise AcrRegistryName> durch Ihren Registrierungsnamen in den Bildwerten für die Klassifizierer- und Kamerakapselmodule:

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

Das endgültige Bereitstellungsmanifest sieht ähnlich wie folgt aus:

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

Bereitstellen von Modulen auf dem Gerät

Stellen Sie sicher, dass erstellte Container-Images in Ihrer Container-Registrierung gespeichert sind. Dann deployieren Sie sie auf einem Gerät mithilfe des Bereitstellungsmanifests deployment.template.json, das für Ihr Szenario vorbereitet wurde.

Verwenden Sie den Befehl "IoT Edge Azure CLI-Set-modules" , um die Module im Azure IoT Hub bereitzustellen. Verwenden Sie beispielsweise den folgenden Befehl, um die in der deployment.template.json-Datei definierten Module in IoT Hub <IotHubName> für das IoT Edge-Gerät DeviceName <>bereitzustellen. Ersetzen Sie die Werte für Hubname, Geräte-ID und Anmelde-IoT Hub-Verbindungszeichenfolge durch Ihre eigene.

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

Tipp

Sie finden Ihre IoT Hub-Verbindungszeichenfolge, einschließlich des freigegebenen Zugriffsschlüssels, im Azure-Portal. Wechseln Sie zu Ihren IoT Hub->Sicherheitseinstellungen>Gemeinsam genutzte Zugriffsrichtlinien>iothubowner.

Stellen Sie sicher, dass Ihr IoT Edge-Gerät läuft.

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. Sie sehen die neuen Klassifizierer und Kameracapture-Module, die zusammen mit $edgeAgent und $edgeHub ausgeführt werden.

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

Zeigen Sie auf Ihrem Gerät die Protokolle des Kameracapture-Moduls an, um die gesendeten Nachrichten anzuzeigen und zu bestätigen, dass sie von IoT Hub empfangen werden.

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

Hinweis

Zunächst könnten in der Ausgabe des Moduls „cameracapture“ Verbindungsfehler angezeigt werden, da es zu Verzögerungen zwischen dem Bereitstellen und dem Starten der Module kommt.

Das Kameraaufnahmemodul versucht automatisch, die Verbindung wiederherzustellen, bis es erfolgreich ist. Nach der erfolgreichen Verbindung werden die erwarteten Bildklassifizierungsmeldungen angezeigt.

Die Ergebnisse des Custom Vision-Moduls, die als Nachrichten aus dem Kameracapture-Modul gesendet werden, enthalten die Wahrscheinlichkeit, dass das Bild ein Hemlock oder Kirschbaum ist. Da auf dem Bild eine Hemlocktanne zu sehen ist, liegt die Wahrscheinlichkeit bei 1.0.

Bereinigen von Ressourcen

Wenn Sie den nächsten empfohlenen Artikel fortsetzen möchten, behalten Sie die von Ihnen erstellten Ressourcen und Konfigurationen bei, und verwenden Sie sie wieder. Sie können auch dasselbe IoT Edge-Gerät als Testgerät weiter nutzen.

Löschen Sie andernfalls die lokalen Konfigurationen und die Azure-Ressourcen, die Sie in diesem Artikel verwendet haben, um Gebühren 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 vorhandenen Ressourcengruppe erstellt haben, die Ressourcen enthält, die Sie behalten möchten, löschen Sie nur die IoT Hub-Ressource selbst, nicht die Ressourcengruppe.

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 Ihre Ressourcengruppe enthält. Wenn Sie alle löschen möchten, klicken Sie auf Ressourcengruppe löschen. Wenn Sie nur einige Ressourcen löschen möchten, wählen Sie die jeweiligen Ressourcen aus, 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

Freigeben über