Esercitazione: Sviluppare moduli IoT Edge con contenitori Linux usando IoT Edge per Linux in Windows

Articolo
04/11/2024

Si applica a: IoT Edge 1.4

Importante

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

Questa esercitazione illustra lo sviluppo, il debug e la distribuzione di codice personalizzato in un dispositivo IoT Edge usando IoT Edge per Linux in Windows e Visual Studio 2022. Si apprenderà lo scenario di sviluppo più comune per le soluzioni IoT Edge distribuendo un modulo C# in un dispositivo Linux. Si distribuirà ed eseguirà il debug di un modulo Azure IoT Edge personalizzato in esecuzione in un contenitore Linux in Windows (EFLOW). Anche se si prevede di usare un linguaggio diverso o di distribuire un servizio di Azure, questa esercitazione è comunque utile per apprendere i concetti e gli strumenti di sviluppo.

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 di questo articolo per selezionare la versione dello strumento.

In questa esercitazione apprenderai a:

Configurare il computer di sviluppo.
Usare IoT Edge Tools per Visual Studio Code per creare un nuovo progetto.
Compilare il progetto come contenitore e archiviarlo in un Registro Azure Container.
Distribuire il codice in un dispositivo IoT Edge.

Prerequisiti

Questo articolo presuppone che si usi un computer che esegue Windows come computer di sviluppo. Nei computer Windows è possibile sviluppare moduli Windows o Linux. Questa esercitazione illustra lo sviluppo di contenitori Linux, usando IoT Edge per Linux in Windows per la compilazione e la distribuzione dei moduli.

Installare IoT Edge per Linux in Windows (EFLOW)
Guida introduttiva: Distribuire il primo modulo IoT Edge in un dispositivo Windows
.NET Core SDK.
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++ .

Dopo aver pronto Visual Studio 2022, sono necessari anche gli strumenti e i componenti seguenti:

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 l'interfaccia della riga di comando di Azure.

Risorse cloud:

Un hub IoT di livello Gratuito o Standard in Azure.

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

Concetti chiave

Questa esercitazione illustra in modo dettagliato le fasi di sviluppo di un modulo IoT Edge. Un modulo IoT Edge, talvolta detto semplicemente modulo, è un contenitore in cui è presente codice eseguibile. È possibile distribuire uno o più moduli in un dispositivo IoT Edge. I moduli eseguono attività specifiche, ad esempio l'inserimento di dati provenienti dai sensori, l'esecuzione di operazioni di analisi e pulizia dei dati oppure l'invio di messaggi a un hub IoT. Per altre informazioni, vedere Informazioni sui moduli Azure IoT Edge.

Quando si sviluppano moduli IoT Edge, è importante comprendere la differenza tra il computer di sviluppo e il dispositivo IoT Edge di destinazione in cui il modulo verrà distribuito. Il contenitore creato per inserire il codice dei moduli deve corrispondere al sistema operativo del dispositivo di destinazione. Ad esempio, lo scenario più comune è quello in cui si sviluppa in un computer Windows un modulo destinato a un dispositivo Linux che esegue IoT Edge. In tal caso, il sistema operativo del contenitore è Linux. Mentre si procede con questa esercitazione, tenere presente la differenza tra sistema operativo del computer di sviluppo e sistema operativo del contenitore. Per questa esercitazione si userà l'host Windows per lo sviluppo e la macchina virtuale IoT Edge per Linux in Windows (EFLOW) per la compilazione e la distribuzione dei moduli.

Questa esercitazione è destinata ai dispositivi che eseguono IoT Edge con contenitori Linux. È possibile usare il sistema operativo preferito, purché il computer di sviluppo esegua i contenitori Linux. È consigliabile usare Visual Studio per sviluppare con contenitori Linux, in modo da usare questa esercitazione. È anche possibile usare Visual Studio Code, ma ci sono alcune differenze in termini di supporto tra i due strumenti. Per altre informazioni, vedere Sviluppare moduli di Azure IoT Edge con Visual Studio Code.

Configurare docker-cli e la connessione remota del motore Docker

I moduli IoT Edge vengono inseriti in pacchetti come contenitori, quindi è necessario un motore per i contenitori nel computer di sviluppo per compilarli e gestirli. La macchina virtuale EFLOW contiene già un'istanza del motore Docker, quindi questa esercitazione illustra come connettersi in remoto dal computer per sviluppatori Windows all'istanza Docker della macchina virtuale EFLOW. Usando questo metodo, si rimuove la dipendenza da Docker Desktop per Windows.

Il primo passaggio consiste nel configurare docker-cli nel computer di sviluppo Windows per potersi connettere al motore Docker remoto.

Scaricare la versione precompilata docker.exe dell'interfaccia della riga di comando docker da Docker-cli Chocolatey. È anche possibile scaricare il progetto dell'interfaccia della riga di comando ufficiale da Docker/cli GitHub e compilarlo seguendo le istruzioni del repository.
Estrarre il docker.exe in una directory nel computer di sviluppo. Ad esempio, C:\Docker\bin
Apri Informazioni sul PC ->Informazioni di sistema ->Impostazioni di sistema avanzate
Selezionare Avanzate -Variabili di ambiente -> In Variabili utente selezionare Percorso>
Modificare la variabile Path e aggiungere il percorso del docker.exe
Aprire una sessione di PowerShell con privilegi elevati
Verificare che l'interfaccia della riga di comando di Docker sia accessibile usando il comando
```
docker --version
```

Se tutto è stato configurato correttamente, il comando precedente dovrebbe restituire la versione docker, ad esempio Docker versione 20.10.12, build e91ed57.

Il secondo passaggio consiste nel configurare il motore Docker della macchina virtuale EFLOW per accettare connessioni esterne e aggiungere le regole del firewall appropriate.

Avviso

L'esposizione del motore Docker a connessioni esterne può aumentare i rischi per la sicurezza. Questa configurazione deve essere usata solo a scopo di sviluppo. Assicurarsi di ripristinare le impostazioni predefinite della configurazione al termine dello sviluppo.

Aprire una sessione di PowerShell con privilegi elevati ed eseguire i comandi seguenti

# Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"

# Create a copy of the EFLOW VM _docker.service_ in the system folder.
Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"

# Replace the service execution line to listen for external connections.
Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g'  /etc/systemd/system/docker.service"

# Reload the EFLOW VM services configurations.
Invoke-EflowVmCommand "sudo systemctl daemon-reload"

# Reload the Docker engine service.
Invoke-EflowVmCommand "sudo systemctl restart docker.service"

# Check that the Docker engine is listening to external connections.
Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"

Di seguito è riportato l'output di esempio.

PS C:\> # Configure the EFLOW virtual machine Docker engine to accept external connections, and add the appropriate firewall rules.
PS C:\> Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 2375 -j ACCEPT"
PS C:\>
PS C:\> # Create a copy of the EFLOW VM docker.service in the system folder.
PS C:\> Invoke-EflowVmCommand "sudo cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Replace the service execution line to listen for external connections.
PS C:\> Invoke-EflowVmCommand "sudo sed -i 's/-H fd:\/\// -H fd:\/\/ -H tcp:\/\/0.0.0.0:2375/g' /etc/systemd/system/docker.service"
PS C:\>
PS C:\> # Reload the EFLOW VM services configurations.
PS C:\> Invoke-EflowVmCommand "sudo systemctl daemon-reload"
PS C:\>
PS C:\> # Reload the Docker engine service.
PS C:\> Invoke-EflowVmCommand "sudo systemctl restart docker.service"
PS C:\>
PS C:\> # Check that the Docker engine is listening to external connections.
PS C:\> Invoke-EflowVmCommand "sudo netstat -lntp | grep dockerd"
tcp6       0      0 :::2375                 :::*                    LISTEN      2790/dockerd

Il passaggio finale consiste nel testare la connessione Docker al motore Docker della macchina virtuale EFLOW. Prima di tutto, è necessario l'indirizzo IP della macchina virtuale EFLOW.
```
Get-EflowVmAddr
```
Suggerimento

Se la macchina virtuale EFLOW è stata distribuita senza IP statico, l'indirizzo IP può cambiare tra i riavvii del sistema operativo host Windows o le modifiche di rete. Assicurarsi di usare l'indirizzo IP della macchina virtuale EFLOW corretto ogni volta che si vuole stabilire una connessione remota al motore Docker.

Di seguito è riportato l'output di esempio.
```
PS C:\> Get-EflowVmAddr
[03/15/2022 15:22:30] Querying IP and MAC addresses from virtual machine (DESKTOP-J1842A1-EFLOW)
 - Virtual machine MAC: 00:15:5d:6f:da:78
 - Virtual machine IP : 172.31.24.105 retrieved directly from virtual machine
00:15:5d:6f:da:78
172.31.24.105 
```

Usando l'indirizzo IP ottenuto, connettersi al motore Docker della macchina virtuale EFLOW ed eseguire il contenitore di esempio Hello-World. Sostituire <EFLOW-VM-IP> con l'indirizzo IP della macchina virtuale EFLOW ottenuto nel passaggio precedente.

docker -H tcp://<EFLOW-VM-IP>:2375 run --rm hello-world

Si noterà che il contenitore viene scaricato e dopo verrà eseguito e restituito quanto segue.

PS C:\> docker -H tcp://172.31.24.105:2375 run --rm hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:4c5f3db4f8a54eb1e017c385f683a2de6e06f75be442dc32698c9bbe6c861edd
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Creare un progetto Azure IoT Edge

Il modello di progetto IoT Edge in Visual Studio crea una soluzione che può essere distribuita nei dispositivi IoT Edge. Prima di tutto si crea una soluzione Azure IoT Edge e quindi si genera il primo modulo in tale soluzione. Ogni soluzione IoT Edge può contenere più di un modulo.

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 .
Nella pagina Crea un nuovo progetto cercare Azure IoT Edge. Selezionare il progetto corrispondente alla piattaforma (modulo Linux IoT Edge) e all'architettura per il dispositivo IoT Edge e selezionare Avanti.
Nella pagina Configura il nuovo progetto immettere un nome per il progetto e specificare il percorso, quindi selezionare Crea.
Nella finestra Aggiungi modulo selezionare il tipo di modulo da sviluppare. È anche possibile selezionare Modulo esistente per aggiungere un modulo IoT Edge esistente alla distribuzione. Specificare il nome del modulo e il repository di immagini del modulo.
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 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 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 deployment.debug.template.json file manifesto della distribuzione. 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 deployment.debug.template.json file manifesto della distribuzione. 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",
    //...
```

Configurare l'istanza remota del motore Docker di Visual Studio 2022

Usare l'estensione degli strumenti di Azure IoT Edge e configurarla per l'uso del motore Docker remoto in esecuzione all'interno della macchina virtuale EFLOW.

Selezionare Strumenti -Strumenti di> Azure IoT Edge ->Impostazioni degli strumenti di IoT Edge...
Sostituire il valore DOCKER_HOST localhost con l'indirizzo IP della macchina virtuale EFLOW. Se non si ricorda l'indirizzo IP, usare il cmdlet Get-EflowVmAddr powerShell EFLOW per ottenerlo. Per exmaple, se l'indirizzo IP della macchina virtuale EFLOW è 172.20.1.100, il nuovo valore deve essere tcp://172.20.1.100:2375.
seleziona OK.

Sviluppare il modulo

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 altri moduli che rispondono alle esigenze chiave per soluzioni IoT, ad esempio sicurezza, gestione dei dispositivi e affidabilità.

Compilare ed eseguire il push 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. Poiché la soluzione verrà compilata o eseguita il debug usando il motore Docker in esecuzione all'interno della macchina virtuale EFLOW, il primo passaggio consiste nel compilare e pubblicare il modulo per abilitare il debug remoto.

In Esplora soluzioni selezionare ed evidenziare la cartella del progetto del modulo, ad esempio myIotEdgeModule. Impostare il modulo personalizzato come progetto di avvio. Selezionare Project Set as StartUp Project (Imposta progetto>come progetto di avvio) dal menu.
Per eseguire il debug del modulo C# Linux, è necessario aggiornare il file Dockerfile.amd64.debug per abilitare il servizio SSH. Aggiornare il file Dockerfile.amd64.debug per usare il modello seguente: Dockerfile per il modulo AMD64 C# di Azure IoT Edge con supporto di debug remoto.

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.

Avviso

Assicurarsi che l'ultima riga del modello ENTRYPOINT ["dotnet", "IotEdgeModule1.dll"] il nome della DLL corrisponda al nome del progetto del modulo IoT Edge.
Per stabilire una connessione SSH con il modulo Linux, è necessario creare una chiave RSA. Aprire una sessione di PowerShell con privilegi elevati ed eseguire i comandi seguenti per creare una nuova chiave RSA. Assicurarsi di salvare la chiave RSA nella stessa cartella del modulo IoT Edge e che il nome della chiave sia id_rsa.
```
ssh-keygen -t RSA -b 4096 -m PEM
```
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. Se si usa un registro locale, è possibile eseguire un registro locale.
```
docker -H tcp://<EFLOW-VM-IP>:2375 login -u <ACR username> -p <ACR password> <ACR login server>
```

In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella del progetto e scegliere Compila ed esegui il push dei moduli IoT Edge per compilare ed eseguire il push dell'immagine Docker per ogni modulo.
Se si usa un registro privato come Registro Azure Container, è necessario aggiungere le informazioni di accesso del registro alle impostazioni di runtime presenti nel file deployment.template.json. Sostituire i segnaposto con il nome utente amministratore, la password e il nome del registro di Registro Azure Container effettivi.
```
      "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.
È necessario esporre la porta 22 per accedere al servizio SSH del modulo. Questa esercitazione usa 10022 come porta host, ma è possibile specificare una porta diversa, che verrà usata come porta SSH per connettersi al modulo C# Linux. È necessario aggiungere le informazioni sulla porta SSH all'impostazione "createOptions" di questo modulo Linux presente nel file deployment.debug.template.json.
```
     "createOptions": {
        "HostConfig": {
           "Privileged": true,
           "PortBindings": {
                 "22/tcp": [
                    {
                       "HostPort": "10022"
                    }
                 ]
           }
        }
     }
```
In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella del progetto e scegliere Genera distribuzione per IoT Edge per compilare il nuovo json di distribuzione IoT Edge.
Aprire Cloud Explorer facendo clic su Visualizza>Cloud Explorer. Assicurarsi di aver eseguito l'accesso a Visual Studio 2019.
In Cloud Explorer espandere la sottoscrizione, trovare l'hub IoT di Azure e il dispositivo Azure IoT Edge da distribuire.
Fare clic con il pulsante destro del mouse sul dispositivo IoT Edge e scegliere Crea distribuzione. Passare al manifesto della distribuzione di debug configurato per la piattaforma che si trova nella cartella config nella soluzione Visual Studio, ad esempio deployment.amd64.json.

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 deployment.debug.template.json file manifesto della distribuzione 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 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à 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.

In Cloud Explorer fare clic con il pulsante destro del mouse sul dispositivo perimetrale e aggiornare per visualizzare il nuovo modulo in esecuzione insieme ai moduli $edgeAgent e $edgeHub .

Eseguire il debug della soluzione

L'uso e la sessione di PowerShell con privilegi elevati eseguono i comandi seguenti
1. Ottenere moduleId in base al nome usato per il modulo Linux C#. Assicurarsi di sostituire il <segnaposto iot-edge-module-name> con il nome del modulo.
```
$moduleId = Invoke-EflowVmCommand "sudo docker ps -aqf name=<iot-edge-module-name>"
```
2. Verificare che il $moduleId sia corretto: se la variabile è vuota, assicurarsi di usare il nome del modulo corretto
3. Avviare il servizio SSH all'interno del contenitore Linux
```
Invoke-EflowVmCommand "sudo docker exec -it -d $moduleId service ssh start"
```
4. Aprire la porta SSH del modulo nella macchina virtuale EFLOW (questa esercitazione usa la porta 10022)
```
Invoke-EflowVmCommand "sudo iptables -A INPUT -p tcp --dport 10022 -j ACCEPT"
```
Avviso

Per motivi di sicurezza, ogni volta che la macchina virtuale EFLOW viene riavviata, la regola della tabella IP eliminerà e tornerà alle impostazioni originali. Inoltre, il servizio SSH del modulo dovrà essere avviato di nuovo manualmente.

Dopo aver avviato correttamente il servizio SSH, selezionare Debug -Attach to Process (Debug ->Attach to Process), impostare Connessione ion Type (Tipo di connessione) su SSH e Connessione ion target (destinazione) sull'indirizzo IP della macchina virtuale EFLOW. Se non si conosce l'IP della macchina virtuale EFLOW, è possibile usare il Get-EflowVmAddr cmdlet di PowerShell. Digitare prima di tutto l'INDIRIZZO IP e quindi premere INVIO. Nella finestra popup immettere le configurazioni seguenti:

Campo	valore
Hostname (Nome host)	Usare l'IP della macchina virtuale EFLOW
Porta	10022 (oppure quello usato nella configurazione della distribuzione)
Nome utente	root
Tipo di autenticazione	Chiave privata
File di chiave privata	Percorso completo del id_rsa creato in un passaggio precedente
Passphrase	Passphrase usata per la chiave creata in un passaggio precedente

Screenshot di come connettersi a un sistema remoto

Dopo la connessione al modulo tramite SSH, è possibile scegliere il processo e selezionare Collega. Per il modulo C# è necessario scegliere il processo dotnet e Connetti a gestito (CoreCLR). La prima volta possono essere necessari da 10 a 20 secondi.
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.
L'output di SimulatedTemperatureSensor deve essere reindirizzato all'input1 del modulo C# Linux personalizzato. Il punto di interruzione deve essere attivato. È possibile controllare le variabili nella finestra Variabili locali di Visual Studio.
Premere CTRL+F5 oppure selezionare il pulsante Arresta per arrestare il debug.

Pulire le risorse

Se si intende continuare con il prossimo articolo consigliato, è possibile conservare 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, è possibile 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 l'hub IoT è stato creato all'interno di un gruppo di risorse esistente che contiene risorse che si vogliono conservare, eliminare solo la risorsa hub IoT stessa, invece dell'intero gruppo.

Per eliminare le risorse:

Accedere al portale di Azure e selezionare Gruppi di risorse.
Selezionare il nome del gruppo di risorse contenente le risorse di test di IoT Edge.
Esaminare l'elenco delle risorse contenute nel gruppo di risorse. Per eliminarle tutte, è possibile selezionare Elimina gruppo di risorse. Se se ne vogliono eliminare solo alcune, è possibile fare clic su ogni risorsa per eliminarle singolarmente.

Passaggi successivi

In questa esercitazione si configura Visual Studio nel computer di sviluppo ed è stato distribuito e sottoposto a debug il primo modulo IoT Edge. Ora che sono stati appresi i concetti di base, provare ad aggiungere funzionalità a un modulo in modo che possa analizzare i dati che passano attraverso di esso.

Sviluppare moduli di Azure IoT Edge con Visual Studio Code

Share via