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

Gilt für: IoT Edge 1,5

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 AI Custom Vision können Sie benutzerdefinierte Imageklassifizierer erstellen und als Container auf Geräten 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:

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

Voraussetzungen

• Richten Sie Ihre Umgebung für die Entwicklung von Linux-Containern ein, indem Sie Tutorial ausführen: Entwickeln Sie IoT Edge Module mithilfe von Visual Studio Code mit dem bevorzugten Azure IoT Edge Dev Tool Befehlszeilenentwicklungstool (CLI). Stellen Sie nach Abschluss des Lernprogramms sicher, dass die folgenden Voraussetzungen in Ihrer Entwicklungsumgebung verfügbar sind:

  • Eine kostenlose oder standardstufige IoT Hub in Azure
  • Ein Gerät, auf dem Azure IoT Edge mit Linux-Containern ausgeführt wird. 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 der Erweiterung Azure IoT Hub 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:

  • Python
  • Git
  • Python erweiterung für Visual Studio Code

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

1. Navigieren Sie im Webbrowser zur Custom Vision-Webseite.

2. Wählen Sie Sign in aus, und melden Sie sich mit demselben Konto an, das Sie für den Zugriff auf Azure Ressourcen verwenden.

3. Wählen Sie "Neues Projekt" aus.

4. 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 Service-Ressource enthalten, oder neuer erstellen 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...)

5. 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.

1. Klonen oder Herunterladen von Beispielbildern aus dem Cognitive-CustomVision-Windows Repo auf Ihrem lokalen Entwicklungscomputer.

   git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
   

2. Kehren Sie zu Ihrem Custom Vision-Projekt zurück, und wählen Sie Bilder hinzufügen aus.

3. Navigieren Sie zu dem Git-Repository, das Sie lokal geklont haben, und navigieren Sie 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.

4. Fügen Sie der Gruppe von Bildern das Tag hemlock hinzu, und drücken Sie dann die EINGABETASTE , um das Tag anzuwenden.

5. Wählen Sie 10 Dateien hochladen aus.

   

6. Klicken Sie nach dem erfolgreichen Hochladen der Bilder auf Fertig.

7. Wählen Sie erneut Bilder hinzufügen aus.

8. 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.

9. Fügen Sie dieser Gruppe von Bildern das Tag japanese cherry hinzu, und drücken Sie dieEINGABETASTE, um das Tag anzuwenden.

10. Wählen Sie 10 Dateien hochladen aus. Klicken Sie nach dem erfolgreichen Hochladen der Bilder auf Fertig.

11. Wählen Sie nach dem Kategorisieren und Hochladen beider Bildergruppen " Trainieren " aus, um den Klassifizierer zu trainieren.

Exportieren Ihrer Klassifizierung

1. Wählen Sie nach dem Trainieren Ihrer Klassifizierung auf der Leistungsseite der Klassifizierung die Option Exportieren aus.

   

2. Wählen Sie für die Plattform die Option DockerFile aus.

3. Wählen Sie für die Version die Option Linux aus.

4. Wählen Sie Exportieren aus.

5. 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 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 Lösung

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 Lösung ist eine logische Möglichkeit, mehrere Module für eine einzelne IoT Edge Bereitstellung zu entwickeln und zu organisieren. Eine Lösung enthält Code für ein oder mehrere Module und das Bereitstellungsmanifest, das deklariert, wie sie auf einem IoT Edge Gerät konfiguriert werden. Erstellen Sie die Lösung mit dem Azure IoT Edge Dev Tool Befehlszeilenentwicklungstool (CLI). Die einfachste Möglichkeit zum Verwenden des Tools ist das IoT Edge Dev Container mit Docker auszuführen.

1. Erstellen Sie ein Verzeichnis mit dem Namen classifier und wechseln Sie in das Verzeichnis.

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Führen Sie das Tool iotedgedev init command aus, um eine neue IoT Edge Lösung zu erstellen. Geben Sie im Container IoT Edge Dev Docker den folgenden Befehl ein:

   iotedgedev solution init --template python --module classifier
   

   Die Iotedgedev-Lösung init fordert Sie auf, mehrere Schritte auszuführen, darunter:

   • Authentifizieren bei Azure
   • Auswählen eines Azure-Abonnements
   • Eine Ressourcengruppe auswählen oder erstellen
   • Auswählen oder Erstellen eines Azure IoT Hub
   • Auswählen oder Erstellen eines Azure IoT Edge Geräts

   Der Befehl erstellt eine neue IoT Edge Lösung mit einem Modul namens classifier im aktuellen Arbeitsverzeichnis.

3. Ö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 ausführen können, um IoT Edge zu testen. 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.

1. 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.

2. Navigieren Sie im Datei-Explorer zu dem Verzeichnis, in dem Sie Visual Studio Code angewiesen haben, Ihre IoT Edge Lösung zu erstellen.

3. Ö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.

4. Fügen Sie die Dateien in den Ordner classifier ein.

5. Kehren Sie zum Fenster von Visual Studio Code zurück. Im Arbeitsbereich Ihrer Projektmappe sollten nun im Modulordner die Bildklassifizierungsdateien angezeigt werden.

6. 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.

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

1. 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
   

2. Öffnen Sie die main.py Datei im Ordner "Module / cameracapture" .

3. 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" )
   

4. Speichern Sie die main.py Datei.

5. Öffnen Sie die Datei requirements.txt.

6. Fügen Sie eine neue Zeile für eine Bibliothek hinzu, die in den Container aufgenommen werden soll.

   requests
   

7. 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 im GitHub Repository enthalten, das Sie zuvor in diesem Lernprogramm für die Schulungsbilder heruntergeladen haben.

1. Navigieren Sie zum Testbild, das sich in Cognitive-CustomVision-Windows / Samples / Images / Test befindet.

2. Kopieren Sie test_image.jpg.

3. Navigieren Sie zu Ihrem IoT Edge Lösungsverzeichnis, und fügen Sie das Testbild in den Ordner module / cameracapture ein. Das Bild muss sich im gleichen Ordner befinden wie die Datei „main.py“, die Sie im vorherigen Abschnitt bearbeitet haben.

4. Öffnen Sie in Visual Studio Code die Datei Dockerfile.amd64 für das Kamerakapselmodul.

5. Fügen Sie nach der Zeile, die das Arbeitsverzeichnis (WORKDIR /app) festlegt, die folgende Codezeile hinzu:

   ADD ./test_image.jpg .
   

6. Speichern Sie das Dockerfile.

Vorbereiten eines Bereitstellungsmanifests

Bisher haben Sie in diesem Lernprogramm ein benutzerdefiniertes Visionsmodell 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 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 eine Vorlage in jeder IoT Edge Lösung bereit, die Sie beim Erstellen eines Bereitstellungsmanifests unterstützt.

1. Öffnen Sie die Datei deployment.template.json aus dem Projektmappenordner.

2. 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 Access keys Ihrer Azure Containerregistrierung im Azure-Portal.

3. Suchen Sie den Abschnitt "Module ", der drei Module enthält: die beiden Erstellten, Klassifizierer und Kameracapture sowie ein dritter, standardmäßig enthaltener tempSensor.

4. Löschen Sie das tempSensor-Modul mit allen Parametern. Dieses Modul stellt Beispieldaten für Testszenarien bereit, ist in dieser Bereitstellung jedoch nicht erforderlich.

5. 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 Kameracapture-Modul ruft das Klassifizierermodul mithilfe einer Bibliothek für Anfragen auf, die alle Anfragen in Kleinbuchstaben formatiert. Da IoT Edge jedoch die Groß- und Kleinschreibung berücksichtigt, kann dies zu Problemen führen.

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

7. Ä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",
   

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

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

10. Speichern Sie die deployment.template.json Datei.

Erstellen und Veröffentlichen Ihrer IoT-Edge-Lösung

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 Lösung auf einem IoT Edge Gerät bereitstellen. Sie können Module auf einem Gerät über die IoT Hub festlegen. In diesem Abschnitt richten Sie den Zugriff auf Ihre IoT Hub ein, und verwenden Sie 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.

1. Öffnen Sie das Visual Studio Code integrierte Terminal, indem Sie View>Terminal auswählen.

2. 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. Sie können diese Werte im Abschnitt Access keys Ihrer Registrierung im Azure-Portal abrufen.

   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-Anmeldereferenz .

3. 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.

1. Melden Sie sich mit den ACR-Anmeldeinformationen (Azure Container Registry) bei Docker 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-Anmeldereferenz .

2. Melden Sie sich beim Azure Container Registry an. Sie müssen Install Azure CLI verwenden, um den Befehl az 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 sich an einem beliebigen Punkt in diesem Lernprogramm abgemeldet haben, wiederholen Sie die Schritte zum Anmelden von Docker und Azure Container Registry, um den Vorgang fortzusetzen.

3. 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": {
          "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 für die Azure IoT Hub bereitzustellen. Um beispielsweise die module bereitzustellen, die in der Datei deployment.template.json in IoT Hub <IotHubName> für das IoT Edge Gerät <DeviceName> definiert sind, verwenden Sie den folgenden Befehl. Ersetzen Sie die Werte für hub-name, device-id und login IoT Hub connection string durch Ihren eigenen Namen.

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

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

Erweitern Sie unter Ihrem Gerät Module , um eine Liste der bereitgestellten und ausgeführten Module 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 Ihrem 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 Laufzeit muss das neue Bereitstellungsmanifest empfangen, die Modulimages aus der Containerlaufzeit herunterziehen 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": ""}

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 wie ein Testgerät verwenden.

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 Azure Ressourcen

Sie können das Löschen Azure Ressourcen und Ressourcengruppen nicht rückgängigmachen. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Wenn Sie die 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:

1. Melden Sie sich beim portal Azure an, und wählen Sie dann Resource groups aus.
2. Wählen Sie den Namen der Ressourcengruppe aus, die Ihre IoT Edge Testressourcen enthält.
3. Überprüfen Sie die Liste der Ressourcen, die Ihre Ressourcengruppe enthält. Wenn Sie alle löschen möchten, können Sie " Ressourcengruppe löschen" auswählen. Wenn Sie nur einige davon löschen möchten, wählen Sie jede Ressource aus, um sie einzeln zu löschen.

Nächste Schritte

In diesem Lernprogramm haben Sie ein benutzerdefiniertes 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 zurück an IoT Hub melden kann.

Fahren Sie mit den nächsten Lernprogrammen fort, um weitere Möglichkeiten zu erfahren, wie Azure IoT Edge Ihnen helfen können, Daten in Geschäftseinblicke am Edge umzuwandeln.