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

Articolo
08/01/2024

Si applica a: IoT Edge 1.5 IoT Edge 1.4

Importante

IoT Edge 1.5 LTS e IoT Edge 1.4 LTS sono versioni supportate. IoT Edge 1.4 LTS raggiungerà il fine vita il 12 novembre 2024. Se si usa una versione precedente, vedere Aggiornare IoT Edge.

Questo articolo illustra come usare Visual Studio 2022 per sviluppare, eseguire il debug e implementare 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, i linguaggi e le architetture supportate, vedere Supporto di 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 di 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:

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

Prerequisiti

Questo articolo presuppone che si usi un computer 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 è la riga di comando (CLI) Azure IoT Edge Dev Tool. 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 è la riga di comando (CLI) Azure IoT Edge Dev Tool.

Suggerimento

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

Installare il manager della libreria 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 Docker Hub 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:
- Crearne uno nel portale di Azure è la soluzione 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 nell'hub IoT dal menu Gestione dispositivi> Dispositivi. Per altre informazioni sulla creazione di un dispositivo IoT Edge tramite il portale di Azure, leggere 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 di IoT Edge nel computer di sviluppo, potrebbe essere necessario arrestare EdgeHub ed 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.

Avviso

L'estensione Azure IoT Edge Tools per Visual Studio non contiene i modelli di progetto per i moduli C e C#. Microsoft sta lavorando per risolvere il problema. Se non è possibile creare moduli IoT Edge usando l'estensione, usare la soluzione alternativa seguente.

Scaricare i file seguenti e inserirli nella directory dei modelli di Visual Studio elencati:

File del modello	Aggiungi alla directory
azureiotedgemodule-v0.0.4.zip	`%userprofile%\Documents\Visual Studio 2022\Templates\ProjectTemplates\Visual C#`
azureiotedgevcmodulevs17-v0.0.9.zip	`%userprofile%\Documents\Visual Studio 2022\Templates\ProjectTemplates\Visual C++ Project`

Nella soluzione verranno compilati tre progetti. Il 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 creato da Visual Studio è diversa rispetto a quella in 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 progettocercare 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 a *<nome 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. Vari 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.5. È consigliabile aggiornare la versione del runtime di IoT Edge alla versione stabile più recente o alla versione di destinazione per i dispositivi.

In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto principale e selezionare Impostare la 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.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.5, modificare le righe seguenti nel file manifesto della distribuzione:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.5"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   //...
```
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.debug.template.json. Un manifesto di distribuzione è un documento JSON che descrive i moduli da configurare nei dispositivi 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.5, modificare le righe seguenti nel file manifesto della distribuzione:
```
"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
    //...
```

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 all'hub IoT.

Quando si è pronti per personalizzare il modello del modulo con il proprio codice, usare gli SDK per l'hub IoT di Azure per compilare moduli che rispondono alle esigenze chiave delle soluzioni IoT quali 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 la stringa di connessione del dispositivo IoT Edge (disponibile nell'hub IoT) dal portale di Azure o dall'interfaccia della riga di comando di Azure.

Se si usa l'interfaccia della riga di comando per recuperare la 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>Configurare il simulatore IoT Edge.
Incollare la 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, è consigliabile 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 soluzioniselezionare ed evidenziare la cartella del progetto del modulo, ad esempio IotEdgeModule1. Impostare il modulo personalizzato come progetto di avvio. Selezionare Progetto>Imposta 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. Inizialmente possono essere necessari da 10 a 20 secondi.
Si noterà che appare una finestra dell'app della console .NET Core se il modulo è stato inizializzato correttamente.
Impostare un punto di interruzione per esaminare il modulo.
- Se si sviluppa in C#, impostare un punto di interruzione nella funzione PipeMessage() 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 oWSL 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 singola o doppia 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 Locali di Visual Studio, rilevate quando il debugger è in esecuzione. Passare a Eseguire il debug>Windows>Locali.

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

Nella console .NET dovrebbe essere visualizzato:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
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. Dal menu scegliere Aggiungi>Nuovo modulo IoT Edge.
Nella finestra Add module assegnare un nome al nuovo modulo e sostituire la parte localhost:5000 dell'URL del repository con il server di accesso del Registro Azure Container, come in precedenza.
Aprire il file deployment.debug.template.json per verificare che il nuovo modulo sia stato aggiunto nella sezione Moduli. È stata aggiunta anche una nuova route alla sezione route in EdgeHub per inviare messaggi dal nuovo modulo all'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) e selezionare 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 si potrebbero associare alla porta necessaria per questo progetto.
Verranno visualizzate due finestre dell'app della 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 funzione PipeMessage() in ModuleBackgroundService.cs.
- Se si usa C, impostare un punto di interruzione nella InputQueue1Callback() funzione in main.c.
Creare i punti di interruzione in ofgni modulo e quindi premere F5 per eseguire ed effettuare il debug di più moduli contemporaneamente. Si dovrebbero vedere più finestre dell'app della console .NET Core, ognuna delle quali 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 nel Registro Azure Container. È 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 l'accesso. È possibile ottenere il nome utente e la password dalla pagina chiavi di accesso del registro nel portale di Azure.
```
docker login <ACR login server>
```
Aggiungere le informazioni di accesso del 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 file .env (più sicuro) o aggiungerle direttamente al file deployment.debug.template.json.

Aggiungere le credenziali al .env file:

In Esplora soluzioniselezionare il pulsante della barra degli strumenti Mostra tutti i file. Viene visualizzato il file .env. Aggiungere il nome utente e la password del Registro Azure Container al file .env. Queste credenziali sono disponibili nella pagina Chiavi di accesso del Registro Azure Container nel 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, in Esplora soluzioni, fare clic con il pulsante destro del mouse sulla cartella del progetto principale e scegliere 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 nel Registro Azure Container, è possibile implementare la soluzione nel dispositivo IoT Edge. In questa esercitazione è già stato analizzato un modello del 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 implementare i moduli nel dispositivo IoT Edge in Azure.

Fare clic con il pulsante destro del mouse sul progetto principale in Esplora soluzioni di Visual Studio e scegliere Genera distribuzione per IoT Edge.
Passare alla cartella principale del progetto di Visual Studio locale e cercare nella cartella config. 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, ad esempio deployment.amd64.debug.json.
Controllare il file deployment.amd64.debug.json per verificare che la versione dello schema edgeHub 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 manualmente deployment.amd64.debug.json, il manifesto generato, se necessario, prima di distribuirlo in Azure.

Importante

Dopo aver distribuito il dispositivo IoT Edge, attualmente non verrà visualizzato correttamente nel 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 nell'hub IoT e si può comunicare con esso in qualsiasi momento usando l'interfaccia della riga di comando di Azure.
A questo punto si implementerà 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
```
Implementare il manifesto per il dispositivo IoT Edge nell'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. Sostituire [device id], [hub name] e [file path] con i propri valori. Se l'ID dispositivo IoT Edge non esiste nell'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 in JSON nel 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. Un manifesto di distribuzione è un documento JSON che descrive i moduli da configurare nei dispositivi IoT Edge di destinazione. Prima della distribuzione, è necessario aggiornare le credenziali del Registro Azure Container, le immagini del modulo e i valori createOptions appropriati. 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 per deployment.debug.template.json nelle impostazioni 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à immagine 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, le impostazioni immagine e createOptions di IotEdgeModule1 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 nell'hub IoT di Azure. Ad esempio, per distribuire i moduli definiti nel file deployment.debug.amd64.json nell'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

È possibile trovare la stringa di connessione dell'hub IoT nel portale di Azure in >Impostazioni di sicurezza>Criteri di accesso condiviso dell’hub IoT di Azure.

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 usando Docker Remote SSH

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

La connessione da remoto a Docker richiede privilegi a livello root. Seguire la procedura descritta in Gestire Docker come utente non root 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 punti di interruzione nel modulo personalizzato.
Quando viene raggiunto un punto di interruzione, è possibile ispezionare le variabili, scorrere 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.

Condividi tramite