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

Articolo
10/23/2024

Si applica a: IoT Edge 1.4

Importante

Azure IoT Edge 1.5 LTS e IoT Edge 1.4 sono versioni supportate. IoT Edge 1.4 LTS sta raggiungendo la fine del servizio il 12 novembre 2024. Se si usa una versione precedente, vedere Aggiornare IoT Edge.

Questa esercitazione illustra come sviluppare, eseguire il debug e distribuire codice personalizzato in un dispositivo Azure 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 IoT Edge personalizzato in esecuzione in un contenitore Linux in Windows. Anche se si prevede di usare un linguaggio diverso o distribuire un servizio di Azure, questa esercitazione è comunque utile per apprendere gli strumenti e i concetti di sviluppo.

Questa esercitazione include i passaggi per due strumenti di sviluppo di IoT Edge:

Interfaccia della riga di comando dell'interfaccia della riga di comando dello strumento di sviluppo di Azure IoT Edge, che è lo strumento preferito per lo sviluppo
Estensione Azure IoT Edge Tools per Visual Studio, in modalità di manutenzione

Usare il pulsante del selettore all'inizio di questa esercitazione per selezionare la versione dello strumento.

In questa esercitazione apprenderai a:

Configurare il computer di sviluppo.
Usare gli strumenti di sviluppo di IoT Edge 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

Questa esercitazione 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.

Prima di iniziare:

Installare IoT Edge per Linux in Windows.
Leggere la guida introduttiva Distribuire il primo modulo IoT Edge in un dispositivo Windows.
Scaricare .NET Core SDK.
Installare o modificare Visual Studio 2022 nel computer di sviluppo. Scegliere le opzioni del carico di lavoro Sviluppo di Azure e Sviluppo di applicazioni desktop con C++ .
Dopo aver pronto l'installazione di Visual Studio 2022, 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 è l'interfaccia della riga di comando di Azure IoT Edge Dev Tool. L'estensione include i modelli di progetto azure IoT Edge usati per creare il progetto di Visual Studio. Attualmente, è necessario installare l'estensione indipendentemente dallo strumento di sviluppo usato.

Suggerimento

Se si usa Visual Studio 2019, scaricare e installare Azure IoT Edge Tools per Visual Studio 2019 da Visual Studio Marketplace.

Installare l'interfaccia della riga di comando di Azure.

Creare un hub IoT gratuito o standard in Azure come risorsa cloud.

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

Concetti chiave

Questa esercitazione illustra lo sviluppo di un modulo IoT Edge. Un modulo IoT Edge è un contenitore con 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 verrà distribuito il modulo. Il contenitore creato per inserire il codice dei moduli deve corrispondere al sistema operativo del dispositivo di destinazione.

Ad esempio, lo scenario più comune è uno sviluppatore di un modulo in un computer Windows che intende usare come destinazione 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 IoT Edge per Linux in una macchina virtuale Windows 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, anche se esistono differenze nel supporto tra i due strumenti. Per altre informazioni, vedere Sviluppare moduli di Azure IoT Edge con Visual Studio Code.

Configurare l'interfaccia della riga di comando di Docker e il motore Docker per la connessione remota

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.

IoT Edge per Linux nella macchina virtuale Windows contiene già un'istanza del motore Docker. Questa esercitazione illustra come connettersi in remoto dal computer per sviluppatori Windows all'istanza docker di IoT Edge per Linux in macchine virtuali Windows. Usando questa connessione remota, si rimuove la dipendenza da Docker Desktop per Windows.

Configurare l'interfaccia della riga di comando di Docker

Il primo passaggio consiste nel configurare l'interfaccia della riga di comando di Docker nel computer di sviluppo Windows per potersi connettere al motore Docker remoto:

Scaricare la versione precompilata docker.exe dell'interfaccia della riga di comando di Docker da Chocolatey. È anche possibile scaricare il progetto dell'interfaccia della riga di comando ufficiale da GitHub e compilarlo seguendo le istruzioni del repository.
Estrarre docker.exe in una directory nel computer di sviluppo, C:\Docker\binad esempio .
Aprire About your PC System Info Advanced system settings .Open About your PC System Info Advanced system settings.Open About your PC>System Info Advanced>system settings.
Selezionare Variabili di ambiente avanzate>. In Variabili utente selezionare Percorso.
Modificare la variabile Path e aggiungere il percorso di docker.exe.
Aprire una sessione di PowerShell con privilegi elevati.
Verificare che l'interfaccia della riga di comando di Docker sia accessibile usando questo comando:
```
docker --version
```
Se tutti gli elementi sono stati configurati correttamente, l'output del comando dovrebbe mostrare la versione di Docker. Dovrebbe essere simile a Docker version 20.10.12, build e91ed57.

Configurare il motore Docker

Il secondo passaggio consiste nel configurare il motore Docker di IoT Edge per Linux in macchine virtuali Windows per accettare connessioni esterne e aggiungere le regole del firewall appropriate.

Avviso

L'esposizione del motore Docker a connessioni esterne potrebbe aumentare i rischi per la sicurezza. È consigliabile usare questa configurazione 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 IoT Edge for Linux on Windows VM 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 IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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"

Ecco l'output di esempio:

PS C:\> # Configure the IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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 IoT Edge for Linux on Windows 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

Testare la connessione

Il passaggio di installazione finale consiste nel testare la connessione Docker al motore Docker di IoT Edge per Linux in macchine virtuali Windows:

Ottenere l'indirizzo IP di IoT Edge per Linux nella macchina virtuale Windows:
```
Get-EflowVmAddr
```
Suggerimento

Se la macchina virtuale IoT Edge per Linux in Windows è stata distribuita senza un indirizzo IP statico, l'indirizzo IP potrebbe cambiare tra i riavvii del sistema operativo host Windows o le modifiche di rete. Assicurarsi di usare l'indirizzo IP corretto per IoT Edge per Linux nella macchina virtuale Windows ogni volta che si vuole stabilire una connessione remota al motore Docker.

Ecco 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 
```

Connettersi al motore Docker della macchina virtuale IoT Edge per Linux ed eseguire il hello-world contenitore di esempio. Sostituire <EFLOW-VM-IP> con l'indirizzo IP della macchina virtuale Windows IoT Edge per Linux ottenuto nel passaggio precedente.

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

Al termine del download del contenitore, il contenitore viene eseguito e produce questo output:

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're 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 è possibile distribuire nei dispositivi IoT Edge. Usare la procedura seguente per creare una soluzione Azure IoT Edge e quindi generare 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. È necessario usare l'estensione Azure IoT Edge Tools per creare il progetto di Visual Studio.

In Visual Studio creare un nuovo progetto selezionando Crea un nuovo progetto nella pagina iniziale o selezionando il pulsante Nuovo progetto sulla barra degli strumenti.
Nella pagina Creare 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 quindi selezionare Avanti.
Nella pagina Configura il nuovo progetto immettere un nome per il progetto e specificare il percorso e quindi selezionare Crea.
Nella finestra di dialogo Aggiungi modulo selezionare il tipo di modulo da sviluppare. È anche possibile selezionare Modulo esistente per aggiungere un modulo IoT Edge esistente alla distribuzione.
In Nome modulo specificare il nome 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 module.json file. L'URL del repository si trova nella repository proprietà del file JSON.

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

Struttura progetto

La soluzione ha due cartelle a livello di progetto: una cartella di progetto principale e una 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. Un manifesto di distribuzione è un documento JSON che descrive i moduli da configurare nei dispositivi IoT Edge di destinazione.

La cartella del modulo contiene un file per il codice del modulo. Il nome Program.cs è o main.c, a seconda della lingua scelta. 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. Il file definisce anche il modo in cui i moduli comunicano tra loro. Per altre informazioni sui manifesti di distribuzione, vedere Informazioni su come distribuire i moduli e stabilire route.

Il modello di distribuzione include:

I due moduli di runtime e edgeAgent edgeHub.
Modulo personalizzato creato in questo progetto di Visual Studio.
Modulo denominato SimulatedTemperatureSensor. Questo modulo predefinito genera dati simulati che è possibile usare per testare i moduli oppure 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. 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 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. Selezionare quindi OK per salvare le modifiche. Se non sono state apportate modifiche, selezionare Annulla.

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 deployment.debug.template.json distribuzione. Modificare la versione di runtime per le immagini edgeAgent del modulo di runtime di sistema 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. Questo passaggio genera un manifesto della distribuzione basato sul modello di distribuzione. Il manifesto viene visualizzato nella config cartella del progetto di Visual Studio.

Aprire il file manifesto della deployment.debug.template.json distribuzione.
Modificare la versione di runtime per le immagini edgeAgent del modulo di runtime di sistema 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

Configurare l'estensione Azure IoT Edge Tools per usare il motore Docker remoto eseguito all'interno della macchina virtuale IoT Edge per Linux in Windows:

Selezionare Strumenti strumenti>di Azure IoT Edge Impostazioni degli strumenti>IoT Edge.
Sostituire il valore DOCKER_HOST localhost con l'indirizzo IP per IoT Edge per Linux nella macchina virtuale Windows. Se non si ricorda l'indirizzo IP, usare il cmdlet Get-EflowVmAddr IoT Edge per Linux in Windows PowerShell per ottenerlo. Ad esempio, se l'indirizzo IP della macchina virtuale IoT Edge per Linux in Windows è 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).

Nella soluzione predefinita i dati simulati del SimulatedTemperatureSensor modulo vengono indirizzati al modulo. Il modulo accetta l'input e lo invia a hub IoT di Azure.

Quando si è pronti per personalizzare il modello di modulo con il proprio codice, usare gli SDK hub IoT di Azure per compilare altri moduli che rispondono alle esigenze chiave per le soluzioni IoT. Queste esigenze possono includere 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 IoT Edge per Linux in una macchina virtuale Windows, il primo passaggio consiste nel compilare e pubblicare il modulo per abilitare il debug remoto:

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

Nota

Quando si seleziona Debug, Visual Studio usa Dockerfile.(amd64|windows-amd64).debug per compilare immagini Docker. Questo file include il debugger della riga di comando di .NET Core VSDBG 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.

Assicurarsi che nell'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. Salvare la chiave RSA nella stessa cartella del modulo IoT Edge e assicurarsi 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, 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. Se si usa un registro locale, è possibile eseguire un registro locale.
```
docker -H tcp://<EFLOW-VM-IP>:2375 login -u <Container Registry username> -p <Container Registry password> <Container Registry 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. Questo comando compila ed esegue 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, la password e il nome del Registro di sistema effettivi dell'amministratore del Registro 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.
È 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. La porta specificata verrà usata come porta SSH per connettersi al modulo Linux C#. È necessario aggiungere le informazioni sulla porta SSH a createOptions per questa impostazione del modulo Linux 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 CODICE JSON di distribuzione IoT Edge.
Selezionare Visualizza>Cloud Explorer. Assicurarsi di aver eseguito l'accesso a Visual Studio 2019.
In Cloud Explorer espandere la sottoscrizione e quindi trovare 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. Si trova nella cartella nella config soluzione di Visual Studio, ad esempio deployment.amd64.json.

Compilare l'immagine Docker del modulo

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"

Eseguire il push dell'immagine Docker del modulo

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

Prima della distribuzione, è necessario aggiornare le credenziali del Registro Azure Container, le immagini del modulo e i valori createOptions appropriati. Per altre informazioni sui createOption valori, 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, aggiungere le credenziali a deployment.debug.template.json nelle edgeAgent impostazioni. 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 image proprietà 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 IotEdgeModule1personalizzato , sostituire il valore della proprietà image con il valore del tag .

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

Ad esempio, le image impostazioni e createOptions per IotEdgeModule1 sono simili all'esempio seguente:

"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 nell'hub deployment.debug.amd64.json my-iot-hub IoT per il dispositivo my-deviceIoT Edge, 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 i hub IoT stringa di connessione nella portale di Azure in hub IoT di Azure> Impostazioni> di accesso condiviso.
In Cloud Explorer fare clic con il pulsante destro del mouse sul dispositivo perimetrale e aggiornare per verificare che il nuovo modulo sia in esecuzione, insieme ai $edgeAgent moduli e $edgeHub .

Eseguire il debug della soluzione

In una sessione di PowerShell con privilegi elevati eseguire i comandi seguenti:
1. Ottenere il moduleId valore in base al nome del modulo C# linux. Sostituire il segnaposto con il <iot-edge-module-name> nome del modulo.
```
$moduleId = Invoke-EflowVmCommand "sudo docker ps -aqf name=<iot-edge-module-name>"
```
2. Verificare che $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 IoT Edge per Linux in Windows. 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 IoT Edge per Linux viene riavviato nella macchina virtuale Windows, la regola della tabella IP viene eliminata e torna alle impostazioni originali. Inoltre, è necessario avviare nuovamente il servizio SSH del modulo manualmente.

Dopo aver avviato correttamente il servizio SSH, selezionare Debug>Connetti a processo, impostare Tipo di connessione su SSH e impostare Destinazione connessione sull'indirizzo IP dell'IoT Edge per Linux nella macchina virtuale Windows. Se non si conosce l'indirizzo IP della macchina virtuale IoT Edge per Linux in una macchina virtuale Windows, è possibile usare il Get-EflowVmAddr cmdlet di PowerShell.

Digitare l'INDIRIZZO IP e quindi premere INVIO. Nella finestra popup immettere le configurazioni seguenti:

Campo	valore
Hostname (Nome host)	Indirizzo IP per IoT Edge per Linux nella macchina virtuale Windows
Porta	10022 (o quello usato nella configurazione della distribuzione)
Nome utente	root
Tipo di autenticazione	Chiave privata
File chiave privata	Percorso completo del `id_rsa` valore creato in un passaggio precedente
Passphrase	Passphrase usata per la chiave creata in un passaggio precedente

Dopo la connessione al modulo tramite SSH, è possibile scegliere il processo e selezionare Collega. Per il modulo C# è necessario scegliere dotnet e Attach to Managed (CoreCLR) (Processo dotnet e Attach to Managed (CoreCLR). La prima volta potrebbero 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 al input1 modulo C# Linux personalizzato. Il punto di interruzione deve essere attivato. È possibile controllare le variabili nella finestra Variabili locali di Visual Studio.
Per arrestare il debug, selezionare CTRL+F5 o selezionare il pulsante Arresta .

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, 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 selezionare ogni risorsa per eliminarle singolarmente.

Passaggio successivo

In questa esercitazione si configura Visual Studio nel computer di sviluppo ed è stato distribuito ed eseguito il debug del primo modulo IoT Edge. Ora che si conoscono i concetti di base, provare ad aggiungere funzionalità a un modulo in modo che possa analizzare i dati passandovi:

Esercitazione: Sviluppare moduli Azure IoT Edge con Visual Studio Code

Condividi tramite