Självstudie: Utföra bildklassificering på gränsen med Custom Vision Service

Gäller för: IoT Edge 1.5

Azure IoT Edge gör IoT-lösningar effektivare genom att flytta arbetsbelastningar från molnet till gränsen. Den här funktionen lämpar sig väl för tjänster som bearbetar stora mängder data, till exempel modeller för visuellt innehåll. Med Azure AI Custom Vision kan du skapa anpassade bildklassificerare och distribuera dem till enheter som containrar. Tillsammans låter dessa två tjänster användarna hitta insikter från bilder eller videoströmmar utan att först överföra alla data utanför platsen. Custom Vision tillhandahåller en klassificerare som jämför bilder med en tränad modell för att generera insikter.

Custom Vision på en IoT Edge-enhet kan till exempel avgöra om en motorväg har högre eller lägre trafik än normalt, eller om ett parkeringsgarage har tillgängliga parkeringsplatser i rad. Dessa insikter kan delas med en annan tjänst i åtgärdssyfte.

I den här självstudien lär du dig att:

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

Förutsättningar

• Konfigurera din miljö för utveckling av Linux-containrar genom att slutföra Självstudie: Utveckla IoT Edge-moduler med hjälp av Visual Studio Code med det föredragna cli-utvecklingsverktyg ( Azure IoT Edge Dev Tool ). När du har slutfört självstudien kontrollerar du att följande krav är tillgängliga i utvecklingsmiljön:

  • En kostnadsfri IoT Hub eller en IoT Hub på standardnivå i Azure
  • En enhet som kör Azure IoT Edge med Linux-containrar. Använd snabbstarterna för att konfigurera en Linux-enhet eller Windows-enhet.
  • Ett containerregister, till exempel Azure Container Registry.
  • Visual Studio Code har konfigurerats med Azure IoT Hub-tillägget .
  • Ladda ned och installera ett Docker-kompatibelt containerhanteringssystem på utvecklingsdatorn. Konfigurera det för att köra Linux-containrar.

• Om du vill utveckla en IoT Edge-modul med Custom Vision-tjänsten kontrollerar du att följande ytterligare krav är installerade på utvecklingsdatorn:

  • Pytonorm
  • Git
  • Python-tillägg för Visual Studio Code

Skapa en bildklassificerare med Custom Vision

Skapa en bildklassificerare genom att skapa ett Custom Vision-projekt och tillhandahålla träningsbilder. Mer information om de steg som du vidtar i det här avsnittet finns på sidan om hur du skapar en klassificerare med Custom Vision.

När du har skapat och tränat avbildningsklassificeraren exporterar du den som en Docker-container och distribuerar den till en IoT Edge-enhet.

Skapa ett nytt projekt

1. I din webbläsare navigerar du till Custom Vision-webbplatsen.

2. Välj Logga in och logga in med samma konto som du använder för att få åtkomst till Azure-resurser.

3. Välj Nytt projekt.

4. Skapa ditt projekt med följande värden:

   Fält	Värde
   Namn	Ange ett namn för projektet, till exempel EdgeTreeClassifier.
   beskrivning	Valfri projektbeskrivning.
   Resurs	Välj en av dina Azure-resursgrupper som innehåller en Custom Vision Service-resurs eller skapa en ny om du inte har lagt till en ännu.
   Projekttyper	Omdöme
   Klassificeringstyper	Multiklass (enskild tagg per bild)
   Domäner	Allmän (kompakt)
   Exportera funktioner	Grundläggande plattformar (TensorFlow, CoreML, ONNX, ...)

5. Välj Skapa projekt.

Ladda upp bilder och träna klassificeraren

För att skapa en bildklassificerare krävs en uppsättning träningsbilder och testbilder.

1. Klona eller ladda ned exempelbilder från lagringsplatsen Cognitive-CustomVision-Windows till din lokala utvecklingsdator.

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

2. Återgå till Custom Vision-projektet och välj Lägg till bilder.

3. Bläddra till den git-lagringsplats som du klonade lokalt och navigera till den första bildmappen, Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Markera alla 10 bilder i mappen och välj sedan Öppna.

4. Lägg till taggen hemlock i den här gruppen med bilder och tryck sedan på Retur för att tillämpa taggen.

5. Välj Ladda upp 10 filer.

   

6. När bilderna har laddats upp väljer du Klar.

7. Välj Lägg till bilder igen.

8. Bläddra till den andra bildmappen, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Välj alla 10 bilder i mappen och sedan Öppna.

9. Lägg till taggen japanese cherry (japanskt körsbärsträd) till den här gruppen med bilder och tryck på Retur för att tillämpa taggen.

10. Välj Ladda upp 10 filer. När bilderna har laddats upp väljer du Klar.

11. När du har taggat och laddat upp båda uppsättningarna av bilder väljer du Träna för att träna klassificeraren.

Exportera klassificeraren

1. När du har tränat klassificeraren väljer du Exportera på sidan Prestanda för klassificeraren.

   

2. Välj DockerFile som plattform.

3. Välj Linux som version.

4. Välj Exportera.

5. När exporten är klar väljer du Ladda ned och sparar .zip-paketet lokalt på datorn. Extrahera alla filer från paketet. Använd dessa filer för att skapa en IoT Edge-modul som innehåller bildklassificeringsservern.

När du nått hit är du klar med att skapa och träna Custom Vision-projektet. Du använder de exporterade filerna i nästa avsnitt, men du är klar med Custom Vision-webbplatsen.

Skapa en IoT Edge-lösning

Nu har du filerna för en containerversion av avbildningsklassificeraren på utvecklingsdatorn. I det här avsnittet konfigurerar du containern för avbildningsklassificerare så att den körs som en IoT Edge-modul. Du skapar också en andra modul som skickar begäranden till klassificeraren och skickar resultatet som meddelanden till IoT Hub.

Skapa en ny lösning

En lösning är ett logiskt sätt att utveckla och organisera flera moduler för en enskild IoT Edge-distribution. En lösning innehåller kod för en eller flera moduler och distributionsmanifestet som förklarar hur du konfigurerar dem på en IoT Edge-enhet. Skapa lösningen med hjälp av cli-utvecklingsverktyg ( Azure IoT Edge Dev Tool ). Det enklaste sättet att använda verktyget är att köra IoT Edge Dev Container med Docker.

1. Skapa en katalog med namnet klassificerare och ändra till katalogen.

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Kör iotedgedev-verktyget init-kommandot för att skapa en ny IoT Edge-lösning. I IoT Edge Dev Docker-containern anger du följande kommando:

   iotedgedev solution init --template python --module classifier
   

   I init-skriptet iotedgedev-lösningen uppmanas du att utföra flera steg, bland annat:

   • Autentisera till Azure
   • Välj en Azure-prenumeration
   • Välj eller skapa en resursgrupp
   • Välj eller skapa en Azure IoT Hub
   • Välj eller skapa en Azure IoT Edge-enhet

   Kommandot skapar en ny IoT Edge-lösning med en modul med namnet klassificerare i den aktuella arbetskatalogen.

3. Öppna lösningen i Visual Studio Code.

Lägga till bildklassificeraren

Python-modulmallen i Visual Studio Code innehåller exempelkod som du kan köra för att testa IoT Edge. Du använder inte den koden i det här scenariot. Använd i stället stegen i det här avsnittet för att ersätta exempelkoden med den bildklassificerarcontainer som du exporterade tidigare.

1. I Utforskaren bläddrar du till det Custom Vision-paket som du laddade ned och extraherade. Kopiera allt innehåll från det extraherade paketet. Det bör vara två mappar, app och azureml, och två filer, Dockerfile och README.

2. I Utforskaren bläddrar du till den katalog där du angav att Visual Studio Code skulle skapa IoT Edge-lösningen.

3. Öppna mappen för klassificerarmodulen. Om du använde de föreslagna namnen i föregående avsnitt ser mappstrukturen ut så här: CustomVisionSolution/modules/classifier.

4. Klistra in filerna i mappen classifier.

5. Återgå till Visual Studio Code-fönstret. Lösningens arbetsyta bör nu visa bildklassificerarfilerna i modulmappen.

6. Ersätt den ursprungliga Dockerfile.amd64-filen med Dockerfile från custom vision-paketet genom att ta bort den ursprungliga Dockerfile.amd64 och byta namn på Dockerfile till Dockerfile.amd64.

7. Spara dina ändringar.

Skapa en modul med en simulerad kamera

I en verklig implementering av custom vision ger en kamera livebilder eller videoströmmar. För det här scenariot simulerar du kameran genom att skapa en modul som skickar en testbild till bildklassificeraren.

I det här avsnittet lägger du till en ny modul i samma CustomVisionSolution och anger kod för att skapa den simulerade kameran.

1. Använd verktyget iotedgedev och lägg till en ny modul i lösningen. Kommandot skapar en ny mapp med namnet cameracapturei modulmappen för din lösning.

   iotedgedev solution add --template python cameracapture
   

2. Öppna filen main.py i mappen modules / cameracapture .

3. Ersätt hela filen med följande kod. Den här exempelkoden skickar POST-begäranden till den bildbearbetningstjänst som körs i klassificerarmodulen. Vi förser den här modulcontainern med en exempelbild som ska användas i begärandena. Sedan paketerar den svaret som IoT Hub-meddelande och skickar det till en utdatakö.

   # 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. Spara filen main.py.

5. Öppna filen requirements.txt .

6. Lägg till en ny rad för ett bibliotek som ska inkluderas i containern.

   requests
   

7. Spara filen requirements.txt.

Lägga till en testbild i containern

I stället för att använda en verklig kamera för att ge en bildfeed för det här scenariot använder vi en enskild testbild. En testbild ingår i den GitHub-lagringsplats som du laddade ned för träningsbilderna tidigare i självstudien.

1. Gå till testbilden, som finns på Cognitive-CustomVision-Windows / Samples / Images / Test.

2. Kopiera test_image.jpg

3. Bläddra till din IoT Edge-lösningskatalog och klistra in testbilden i mappen modules / cameracapture . Bilden ska vara i samma mapp som filen main.py, som du redigerade i föregående avsnitt.

4. I Visual Studio Code öppnar du dockerfile.amd64-filen för modulen cameracapture.

5. Efter den rad som upprättar arbetskatalogen, WORKDIR /app, lägger du till följande kodrad:

   ADD ./test_image.jpg .
   

6. Spara Dockerfile.

Förbereda ett distributionsmanifest

Hittills i den här självstudien har du tränat en anpassad visionsmodell för att klassificera bilder av träd och paketerat modellen som en IoT Edge-modul. Sedan skapade du en andra modul som frågar bildklassificeringsservern och rapporterar dess resultat till IoT Hub. Nu är du redo att skapa distributionsmanifestet som talar om för en IoT Edge-enhet hur de ska starta och köra dessa två moduler tillsammans.

IoT Edge-tillägget för Visual Studio Code innehåller en mall i varje IoT Edge-lösning som hjälper dig skapa ett distributionsmanifest.

1. Öppna filen deployment.template.json i lösningsmappen.

2. Ange registerautentiseringsuppgifterna för modulerna i distributionsmanifestet.

   "registryCredentials": {
       "<registryName>": {
           "username": "<AcrUsername>",
           "password": "<AcrPassword>",
           "address": "<registryName>.azurecr.io"
       }
   }
   

   Ersätt <registryName> med namnet på ditt Azure-containerregister och ersätt <AcrUsername> och <AcrPassword> med användarnamnet och lösenordet för registret. Du hittar dessa värden i avsnittet Åtkomstnycklar i azure-containerregistret i Azure-portalen.

3. Leta reda på avsnittet moduler , som innehåller tre moduler: de två som du skapade, klassificerare och kamerakapsling, och en tredje som ingår som standard tempSensor.

4. Ta bort tempSensor-modulen med alla dess parametrar. Den här modulen innehåller exempeldata för testscenarier, men de behövs inte i den här distributionen.

5. Om du har gett bildklassificeringsmodulen något annat namn än classifier kontrollerar du namnet nu och ser till att det endast består av gemener. Modulen cameracapture anropar klassificerarmodulen med hjälp av biblioteket requests som formaterar alla begäranden i små bokstäver, och IoT Edge är skiftlägeskänsligt.

6. Ändra värdet createOptions till en strängifierad version för varje systemmodul edgeAgent och edgeHub. Till exempel:

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

7. Ändra avbildningsversionen till den senaste versionen 1.5 för varje systemmodul edgeAgent och edgeHub. Till exempel:

   "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
   "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   

8. Uppdatera parametern createOptions för klassificerarmodulen till en strängifierad version. Till exempel:

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

9. Uppdatera parametern createOptions för modulen cameracapture med följande JSON. Den här informationen skapar miljövariabler i modulcontainern som hämtas i main.py-processen. Med den här informationen i distributionsmanifestet kan du ändra avbildningen eller slutpunkten utan att återskapa modulbilden.

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

   Om du gav Custom Vision-modulen något annat namn än classifier uppdaterar du slutpunktsvärdet för bildbearbetning så att det matchar.

   Till exempel bör konfigurationen av klassificeraren och kamerakapslingen likna:

   "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. Spara filen deployment.template.json.

Skapa och push-överföra din IoT Edge-lösning

När du har skapat båda modulerna och konfigurerat mallen för distributionsmanifestet skapar du containeravbildningarna och push-överför dem till containerregistret.

När bilderna finns i registret kan du distribuera lösningen till en IoT Edge-enhet. Du kan ange moduler på en enhet via IoT Hub. I det här avsnittet konfigurerar du åtkomst till din IoT Hub och använder sedan Azure CLI för att distribuera din lösning till din IoT Edge-enhet.

Börja med att skapa och push-överföra lösningen till containerregistret.

1. Öppna den integrerade Terminalen i Visual Studio Code genom att välja Visa>terminal.

2. Logga in på Docker genom att ange följande kommando i terminalen med användarnamnet, lösenordet och inloggningsservern från Azure-containerregistret. Du kan hämta dessa värden från avsnittet Åtkomstnycklar i registret i Azure Portal.

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Du kan få en säkerhetsvarning som rekommenderar användning av --password-stdin. Även om den bästa metoden rekommenderas för produktionsscenarier ligger den utanför omfånget för den här självstudien. Mer information finns i docker-inloggningsreferensen.

3. Använd modulens Dockerfile för att skapa och tagga docker-modulens avbildning.

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

   Om du till exempel vill skapa avbildningen för det lokala registret eller ett Azure-containerregister använder du följande kommandon:

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

Push-modul docker-avbildning

Ange dina autentiseringsuppgifter för containerregistret till Docker så att den kan skicka containeravbildningen till lagring i registret.

1. Logga in på Docker med autentiseringsuppgifterna för Azure Container Registry (ACR).

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Du kan få en säkerhetsvarning som rekommenderar användning av --password-stdin. Även om det är en rekommenderad metod för produktionsscenarier är det utanför omfånget för den här självstudien. Mer information finns i docker-inloggningsreferensen.

2. Logga in på Azure Container Registry. Du måste installera Azure CLI för att använda az kommandot. Det här kommandot frågar efter ditt användarnamn och lösenord som finns i containerregistret i Inställningar>Åtkomstnycklar.

   az acr login -n <AcrRegistryName>
   

   Dricks

   Om du loggas ut någon gång i den här självstudien upprepar du inloggningsstegen docker och Azure Container Registry för att fortsätta.

3. Skicka modulavbildningen till det lokala registret eller ett containerregister.

   docker push <ImageName>
   

   Till exempel:

   # 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
   

Uppdatera distributionsmallen

Uppdatera deployment.template.json-filen med platsen för avbilden i containerregistret. Ändra image-värdet till den image som du laddade upp till registret. Ersätt <till exempel AcrRegistryName> med ditt registernamn i avbildningsvärdena för modulerna klassificerare och kamerakapsling:

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

Det slutliga distributionsmanifestet ser ut ungefär så här:

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

Distribuera moduler till enheten

Kontrollera att byggda containeravbildningar lagras i containerregistret. Distribuera dem sedan till en enhet med hjälp av distributionsmanifestet deployment.template.json förberett för ditt scenario.

Använd kommandot IoT Edge Azure CLI set-modules för att distribuera modulerna till Azure IoT Hub. Om du till exempel vill distribuera modulerna som definierats i filendeployment.template.json till IoT Hub <IotHubName> för IoT Edge-enheten <DeviceName> använder du följande kommando. Ersätt värdena för hubbnamn, enhets-ID och inloggnings-IoT Hub-anslutningssträng med dina egna.

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

Kontrollera att din IoT Edge-enhet körs.

Under enheten expanderar du Moduler för att se en lista över distribuerade och körande moduler. Välj uppdateringsknappen. Du ser de nya modulerna klassificerare och kamerakapsling som körs tillsammans med $edgeAgent och $edgeHub.

Du kan även kontrollera att alla moduler är igång på själva enheten. Kör följande kommando på IoT Edge-enheten för att se status för modulerna.

iotedge list

Det kan ta några minuter innan modulerna startas. IoT Edge-körningen måste ta emot sitt nya distributionsmanifest, hämta modulavbildningarna från containerkörningen och starta sedan varje ny modul.

Visa klassificeringsresultat

På enheten visar du loggarna för modulen cameracapture för att se de meddelanden som skickas och bekräfta att de tas emot av IoT Hub.

iotedge logs cameracapture

Du bör till exempel se utdata som följande:

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

Resultaten från Custom Vision-modulen, som skickas som meddelanden från modulen cameracapture, inkluderar sannolikheten att bilden är ett hemlock- eller körsbärsträd. Eftersom bilden föreställer hemlock, betraktar du sannolikheten som 1,0.

Rensa resurser

Om du planerar att fortsätta till nästa rekommenderade artikel behåller du de resurser och konfigurationer som du skapade och återanvänder dem. Du kan även fortsätta att använda samma IoT Edge-enhet som en testenhet.

Annars tar du bort de lokala konfigurationerna och De Azure-resurser som du använde i den här artikeln för att undvika avgifter.

Ta bort Azure-resurser

Det går inte att ångra borttagningen av Azure-resurser och resursgrupper. Var noga så att du inte tar bort fel resursgrupp eller resurser av misstag. Om du har skapat IoT Hub i en befintlig resursgrupp som har resurser som du vill behålla tar du bara bort själva IoT Hub-resursen, inte resursgruppen.

Ta bort resurser:

1. Logga in på Azure-portalen och välj Resursgrupper.

2. Välj namnet på resursgruppen som innehåller dina IoT Edge-testresurser.

3. Granska listan över resurser som resursgruppen innehåller. Om du vill ta bort alla kan du välja Ta bort resursgrupp. Om du bara vill ta bort några av dem kan du välja varje resurs för att ta bort dem individuellt.

Nästa steg

I den här självstudien tränade du en Custom Vision-modell och distribuerade den som modul till en IoT Edge-enhet. Sedan skapade du en modul som kan köra frågor mot bildklassificeringstjänsten och rapporterar resultatet tillbaka till IoT Hub.

Fortsätt till nästa självstudier för att lära dig mer om andra sätt som Azure IoT Edge kan hjälpa dig att omvandla data till affärsinsikter på gränsen.