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

Si applica a: 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. Visione personalizzata di Intelligenza artificiale di Azure 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 in un dispositivo IoT Edge potrebbe determinare se un'autostrada ha 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 apprenderai a:

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Prerequisiti

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

  • Un hub IoT di livello gratuito o standard in Azure
  • Un dispositivo che esegue Azure IoT Edge con contenitori Linux. Usare le guide introduttive per configurare un dispositivo Linux o un dispositivo Windows.
  • Un registro contenitori, ad esempio Registro Azure Container.
  • Visual Studio Code configurato 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:

  • Pitone
  • Git
  • Estensione 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.

Crea un nuovo progetto

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

2. Selezionare Accedi 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.
   Conto risorse	Selezionare uno dei gruppi di risorse di Azure che include una risorsa del servizio Visione personalizzata o crearne uno nuovo se non ne è ancora stato aggiunto uno.
   Project Types (Tipi di progetto)	Classificazione
   Classification Types (Tipi di classificazione)	Multiclasse (singola etichetta per immagine)
   Domini	Generale (compatto)
   Funzionalità di esportazione	Piattaforme di base (TensorFlow, CoreML, ONNX, ...)

5. Selezionare 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. Accedi al repository Git clonato in locale e successivamente alla prima cartella delle 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 IoT Edge. Si crea anche un secondo modulo che invia richieste al classificatore e invia i risultati come messaggi all'hub IoT.

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 di distribuzione che dichiara come configurarli in un dispositivo IoT Edge. Creare la soluzione utilizzando lo strumento di sviluppo CLI di Azure IoT Edge Dev Tool. Il modo più semplice per usare lo strumento consiste nell'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 Docker per sviluppatori IoT Edge immettere il comando seguente:

   iotedgedev solution init --template python --module classifier
   

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

   • Autenticazione con Azure
   • Scegliere una sottoscrizione Azure
   • Scegliere o creare un gruppo di risorse
   • Scegliere o creare un hub IoT di Azure
   • Scegliere o creare un dispositivo Azure IoT Edge

   Il comando crea una nuova soluzione IoT Edge con un modulo denominato classificatore 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 del codice di esempio che può essere eseguito 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 file passare alla directory in cui si è indicato a Visual Studio Code di 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. Salva 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 cartellacameracapturedei moduli / .

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. Il codice crea quindi un pacchetto della risposta come messaggio dell'hub IoT e lo invia a 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 precedentemente scaricato per le immagini di training in questa esercitazione.

1. Vai 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 cartellacameracapturedei moduli / . 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 questa esercitazione è stato addestrato un modello di visione personalizzata per classificare le immagini degli alberi e creare un pacchetto del 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 all'hub IoT. 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 che semplifica la creazione di un manifesto di 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 Azure Container e sostituire <AcrUsername> e <AcrPassword> con il nome utente e la password per il registro. Questi valori sono disponibili nella sezione Chiavi di accesso del Registro Azure Container 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 .

Eseguire la compilazione e il push della 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 inserite le immagini nel registro, è possibile distribuire la soluzione in un dispositivo IoT Edge. È possibile impostare moduli in un dispositivo tramite l'hub IoT. In questa sezione viene configurato l'accesso all'hub IoT e quindi si usa l'interfaccia della riga di comando di Azure 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 di Visual Studio Code selezionando Visualizza>terminale.

2. Accedere a Docker immettendo il comando seguente nel terminale usando il nome utente, la password e il server di accesso dal Registro Azure Container. È 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, consultare la documentazione di riferimento di 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 Azure Container, 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 del Registro Azure Container.

   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, consultare la documentazione di riferimento di docker login.

2. Accedere al Registro Azure Container. È necessario installare l'interfaccia della riga di comando di Azure per usare il comando az. Questo comando richiede 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 di questa esercitazione, ripetere i passaggi di accesso a Docker e Registro Azure Container 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": {
          "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
        }
      }
    }
  }
}

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 set-modules dell'interfaccia della riga di comando di Azure di IoT Edge per distribuire i moduli nell'hub IoT di Azure. Ad esempio, per distribuire i moduli definiti nel file deployment.template.json nell'hub <IoT IotHubName> per il dispositivo <IoT Edge DeviceName>, usare il comando seguente. Sostituire i valori della stringa di connessione dell'hub IoT hub-name, device-id e account di accesso 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 questo comando per visualizzare lo stato dei moduli.

iotedge list

L'avvio dei moduli potrebbe richiedere alcuni minuti. Il runtime IoT Edge deve ricevere il nuovo manifesto della distribuzione, eseguire il pull delle immagini dei moduli dal runtime del contenitore e quindi avviare ogni nuovo modulo.

Visualizzare i risultati della classificazione

Nel dispositivo visualizzare i log del modulo cameracapture per visualizzare i messaggi inviati e verificare che vengano ricevuti dall'hub IoT.

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 come dispositivo di test.

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

Eliminare le risorse di Azure

L'eliminazione delle risorse e dei gruppi di risorse di Azure è irreversibile. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se è stato creato l'hub IoT all'interno di un gruppo di risorse esistente con risorse da mantenere, eliminare solo la risorsa dell'hub IoT 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 contenente le risorse di test di IoT Edge.

3. Esaminare l'elenco delle risorse contenute nel gruppo di risorse. Per eliminarli tutti, è possibile selezionare Elimina gruppo di risorse. Se se ne vogliono eliminare solo alcune, è possibile selezionare ogni risorsa per eliminarle singolarmente.

Passaggi successivi

In questa esercitazione è stato eseguito il training di un modello di Visione personalizzata, che è stato poi distribuito come modulo in un dispositivo IoT Edge. Si è poi compilato un modulo in grado di eseguire query sul server di classificazione delle immagini e riportarne i risultati all'hub IoT.

Continuare con le esercitazioni successive per ottenere informazioni sugli altri modi in cui Azure IoT Edge può contribuire alla trasformazione dei dati in informazioni dettagliate aziendali nei dispositivi perimetrali.