Usare Visual Studio 2022 per sviluppare ed eseguire il debug di moduli per Azure IoT Edge

Articolo
04/11/2024

Si applica a: IoT Edge 1.4

Importante

IoT Edge 1.4 è la versione supportata. Se si usa una versione precedente, vedere Aggiornare IoT Edge.

Questo articolo illustra come usare Visual Studio 2022 per sviluppare, eseguire il debug e distribuire moduli personalizzati di Azure IoT Edge. Visual Studio 2022 fornisce modelli per i moduli IoT Edge scritti in C e C#. Le architetture dei dispositivi supportate sono Windows x64, Linux x64, ARM32 e ARM64 (anteprima). Per altre informazioni sui sistemi operativi, le lingue e le architetture supportate, vedere Supporto per linguaggi e architetture.

Questo articolo include i passaggi per due strumenti di sviluppo di IoT Edge.

L'interfaccia della riga di comando è lo strumento preferito per lo sviluppo.
Estensione Azure IoT Edge Tools per Visual Studio . L'estensione è in modalità di manutenzione.

Usare il pulsante del selettore dello strumento all'inizio per scegliere l'opzione dello strumento per questo articolo. Entrambi gli strumenti offrono i vantaggi seguenti:

Creare, modificare, compilare, eseguire ed eseguire il debug di soluzioni e moduli IoT Edge nel computer di sviluppo locale.
Scrivere il codice dei moduli IoT di Azure in C o C# con i vantaggi dello sviluppo di Visual Studio.
Distribuire la soluzione IoT Edge in un dispositivo IoT Edge tramite hub IoT di Azure.

Prerequisiti

Questo articolo presuppone che si usi un computer che esegue Windows come computer di sviluppo.

Installare o modificare Visual Studio 2022 nel computer di sviluppo. Scegliere le opzioni Sviluppo di Azure e Sviluppo di applicazioni desktop con carichi di lavoro C++ .
Scaricare e installare Azure IoT Edge Tools da Visual Studio Marketplace. È possibile usare l'estensione Azure IoT Edge Tools per creare e compilare la soluzione IoT Edge. Lo strumento di sviluppo preferito è lo strumento di sviluppo di Azure IoT Edge da riga di comando. L'estensione include i modelli di progetto Azure IoT Edge usati per creare il progetto di Visual Studio. Attualmente, è necessaria l'estensione installata indipendentemente dallo strumento di sviluppo usato.

Importante

L'estensione Azure IoT Edge Tools per VS 2022 è in modalità di manutenzione. Lo strumento di sviluppo preferito è lo strumento di sviluppo di Azure IoT Edge da riga di comando.

Suggerimento

Se si usa Visual Studio 2019, scaricare e installare Azure IoT Edge Tools per VS 2019 dal marketplace di Visual Studio.

Installare il gestore di librerie Vcpkg

git clone https://github.com/Microsoft/vcpkg
cd vcpkg
bootstrap-vcpkg.bat

Installare il pacchetto azure-iot-sdk-c per Windows

vcpkg.exe install azure-iot-sdk-c:x64-windows
vcpkg.exe --triplet x64-windows integrate install

Scaricare e installare un sistema di gestione contenitori compatibile con Docker nel computer di sviluppo per compilare ed eseguire le immagini del modulo. Ad esempio, installare Docker Community Edition.
Per sviluppare moduli con contenitori Linux, usare un computer Windows che soddisfi i requisiti per Docker Desktop.
Creare un Registro Azure Container o un hub Docker per archiviare le immagini del modulo.

Suggerimento

Per prototipi e test è possibile usare un registro Docker locale anziché un registro nel cloud.
Installare l'interfaccia della riga di comando di Azure.
Per testare il modulo in un dispositivo, è necessario un hub IoT attivo con almeno un dispositivo IoT Edge. Per creare un dispositivo IoT Edge per il test, è possibile crearne uno nel portale di Azure o con l'interfaccia della riga di comando:
- La creazione di una nella portale di Azure è la più rapida. Dal portale di Azure passare alla risorsa hub IoT. Selezionare Dispositivi nel menu Gestione dispositivi e quindi selezionare Aggiungi dispositivo.
  
  In Crea un dispositivo assegnare un nome al dispositivo usando l'ID dispositivo, selezionare Dispositivo IoT Edge e quindi selezionare Salva in basso a sinistra.
  
  Verificare infine che il nuovo dispositivo esista nel hub IoT dal menu Dispositivi di gestione > dei dispositivi. Per altre informazioni sulla creazione di un dispositivo IoT Edge tramite il portale di Azure, vedere Creare ed effettuare il provisioning di un dispositivo IoT Edge in Linux usando chiavi simmetriche.
- Per creare un dispositivo IoT Edge con l'interfaccia della riga di comando, seguire la procedura descritta nella guida introduttiva per Linux o Windows. Nel processo di registrazione di un dispositivo IoT Edge, si crea un dispositivo IoT Edge.
Se si esegue il daemon IoT Edge nel computer di sviluppo, potrebbe essere necessario arrestare EdgeHub e EdgeAgent prima di iniziare lo sviluppo in Visual Studio.

Creare un progetto Azure IoT Edge

Il modello di progetto IoT Edge in Visual Studio crea una soluzione da distribuire nei dispositivi IoT Edge. Creare prima di tutto una soluzione Azure IoT Edge. Creare quindi un modulo in tale soluzione. Ogni soluzione IoT Edge può contenere più di un modulo.

Nella soluzione verranno compilati tre progetti. Modulo principale che contiene EdgeAgent e EdgeHub, oltre al modulo del sensore di temperatura. Successivamente, si aggiungono altri due moduli IoT Edge.

Importante

La struttura del progetto IoT Edge creata da Visual Studio non è identica a quella di Visual Studio Code.

Attualmente, l'interfaccia della riga di comando di Azure IoT Edge Dev Tool non supporta la creazione del tipo di progetto di Visual Studio. Per creare il progetto di Visual Studio, è necessario usare l'estensione Visual Studio IoT Edge.

In Visual Studio creare un nuovo progetto in .
In Creare un nuovo progetto cercare Azure IoT Edge. Selezionare il progetto corrispondente alla piattaforma e all'architettura per il dispositivo IoT Edge e selezionare Avanti.
In Configura il nuovo progetto immettere un nome per il progetto, specificare il percorso e selezionare Crea.
In Aggiungi modulo selezionare il tipo di modulo che si vuole sviluppare. Se si dispone di un modulo esistente da aggiungere alla distribuzione, selezionare Modulo esistente.
In Nome modulo immettere un nome per il modulo. Scegliere un nome univoco all'interno del registro contenitori.
In Url repository specificare il nome del repository di immagini del modulo. Visual Studio popola automaticamente il nome del modulo con localhost:5000/<nome del modulo>. Sostituire tale valore con le proprie informazioni di registro. Usare localhost se si usa un registro Docker locale per i test. Se si usa Registro Azure Container, specificare il server di accesso indicato nelle impostazioni del registro. Il server di accesso ha un nome simile a <nome registro>.azurecr.io. Sostituire solo la parte localhost:5000 della stringa in modo che il risultato finale sia simile <al nome> del registro.azurecr.io/< nome del modulo.>
Selezionare Aggiungi per aggiungere il modulo al progetto.

Nota

Se si dispone di un progetto IoT Edge esistente, è possibile modificare l'URL del repository aprendo il file module.json . L'URL del repository si trova nella proprietà del repository del file JSON.

È ora disponibile un progetto IoT Edge e un modulo IoT Edge nella soluzione Visual Studio.

Struttura progetto

Nella soluzione sono presenti due cartelle a livello di progetto, tra cui una cartella principale del progetto e una singola cartella del modulo. Ad esempio, potrebbe essere disponibile una cartella di progetto principale denominata AzureIotEdgeApp1 e una cartella del modulo denominata IotEdgeModule1. La cartella principale del progetto contiene il manifesto della distribuzione.

La cartella del progetto del modulo contiene un file per il codice del modulo denominato Program.cs o main.c a seconda del linguaggio scelto. Questa cartella contiene anche un file denominato module.json che descrive i metadati del modulo. Diversi file Docker inclusi qui forniscono le informazioni necessarie per compilare il modulo come contenitore Windows o Linux.

Manifesto della distribuzione del progetto

Il manifesto della distribuzione modificato è denominato deployment.debug.template.json. Questo file è un modello di un manifesto di distribuzione IoT Edge che definisce tutti i moduli eseguiti in un dispositivo insieme a come comunicano tra loro. Per altre informazioni sui manifesti di distribuzione, vedere Informazioni su come distribuire i moduli e stabilire route.

Se si apre questo modello di distribuzione, si noterà che i due moduli di runtime, edgeAgent e edgeHub sono inclusi, insieme al modulo personalizzato creato in questo progetto di Visual Studio. È incluso anche un quarto modulo denominato SimulatedTemperatureSensor . Questo modulo predefinito genera dati simulati che è possibile usare per testare i moduli o eliminare se non è necessario. Per informazioni sul funzionamento del sensore di temperatura simulato, visualizzare il codice sorgente SimulatedTemperatureSensor.csproj.

Impostare la versione del runtime di IoT Edge

Attualmente, la versione più recente del runtime stabile è 1.4. È consigliabile aggiornare la versione del runtime di IoT Edge alla versione stabile più recente o alla versione di destinazione per i dispositivi.

Nella Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto principale e scegliere Imposta versione del runtime di IoT Edge.
Usare il menu a discesa per scegliere la versione di runtime in cui sono in esecuzione i dispositivi IoT Edge, quindi selezionare OK per salvare le modifiche. Se non è stata apportata alcuna modifica, selezionare Annulla per uscire.

Attualmente, l'estensione non include una selezione per le versioni di runtime più recenti. Se si vuole impostare la versione di runtime successiva alla 1.2, aprire il file manifesto della distribuzione deployment deployment.debug.template.json . Modificare la versione di runtime per le immagini del modulo di runtime di sistema edgeAgent e edgeHub. Ad esempio, se si vuole usare il runtime di IoT Edge versione 1.4, modificare le righe seguenti nel file manifesto della distribuzione:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.4"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
   //...
```
Se è stata modificata la versione, rigenerare il manifesto della distribuzione facendo clic con il pulsante destro del mouse sul nome del progetto e scegliendo Genera distribuzione per IoT Edge. In questo modo viene generato un manifesto della distribuzione basato sul modello di distribuzione e visualizzato nella cartella config del progetto di Visual Studio.

Aprire il file manifesto della distribuzione deployment deployment.debug.template.json . Il manifesto della distribuzione è un documento JSON che descrive i moduli da configurare nel dispositivo IoT Edge di destinazione.
Modificare la versione di runtime per le immagini del modulo di runtime di sistema edgeAgent e edgeHub. Ad esempio, se si vuole usare il runtime di IoT Edge versione 1.4, modificare le righe seguenti nel file manifesto della distribuzione:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.4",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.4",
    //...
```

Opzioni di sviluppo e infrastruttura dei moduli

Quando si aggiunge un nuovo modulo, viene fornito con codice predefinito pronto per la compilazione e la distribuzione in un dispositivo in modo che sia possibile avviare il test senza toccare alcun codice. Il codice del modulo si trova all'interno della cartella del modulo in un file denominato Program.cs (per C#) o main.c (per C).

La soluzione predefinita viene compilata in modo che i dati simulati del modulo SimulatedTemperatureSensor vengano indirizzati al modulo, che accetta l'input e li invia a hub IoT.

Quando si è pronti per personalizzare il modello di modulo con il proprio codice, usare gli SDK di hub IoT di Azure per compilare moduli che rispondono alle esigenze chiave per soluzioni IoT, ad esempio sicurezza, gestione dei dispositivi e affidabilità.

Eseguire il debug con il simulatore

Lo strumento di sviluppo Azure IoT EdgeHub offre un'esperienza di sviluppo e debug locale. Lo strumento consente di avviare moduli senza runtime IoT Edge, in modo da poter creare, sviluppare ed eseguire moduli e soluzioni IoT Edge in locale ed eseguirne il debug. Non è necessario eseguire il push delle immagini in un registro contenitori e distribuirli a un dispositivo per il test.

Per altre informazioni, vedere Azure IoT EdgeHub Dev Tool.

Per inizializzare lo strumento in Visual Studio:

Recuperare il stringa di connessione del dispositivo IoT Edge (disponibile nella hub IoT) dall'portale di Azure o dall'interfaccia della riga di comando di Azure.

Se si usa l'interfaccia della riga di comando per recuperare il stringa di connessione, usare questo comando, sostituendo "[device_id]" e "[hub_name]" con i propri valori:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
Dal menu Strumenti in Visual Studio selezionare Azure IoT Edge Tools>Setup IoT Edge Simulator (Configurare il simulatore IoT Edge).
Incollare il stringa di connessione e selezionare OK.

Nota

È necessario seguire questa procedura solo una volta nel computer di sviluppo, poiché i risultati vengono applicati automaticamente a tutte le soluzioni Azure IoT Edge successive. Questa procedura può essere eseguita nuovamente se è necessario usare una stringa di connessione diversa.

Compilare ed eseguire il debug di un singolo modulo

In genere, è necessario testare ed eseguire il debug di ogni modulo prima di eseguirlo all'interno di un'intera soluzione con più moduli. Lo strumento simulatore IoT Edge consente di eseguire un singolo modulo in isolamento un messaggio di invio sulla porta 53000.

In Esplora soluzioni selezionare ed evidenziare la cartella del progetto del modulo , ad esempio IotEdgeModule1. Impostare il modulo personalizzato come progetto di avvio. Selezionare Project Set as StartUp Project (Imposta progetto>come progetto di avvio) dal menu.
Premere F5 o selezionare il pulsante Esegui barra degli strumenti per avviare il simulatore IoT Edge per un singolo modulo. La prima operazione può richiedere da 10 a 20 secondi.
Se il modulo è stato inizializzato correttamente, verrà visualizzata una finestra dell'app console .NET Core.
Impostare un punto di interruzione per esaminare il modulo.
- Se si sviluppa in C#, impostare un punto di interruzione nella PipeMessage() funzione in ModuleBackgroundService.cs.
- Se si usa C, impostare un punto di interruzione nella InputQueue1Callback() funzione in main.c.
Testare il modulo inviando un messaggio. Quando si esegue il debug di un singolo modulo, il simulatore è in ascolto sulla porta predefinita 53000 per i messaggi. Per inviare un messaggio al modulo, eseguire il comando curl seguente da una shell dei comandi come Git Bash o WSL Bash.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Se viene visualizzato l'errore con parentesi graffa/parentesi graffa chiusa senza corrispondenza nell'URL, provare il comando seguente:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
Il punto di interruzione deve essere attivato. È possibile controllare le variabili nella finestra Variabili locali di Visual Studio, rilevate quando il debugger è in esecuzione. Passare a Debug variabili>locali di Windows.>

Nella shell o Bash dovrebbe essere visualizzata una {"message":"accepted"} conferma.

Nella console .NET dovrebbe essere visualizzato:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Suggerimento

È anche possibile usare PostMan o altri strumenti API per inviare messaggi invece di curl.
Premere CTRL+F5 oppure selezionare il pulsante Arresta per arrestare il debug.

Compilare ed eseguire il debug di più moduli

Dopo aver completato lo sviluppo di un modulo singolo, è possibile eseguire ed effettuare il debug di un'intera soluzione con più moduli. Lo strumento simulatore IoT Edge consente di eseguire tutti i moduli definiti nel manifesto della distribuzione, incluso un edgeHub simulato per il routing dei messaggi. In questo esempio vengono eseguiti due moduli personalizzati e il modulo del sensore di temperatura simulato. I messaggi del modulo del sensore temperatura simulato vengono instradati a ogni modulo personalizzato.

In Esplora soluzioni aggiungere un secondo modulo alla soluzione facendo clic con il pulsante destro del mouse sulla cartella principale del progetto. Scegliere Aggiungi>nuovo modulo IoT Edge dal menu.
Add module Nella finestra assegnare un nome al nuovo modulo e sostituire la localhost:5000 parte dell'URL del repository con il server di accesso Registro Azure Container, come in precedenza.
Aprire il file deployment.debug.template.json per verificare che il nuovo modulo sia stato aggiunto nella sezione modules . È stata aggiunta anche una nuova route alla sezione route in EdgeHub per inviare messaggi dal nuovo modulo a hub IoT. Per inviare dati dal sensore di temperatura simulata al nuovo modulo, aggiungere un'altra route con la riga seguente di JSON. Sostituire <NewModuleName> (in due posizioni) con il nome del modulo.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Fare clic con il pulsante destro del mouse sul progetto principale,ad esempio AzureIotEdgeApp1, quindi scegliere Imposta come progetto di avvio. Impostando il progetto principale come progetto di avvio, vengono eseguiti tutti i moduli della soluzione. Sono inclusi entrambi i moduli aggiunti alla soluzione, il modulo del sensore di temperatura simulato e l'hub edge simulato.
Premere F5 o selezionare il pulsante Esegui barra degli strumenti per eseguire la soluzione. Inizialmente potrebbero essere necessari da 10 a 20 secondi. Assicurarsi di non avere altri contenitori Docker in esecuzione che potrebbero associare la porta necessaria per questo progetto.
Verranno visualizzate due finestre dell'app console .NET Core una per ogni modulo.
Impostare un punto di interruzione per esaminare i moduli.
- Se si sviluppa in C#, impostare un punto di interruzione nella PipeMessage() funzione in ModuleBackgroundService.cs.
- Se si usa C, impostare un punto di interruzione nella InputQueue1Callback() funzione in main.c.
Creare punti di interruzione in ogni modulo e quindi premere F5 per eseguire ed eseguire il debug di più moduli contemporaneamente. Verranno visualizzate più finestre dell'app console .NET Core, con ogni finestra che rappresenta un modulo diverso.
Premere CTRL+F5 oppure selezionare il pulsante Arresta per arrestare il debug.

Compilare ed eseguire il push di immagini nel Registro di sistema

Dopo aver sviluppato e sottoposto a debug il modulo, è possibile compilare ed eseguire il push dell'immagine del modulo nell'Registro Azure Container. È quindi possibile distribuire il modulo nel dispositivo IoT Edge.

Impostare il progetto IoT Edge principale come progetto di avvio, non come uno dei singoli moduli.
Selezionare Debug o Versione come configurazione per la compilazione delle immagini del modulo.

Nota

Quando si sceglie Debug, Visual Studio usa Dockerfile.(amd64|windows-amd64).debug per compilare le immagini Docker. Ciò include VSDBG, ovvero il debugger della riga di comando di .NET Core, nell'immagine del contenitore durante la compilazione. Per i moduli IoT Edge per l'ambiente di produzione, è consigliabile usare la configurazione Versione, che usa Dockerfile.(amd64|windows-amd64) senza VSDBG.
Se si usa un registro privato come Registro Azure Container (ACR), usare il comando Docker seguente per accedervi. È possibile ottenere il nome utente e la password dalla pagina Chiavi di accesso del Registro di sistema nel portale di Azure.
```
docker login <ACR login server>
```
Aggiungere le informazioni di accesso Registro Azure Container alle impostazioni di runtime disponibili nel file deployment.debug.template.json. Per eseguire questa operazione è possibile procedere in due modi: È possibile aggiungere le credenziali del Registro di sistema al .env file (più sicuro) o aggiungerle direttamente al deployment.debug.template.json file.

Aggiungere le credenziali al .env file:

In Esplora soluzioni selezionare il pulsante della barra degli strumenti Mostra tutti i file. Viene visualizzato il .env file. Aggiungere il nome utente e la .env password Registro Azure Container al file. Queste credenziali sono disponibili nella pagina Chiavi di accesso del Registro Azure Container nella portale di Azure.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Aggiungere le credenziali direttamente a deployment.debug.template.json

Se si preferisce aggiungere le credenziali direttamente al modello di distribuzione, sostituire i segnaposto con il nome utente, la password e il nome del Registro di sistema dell'amministratore del Registro Azure Container.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Nota

Questo articolo usa le credenziali di accesso amministratore per Registro Azure Container, utili per scenari di sviluppo e test. Quando si è pronti per gli scenari di produzione, è consigliabile usare un'opzione di autenticazione con privilegi minimi, ad esempio le entità servizio. Per altre informazioni, vedere Gestire l'accesso al registro contenitori.
Se si usa un registro locale, è possibile eseguire un registro locale.
Infine, nella Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella principale del progetto e selezionare Compila ed esegui il push dei moduli IoT Edge per compilare ed eseguire il push dell'immagine Docker per ogni modulo. L'operazione potrebbe richiedere un minuto. Quando viene visualizzata Finished Build and Push IoT Edge Modules. nella console di output di Visual Studio, l'operazione è completata.

Distribuire la soluzione

Dopo aver compilato ed eseguito il push delle immagini del modulo nell'Registro Azure Container, è possibile distribuire la soluzione nel dispositivo IoT Edge. In questa esercitazione è già stato osservato un modello manifesto di distribuzione. A questo punto si genererà un manifesto della distribuzione, quindi si userà un comando dell'interfaccia della riga di comando di Azure per distribuire i moduli nel dispositivo IoT Edge in Azure.

Fare clic con il pulsante destro del mouse sul progetto principale in Visual Studio Esplora soluzioni e scegliere Genera distribuzione per IoT Edge.
Passare alla cartella principale del progetto di Visual Studio locale e cercare nella config cartella . Il percorso del file potrebbe essere simile al seguente: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Qui si trova il manifesto della distribuzione generato, deployment.amd64.debug.jsonad esempio .
Controllare il deployment.amd64.debug.json file per verificare che la edgeHub versione dello schema sia impostata su 1.2.
```
 "$edgeHub": {
     "properties.desired": {
       "schemaVersion": "1.2",
       "routes": {
         "IotEdgeModule2022ToIoTHub": "FROM /messages/modules/IotEdgeModule2022/outputs/* INTO $upstream",
         "sensorToIotEdgeModule2022": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/IotEdgeModule2022/inputs/input1\")",
         "IotEdgeModule2022bToIoTHub": "FROM /messages/modules/IotEdgeModule2022b/outputs/* INTO $upstream"
       },
       "storeAndForwardConfiguration": {
         "timeToLiveSecs": 7200
       }
     }
   }
```
Suggerimento

Il modello di distribuzione per Visual Studio 2022 richiede la versione dello schema 1.2. Se è necessario che sia 1.1 o 1.0, attendere fino a quando non viene generata la distribuzione (non modificarla in deployment.debug.template.json). La generazione di una distribuzione creerà uno schema 1.2 per impostazione predefinita. Tuttavia, è possibile modificare deployment.amd64.debug.jsonmanualmente , il manifesto generato, se necessario, prima di distribuirlo in Azure.

Importante

Dopo aver distribuito il dispositivo IoT Edge, attualmente non verrà visualizzato correttamente nella portale di Azure con schema versione 1.2 (la versione 1.1 sarà corretta). Si tratta di un bug noto e verrà risolto a breve. Tuttavia, questo non influirà sul dispositivo, perché è ancora connesso in hub IoT e può essere comunicato in qualsiasi momento usando l'interfaccia della riga di comando di Azure.
A questo punto si distribuirà il manifesto con un comando dell'interfaccia della riga di comando di Azure. Aprire il prompt dei comandi per gli sviluppatori di Visual Studio e passare alla directory config.
```
    cd config
```
Distribuire il manifesto per il dispositivo IoT Edge in hub IoT. Il comando configura il dispositivo per l'uso di moduli sviluppati nella soluzione. Il manifesto della distribuzione è stato creato nel passaggio precedente e archiviato nella cartella config . Dalla cartella config eseguire il comando di distribuzione seguente. [device id]Sostituire , [hub name]e [file path] con i valori. Se l'ID dispositivo IoT Edge non esiste nel hub IoT, deve essere creato.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Ad esempio, il comando potrebbe essere simile al seguente:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
Dopo aver eseguito il comando, verrà visualizzata una conferma della distribuzione stampata nel JSON prompt dei comandi.

Immagine Docker del modulo di compilazione

Dopo aver sviluppato il modulo, è possibile compilare l'immagine del modulo da archiviare in un registro contenitori per la distribuzione nel dispositivo IoT Edge.

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

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

Si supponga, ad esempio, che la shell dei comandi si trova nella directory del progetto e che il nome del modulo sia IotEdgeModule1. Per compilare l'immagine per il registro locale o un registro Azure Container, usare i comandi seguenti:

# Build the image for the local registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t localhost:5000/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

# Or build the image for an Azure Container Registry

docker build --rm -f "./IotEdgeModule1/Dockerfile.amd64.debug" -t myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 "./IotEdgeModule1"

Immagine Docker del modulo push

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

docker push <ImageName>

Ad esempio:

# Push the Docker image to the local registry

docker push localhost:5000/iotedgemodule1:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry
az acr login --name myacr
docker push myacr.azurecr.io/iotedgemodule1:0.0.1-amd64

Distribuire il modulo nel dispositivo IoT Edge.

In Visual Studio aprire il file manifesto della distribuzione deployment.debug.template.json nel progetto principale. Il manifesto della distribuzione è un documento JSON che descrive i moduli da configurare nel dispositivo IoT Edge di destinazione. Prima della distribuzione, è necessario aggiornare le credenziali di Registro Azure Container, le immagini del modulo e i valori appropriaticreateOptions. Per altre informazioni sui valori createOption, vedere Come configurare le opzioni di creazione di contenitori per i moduli IoT Edge.

Se si usa un Registro Azure Container per archiviare l'immagine del modulo, è necessario aggiungere le credenziali a deployment.debug.template.json nelle impostazioni di edgeAgent. ad esempio:

"modulesContent": {
"$edgeAgent": {
  "properties.desired": {
    "schemaVersion": "1.1",
    "runtime": {
      "type": "docker",
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "myacr": {
            "username": "myacr",
            "password": "<your_acr_password>",
            "address": "myacr.azurecr.io"
          }
        }
      }
    },
//...

Sostituire il valore della proprietà image con il nome dell'immagine del modulo di cui è stato eseguito il push nel Registro di sistema. Ad esempio, se è stato eseguito il push di un'immagine contrassegnata myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 per il modulo personalizzato IotEdgeModule1, sostituire il valore della proprietà image con il valore del tag.

Aggiungere o sostituire il valore createOptions con contenuto stringato per ogni modulo di sistema e personalizzato nel modello di distribuzione.

Ad esempio, l'immagine di IotEdgeModule1 e le impostazioni createOptions sono simili alle seguenti:

"IotEdgeModule1": {
"version": "1.0.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
    "image": "myacr.azurecr.io/iotedgemodule1:0.0.1-amd64",
    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}

Usare il comando set-modules dell'interfaccia della riga di comando di Azure di IoT Edge per distribuire i moduli nel hub IoT di Azure. Ad esempio, per distribuire i moduli definiti nel file deployment.debug.amd64.json in hub IoT my-iot-hub per il dispositivo IoT Edge my-device, usare il comando seguente:

az iot edge set-modules --hub-name my-iot-hub --device-id my-device --content ./deployment.debug.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Suggerimento

Le hub IoT stringa di connessione sono disponibili nella portale di Azure in hub IoT di Azure >Impostazioni>di sicurezza Criteri di accesso condiviso.

Confermare la distribuzione nel dispositivo

Per verificare che i moduli IoT Edge siano stati distribuiti in Azure, accedere al dispositivo (o alla macchina virtuale), ad esempio tramite SSH o Azure Bastion ed eseguire il comando elenco IoT Edge.

   iotedge list

Verrà visualizzato un elenco dei moduli in esecuzione nel dispositivo o nella macchina virtuale.

   NAME                        STATUS           DESCRIPTION      CONFIG
   SimulatedTemperatureSensor  running          Up a minute      mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0
   edgeAgent                   running          Up a minute      mcr.microsoft.com/azureiotedge-agent:1.2
   edgeHub                     running          Up a minute      mcr.microsoft.com/azureiotedge-hub:1.2
   IotEdgeModule1              running          Up a minute      myacr.azurecr.io/iotedgemodule1:0.0.1-amd64.debug
   myIotEdgeModule2            running          Up a minute      myacr.azurecr.io/myiotedgemodule2:0.0.1-amd64.debug

Eseguire il debug con Docker Remote SSH

I motori Docker e Moby supportano connessioni SSH ai contenitori che consentono di collegare ed eseguire il debug del codice in un dispositivo remoto usando Visual Studio.

Connessione da remoto a Docker richiede privilegi a livello radice. Seguire la procedura descritta in Gestire Docker come utente non radice per consentire la connessione al daemon Docker nel dispositivo remoto. Al termine del debug, è possibile rimuovere l'utente dal gruppo Docker.
Seguire la procedura per usare Visual Studio per connettersi a un processo in esecuzione in un contenitore Docker nel dispositivo remoto.
In Visual Studio impostare i punti di interruzione nel modulo personalizzato.
Quando viene raggiunto un punto di interruzione, è possibile esaminare le variabili, eseguire il codice ed eseguire il debug del modulo.

Passaggi successivi

Per sviluppare moduli personalizzati per i dispositivi IoT Edge, comprendere e usare gli SDK per l'hub IoT di Azure.
Per monitorare i messaggi da dispositivo a cloud (D2C) per un dispositivo IoT Edge specifico, vedere Esercitazione : Monitorare i dispositivi IoT Edge per iniziare.