Esercitazione: Eseguire la classificazione delle immagini nella rete perimetrale con il Servizio visione artificiale personalizzato

Applica a: IoT Edge 1.5

Azure IoT Edge rende le soluzioni IoT più efficienti spostando i carichi di lavoro dal cloud al perimetro. Questa funzionalità è particolarmente utile per i servizi che elaborano grandi quantità di dati, come i modelli di visione artificiale. Azure AI Custom Vision consente di creare classificatori di immagini personalizzati e di distribuirli nei dispositivi come contenitori. Insieme, questi due servizi consentono agli utenti di trovare informazioni dettagliate da immagini o flussi video senza trasferire prima tutti i dati fuori sede. Visione personalizzata fornisce un classificatore che confronta le immagini con un modello sottoposto a training per generare informazioni dettagliate.

Ad esempio, Visione personalizzata su un dispositivo IoT Edge potrebbe determinare se un'autostrada ha un traffico superiore o inferiore al normale o se un garage dispone di parcheggi disponibili in fila. Queste informazioni dettagliate possono essere condivise con un altro servizio in modo da intraprende l'azione appropriata.

In questa esercitazione verranno illustrate le procedure per:

Se non si ha un account Azure, creare un account free prima di iniziare.

Prerequisiti

• Configurare l'ambiente per lo sviluppo di contenitori Linux completando Tutorial: Sviluppare moduli IoT Edge usando Visual Studio Code con il preferito strumento di sviluppo da riga di comando Dev Tool di Azure IoT Edge. Dopo aver completato l'esercitazione, verificare che i prerequisiti seguenti siano disponibili nell'ambiente di sviluppo:

  • Un IoT Hub di livello gratuito o standard in Azure
  • Un dispositivo che esegue Azure IoT Edge con contenitori Linux. Usare i tutorial iniziali per configurare un dispositivo Linux o un dispositivo Windows.
  • Registro contenitori, ad esempio Azure Container Registry.
  • Visual Studio Code configurata con l'estensione Azure IoT Hub.
  • Scaricare e installare un sistema di gestione contenitori compatibile con Docker nel computer di sviluppo. Configurarlo per eseguire contenitori Linux.

• Per sviluppare un modulo IoT Edge con il servizio Visione personalizzata, verificare che nel computer di sviluppo siano installati i prerequisiti aggiuntivi seguenti:

  • Python
  • Git
  • Estensione di Python per Visual Studio Code

Compilare un classificatore di immagini con il Servizio visione artificiale personalizzato

Per costruire un classificatore di immagini, creare un progetto di visione personalizzata e fornire immagini di training. Per altre informazioni sui passaggi da eseguire in questa sezione, vedere Come creare un classificatore con Visione personalizzata.

Dopo aver compilato ed eseguito il training del classificatore di immagini, esportarlo come contenitore Docker e distribuirlo in un dispositivo IoT Edge.

Creare un nuovo progetto

1. Nel tuo browser web, naviga alla pagina web di Custom Vision.

2. Selezionare Accedi a e accedere con lo stesso account usato per accedere alle risorse di Azure.

3. Selezionare Nuovo progetto.

4. Creare il progetto con i valori seguenti:

   Campo	Valore
   Nome	Specificare un nome per il progetto, ad esempio EdgeTreeClassifier.
   Descrizione	Descrizione facoltativa del progetto.
   Risorsa	Selezionare uno dei gruppi di risorse Azure che include una risorsa del servizio Visione personalizzata o crea nuovo se non ne è ancora stato aggiunto uno.
   Tipi di progetto	Classificazione
   Tipi di classificazione	Multiclasse (singola etichetta per immagine)
   Domini	Generale (compatto)
   Funzionalità di esportazione	Piattaforme di base (TensorFlow, CoreML, ONNX, ...)

5. Seleziona Crea progetto.

Caricare le immagini ed eseguire il training del classificatore

Per creare un classificatore di immagini sono necessari un set di immagini di training e un set di immagini di test.

1. Clonare o scaricare immagini di esempio dal repository Cognitive-CustomVision-Windows nel computer di sviluppo locale.

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

2. Tornare al progetto di Visione personalizzata e selezionare Aggiungi immagini.

3. Passare al repository Git clonato in locale e passare alla prima cartella di immagini Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Selezionare tutte le 10 immagini nella cartella e quindi selezionare Apri.

4. Aggiungere il tag hemlock a questo gruppo di immagini, e poi premere INVIO per applicare il tag.

5. Selezionare Carica 10 file.

   

6. Quando le immagini vengono caricate correttamente, selezionare Fine.

7. Selezionare di nuovo Aggiungi immagini .

8. Passare alla seconda cartella immagine, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Selezionare tutte le 10 immagini nella cartella e quindi Apri.

9. Aggiungere il tag japanese cherry a questo gruppo di immagini e premere INVIO per applicare il tag.

10. Selezionare Carica 10 file. Quando le immagini vengono caricate correttamente, selezionare Fine.

11. Dopo aver aggiunto tag e caricato entrambi i set di immagini, selezionare Esegui training per eseguire il training del classificatore.

Esportare il classificatore

1. Dopo il training del classificatore, selezionare Esporta nella pagina Prestazioni del classificatore.

   

2. Selezionare DockerFile per la piattaforma.

3. Selezionare Linux per la versione.

4. Selezionare Esporta.

5. Al termine dell'esportazione, selezionare Scarica e salvare il pacchetto .zip in locale nel computer. Estrarre tutti i file dal pacchetto. Usare questi file per creare un modulo IoT Edge che contiene il server di classificazione delle immagini.

A questo punto la creazione e il training del progetto Visione personalizzata sono terminati. I file esportati verranno usati nella sezione successiva, ma non occorre più usare la pagina Web Visione personalizzata.

Creare una soluzione IoT Edge

Sono ora disponibili i file per una versione contenitore del classificatore di immagini nel computer di sviluppo. In questa sezione viene configurato il contenitore del classificatore di immagini da eseguire come modulo di IoT Edge. Si crea anche un secondo modulo che invia richieste al classificatore e invia i risultati come messaggi a IoT Hub.

Creare una nuova soluzione

Una soluzione è un modo logico per sviluppare e organizzare più moduli per una singola distribuzione IoT Edge. Una soluzione contiene il codice per uno o più moduli e il manifesto della distribuzione che dichiara come configurarli in un dispositivo IoT Edge. Creare la soluzione usando lo strumento della riga di comando di sviluppo Azure IoT Edge Dev Tool. Il modo più semplice per usare lo strumento consiste nel Eseguire il contenitore di sviluppo IoT Edge con Docker.

1. Creare una directory denominata classificatore e passare alla directory .

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Eseguire il comando init dello strumento iotedgedev per creare una nuova soluzione IoT Edge. Nel contenitore IoT Edge Dev immettere il comando seguente:

   iotedgedev solution init --template python --module classifier
   

   Lo script init della soluzione iotedgedev richiede di completare diversi passaggi, tra cui:

   • Eseguire l'autenticazione per Azure
   • Scegliere una sottoscrizione Azure
   • Scegliere o creare un gruppo di risorse
   • Scegliere o creare un Azure IoT Hub
   • Scegliere o creare un dispositivo Azure IoT Edge

   Il comando crea una nuova soluzione di IoT Edge con un modulo denominato classifier nella directory di lavoro corrente.

3. Aprire la soluzione in Visual Studio Code.

Aggiungere il classificatore di immagini

Il modello di modulo Python in Visual Studio Code contiene codice di esempio che è possibile eseguire per testare IoT Edge. Questo codice non verrà usato in questo scenario. Usare invece la procedura descritta in questa sezione per sostituire il codice di esempio con il contenitore del classificatore di immagini esportato in precedenza.

1. In Esplora file passare al pacchetto di Visione personalizzata precedentemente scaricato ed estratto. Copiare tutto il contenuto del pacchetto estratto. Devono essere due cartelle, app e azureml e due file, Dockerfile e README.

2. In Esplora risorse, passare alla directory che hai indicato a Visual Studio Code per creare la soluzione IoT Edge.

3. Aprire la cartella del modulo classifier. Se sono stati usati i nomi suggeriti nella sezione precedente, la struttura di cartelle è simile a CustomVisionSolution/modules/classifier.

4. Incollare i file nella cartella del classificatore .

5. Tornare alla finestra di Visual Studio Code. Ora l'area di lavoro della soluzione dovrebbe mostrare i file del classificatore di immagini nella cartella dei moduli.

6. Sostituire il file Dockerfile.amd64 originale con Dockerfile dal pacchetto di visione personalizzata, eliminando il Dockerfile.amd64 originale e rinominando in Dockerfile.amd64 il file Dockerfile.

7. Salvare le modifiche.

Creare un modulo di videocamera simulata

In una distribuzione di visione personalizzata reale, una fotocamera fornisce immagini live o flussi video. Per questo scenario si simulerà la videocamera compilando un modulo che invia un'immagine di test al classificatore di immagini.

In questa sezione si aggiungerà un nuovo modulo alla stessa CustomVisionSolution e si specificherà il codice per creare la videocamera simulata.

1. Usare lo strumento iotedgedev per aggiungere un nuovo modulo alla soluzione. Il comando crea una nuova cartella denominata cameracapture nella cartella modules della soluzione.

   iotedgedev solution add --template python cameracapture
   

2. Aprire il file main.py nella cartellacameracapture / .

3. Sostituire l'intero file con il codice seguente. Questo codice di esempio invia richieste POST al servizio di elaborazione delle immagini in esecuzione nel modulo classifier. Questo contenitore di modulo viene fornito con un'immagine di esempio da usare nelle richieste. Confeziona quindi la risposta come messaggio per IoT Hub e lo invia in una coda di output.

   # 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. Salvare il file main.py .

5. Aprire il file requirements.txt .

6. Aggiungere una nuova riga per una libreria da includere nel contenitore.

   requests
   

7. Salvare il file requirements.txt .

Aggiungere un'immagine di test al contenitore

Invece di usare una videocamera reale per fornire un feed di immagini per questo scenario, si userà una singola immagine di test. Un'immagine di test è inclusa nel repository GitHub che hai scaricato in precedenza per le immagini di training in questa esercitazione.

1. Accedere all'immagine di test situata in Cognitive-CustomVision-Windows / Samples / Images / Test.

2. Copia test_image.jpg

3. Passare alla directory della soluzione IoT Edge e incollare l'immagine di test nella cartella modules / cameracapture. L'immagine dovrebbe essere nella stessa cartella del file main.py modificato nella sezione precedente.

4. In Visual Studio Code aprire il file Dockerfile.amd64 per il modulo cameracapture.

5. Dopo la riga che stabilisce la directory di lavoro, WORKDIR /app, aggiungere la riga di codice seguente:

   ADD ./test_image.jpg .
   

6. Salvare il Dockerfile.

Preparare un manifesto di distribuzione

Finora in questo tutorial, hai addestrato un modello di visione personalizzato per classificare le immagini di alberi e hai confezionato quel modello come modulo IoT Edge. È stato quindi creato un secondo modulo che esegue una query sul server di classificazione delle immagini e ne segnala i risultati a IoT Hub. A questo punto, è possibile creare il manifesto della distribuzione che indica a un dispositivo IoT Edge come avviare ed eseguire questi due moduli insieme.

L'estensione IoT Edge per Visual Studio Code fornisce un modello in ogni soluzione IoT Edge per creare un manifesto della distribuzione.

1. Aprire il file deployment.template.json nella cartella della soluzione.

2. Impostare le credenziali del Registro di sistema per i moduli nel manifesto della distribuzione.

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

   Sostituire <registryName> con il nome del registro contenitori Azure, e sostituire <AcrUsername> e <AcrPassword> con il nome utente e la password del registro. Questi valori sono disponibili nella sezione chiavi Access del registro contenitori Azure nel portale di Azure.

3. Trovare la sezione moduli , che contiene tre moduli: i due creati, classificatori e cameracapture e un terzo incluso per impostazione predefinita , tempSensor.

4. Eliminare il modulo tempSensor con tutti i relativi parametri. Questo modulo fornisce dati di esempio per gli scenari di test, ma non è necessario in questa distribuzione.

5. Se è stato assegnato un nome al modulo di classificazione delle immagini diverso da classificatore, controllare il nome e assicurarsi che sia tutto in minuscolo. Il modulo cameracapture chiama il modulo di classificazione usando una libreria di richieste che formatta tutte le richieste in lettere minuscole e IoT Edge fa distinzione tra maiuscole e minuscole.

6. Per ogni modulo di sistema edgeAgent e edgeHub, modificare il valore createOptions in una versione stringata. Per esempio:

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

7. Per ogni modulo di sistema edgeAgent e edgeHub, modificare la versione dell'immagine alla versione 1.5 più recente. Per esempio:

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

8. Aggiornare il parametro createOptions per il modulo di classificazione a una versione stringata. Per esempio:

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

9. Aggiornare il parametro createOptions per il modulo cameracapture con il codice JSON seguente. Queste informazioni creano nel contenitore di moduli le variabili di ambiente recuperate nel processo main.py. L'inclusione di queste informazioni nel manifesto della distribuzione consente di modificare l'immagine o l'endpoint senza ricompilare l'immagine del modulo.

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

   Se è stato assegnato un nome al modulo Visione personalizzata diverso dal classificatore, aggiornare il valore dell'endpoint di elaborazione delle immagini in modo che corrisponda.

   Ad esempio, la configurazione del classificatore e della fotocameracapture dovrebbe essere simile alla seguente:

   "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. Salvare il file deployment.template.json .

Sviluppare e inviare una soluzione IoT Edge

Dopo aver creato entrambi i moduli e configurato il modello del manifest di distribuzione, costruire le immagini del contenitore ed eseguire il push nel registro dei contenitori.

Una volta che le immagini si trovano nel Registro di sistema, è possibile distribuire la soluzione in un dispositivo IoT Edge. È possibile impostare moduli in un dispositivo tramite il IoT Hub. In questa sezione viene configurato l'accesso al IoT Hub quindi si usa Azure CLI per distribuire la soluzione nel dispositivo IoT Edge.

Prima di tutto, compilare ed eseguire il push della soluzione nel registro contenitori.

1. Aprire il terminale integrato Visual Studio Code selezionando View>Terminal.

2. Accedere a Docker immettendo il comando seguente nel terminale usando il nome utente, la password e il server di accesso dal registro contenitori Azure. È possibile recuperare questi valori dalla sezione Chiavi di accesso del Registro di sistema nel portale di Azure.

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

   Potrebbe venire visualizzato un avviso di sicurezza in cui si consiglia l'uso di --password-stdin. Sebbene si tratti di una procedura consigliata per gli scenari di produzione, esula dell'ambito di questa esercitazione. Per ulteriori informazioni, vedere il riferimento docker login.

3. Usare il Dockerfile del modulo per compilare e contrassegnare l'immagine Docker del modulo.

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

   Ad esempio, per compilare l'immagine per il registro locale o un registro contenitori Azure, usare i comandi seguenti:

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

Immagine Docker del modulo push

Fornire a Docker le credenziali del Registro Container, per consentire il push dell'immagine del contenitore da archiviare nel registro.

1. Accedere a Docker con le credenziali di Azure Container Registry (ACR).

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

   Potrebbe venire visualizzato un avviso di sicurezza in cui si consiglia l'uso di --password-stdin. Sebbene si tratti di una procedura consigliata per gli scenari di produzione, esula dell'ambito di questa esercitazione. Per ulteriori informazioni, vedere il riferimento docker login.

2. Accedere al Azure Container Registry. È necessario Installare Azure CLI per usare il comando az. Questo comando chiede il nome utente e la password trovati nel registro contenitori in Impostazioni>Chiavi di accesso.

   az acr login -n <AcrRegistryName>
   

   Suggerimento

   Se si è disconnessi in qualsiasi momento durante questa esercitazione, ripetere i passaggi di accesso a Docker e Azure Container Registry per continuare.

3. Eseguire il push dell'immagine del modulo nel registro locale o in un registro contenitori.

   docker push <ImageName>
   

   Per esempio:

   # 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
   

Aggiornare il modello di distribuzione

Aggiornare il file deployment.template.json con il percorso dell'immagine nel registro dei contenitori. Modificare il valore dell'immagine nell'immagine che hai caricato nel registro. Ad esempio, sostituire <AcrRegistryName> con il nome del registro nei valori image per il classificatore e i moduli cameracapture:

"classifier": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    },
    "cameracapture": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
            "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
        }
    }
}

Il manifesto della distribuzione finale è simile al seguente:

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

Distribuire i moduli nel dispositivo

Verificare che le immagini dei container costruite siano archiviate nel registro dei container. Quindi, distribuirli in un dispositivo usando il manifesto della distribuzione deployment.template.json preparato per lo scenario.

Usare il comando IoT Edge Azure CLI set-modules per distribuire i moduli nel Azure IoT Hub. Ad esempio, per distribuire i moduli definiti nel file deployment.template.json in IoT Hub <IotHubName> per il dispositivo IoT Edge <DeviceName>, usare il comando seguente. Sostituire i valori di hub-name, device-id e login nella stringa di connessione IoT Hub con i propri.

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

Verificare che il dispositivo IoT Edge sia in esecuzione.

Nel dispositivo espandere Moduli per visualizzare un elenco di moduli distribuiti ed in esecuzione. Selezionare il pulsante Aggiorna. Vedi i nuovi moduli classifier e cameracapture in esecuzione insieme a $edgeAgent e $edgeHub.

È anche possibile verificare che tutti i moduli siano operativi nel dispositivo. Nel dispositivo IoT Edge eseguire il comando seguente per visualizzare lo stato dei moduli.

iotedge list

L'avvio dei moduli potrebbe richiedere alcuni minuti. Il runtime IoT Edge deve ricevere il manifesto di distribuzione aggiornato, scaricare le immagini dei moduli dall'ambiente di runtime del contenitore, quindi avviare ciascun modulo.

Visualizzare i risultati della classificazione

Nel dispositivo visualizzare i log del modulo cameracapture per visualizzare i messaggi inviati e verificare che vengano ricevuti da IoT Hub.

iotedge logs cameracapture

Ad esempio, verrà visualizzato un output simile al seguente:

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

I risultati del modulo Visione personalizzata, inviati come messaggi dal modulo cameracapture, includono la probabilità che l'immagine sia un hemlock o un albero ciliegio. Poiché l'immagine è hemlock, la probabilità viene visualizzata come 1,0.

Pulire le risorse

Se si prevede di continuare con l'articolo consigliato successivo, mantenere le risorse e le configurazioni create e riutilizzarle. È anche possibile continuare a usare lo stesso dispositivo IoT Edge di un dispositivo di test.

In caso contrario, eliminare le configurazioni locali e le risorse Azure usate in questo articolo per evitare addebiti.

Eliminare Azure risorse

Non è possibile annullare l'eliminazione di Azure risorse e gruppi di risorse. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se è stato creato il IoT Hub all'interno di un gruppo di risorse esistente con risorse da conservare, eliminare solo la risorsa IoT Hub stessa, non il gruppo di risorse.

Per eliminare le risorse:

1. Accedere al portale di Azure e quindi selezionare Gruppi di risorse.
2. Selezionare il nome del gruppo di risorse che contiene le risorse di test IoT Edge.
3. Esaminare l'elenco delle risorse contenute nel gruppo di risorse. Per eliminarli tutti, è possibile selezionare Elimina gruppo di risorse. Se si vogliono eliminare solo alcuni di essi, selezionare ogni risorsa per eliminarle singolarmente.

Passaggi successivi

In questa esercitazione è stato eseguito il training di un modello di Visione personalizzata e distribuito come modulo in un dispositivo IoT Edge. È stato quindi creato un modulo in grado di eseguire query sul servizio di classificazione delle immagini e segnalarne i risultati a IoT Hub.

Continuare con le esercitazioni successive per informazioni su altri modi in cui Azure IoT Edge consente di trasformare i dati in informazioni aziendali dettagliate al perimetro.