Använda Visual Studio 2022 för att utveckla och felsöka moduler för Azure IoT Edge

Artikel
04/11/2024

Gäller för: IoT Edge 1.5 IoT Edge 1.4

Viktigt!

IoT Edge 1.5 LTS och IoT Edge 1.4 LTS stöds. IoT Edge 1.4 LTS upphör den 12 november 2024. Om du har en tidigare version läser du Uppdatera IoT Edge.

Den här artikeln visar hur du använder Visual Studio 2022 för att utveckla, felsöka och distribuera anpassade Azure IoT Edge-moduler. Visual Studio 2022 innehåller mallar för IoT Edge-moduler skrivna i C och C#. Enhetsarkitekturer som stöds är Windows x64, Linux x64, ARM32 och ARM64 (förhandsversion). Mer information om operativsystem, språk och arkitekturer som stöds finns i Stöd för språk och arkitektur.

Den här artikeln innehåller steg för två IoT Edge-utvecklingsverktyg.

Kommandoradsgränssnitt (CLI) är det bästa verktyget för utveckling.
Azure IoT Edge-verktyg för Visual Studio-tillägget . Tillägget är i underhållsläge.

Använd knappen för verktygsväljaren i början för att välja verktygsalternativet för den här artikeln. Båda verktygen ger följande fördelar:

Skapa, redigera, skapa, köra och felsöka IoT Edge-lösningar och moduler på din lokala utvecklingsdator.
Koda dina Azure IoT-moduler i C eller C# med fördelarna med Visual Studio-utveckling.
Distribuera din IoT Edge-lösning till en IoT Edge-enhet via Azure IoT Hub.

Förutsättningar

Den här artikeln förutsätter att du använder en dator som kör Windows som utvecklingsdator.

Installera eller ändra Visual Studio 2022 på utvecklingsdatorn. Välj azure-utveckling och skrivbordsutveckling med arbetsbelastningsalternativ för C++.
Ladda ned och installera Azure IoT Edge-verktyg från Visual Studio Marketplace. Du kan använda Azure IoT Edge Tools-tillägget för att skapa och skapa din IoT Edge-lösning. Det föredragna utvecklingsverktyget är kommandoradsverktyget (CLI) Azure IoT Edge Dev Tool. Tillägget innehåller Azure IoT Edge-projektmallarna som används för att skapa Visual Studio-projektet. För närvarande behöver du tillägget installerat oavsett vilket utvecklingsverktyg du använder.

Viktigt!

Azure IoT Edge Tools for VS 2022-tillägget är i underhållsläge. Det föredragna utvecklingsverktyget är kommandoradsverktyget (CLI) Azure IoT Edge Dev Tool.

Dricks

Om du använder Visual Studio 2019 laddar du ned och installerar Azure IoT Edge Tools för VS 2019 från Visual Studio Marketplace.

Installera Vcpkg-bibliotekshanteraren

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

Installera azure-iot-sdk-c-paketet för Windows

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

Ladda ned och installera ett Docker-kompatibelt containerhanteringssystem på utvecklingsdatorn för att skapa och köra modulavbildningarna. Installera till exempel Docker Community Edition.
Om du vill utveckla moduler med Linux-containrar använder du en Windows-dator som uppfyller kraven för Docker Desktop.
Skapa ett Azure Container Registry eller Docker Hub för att lagra dina modulavbildningar.

Dricks

Du kan använda ett lokalt Docker-register i prototyp- och testsyfte i stället för ett molnregister.
Installera Azure CLI.
För att testa modulen på en enhet behöver du en aktiv IoT Hub med minst en IoT Edge-enhet. Om du vill skapa en IoT Edge-enhet för testning kan du skapa en i Azure-portalen eller med CLI:
- Att skapa en i Azure-portalen är det snabbaste. Från Azure-portalen går du till din IoT Hub-resurs. Välj Enheter under menyn Enhetshantering och välj sedan Lägg till enhet.
  
  I Skapa en enhet namnger du enheten med enhets-ID, kontrollerar IoT Edge-enhet och väljer sedan Spara längst ned till vänster.
  
  Bekräfta slutligen att den nya enheten finns i din IoT Hub från menyn Enheter för enhetshantering>. Mer information om hur du skapar en IoT Edge-enhet via Azure-portalen finns i Skapa och etablera en IoT Edge-enhet i Linux med symmetriska nycklar.
- Om du vill skapa en IoT Edge-enhet med CLI följer du stegen i snabbstarten för Linux eller Windows. När du registrerar en IoT Edge-enhet skapar du en IoT Edge-enhet.
Om du kör IoT Edge-daemonen på utvecklingsdatorn kan du behöva stoppa EdgeHub och EdgeAgent innan du börjar utveckla i Visual Studio.

Skapa ett Azure IoT Edge-projekt

IoT Edge-projektmallen i Visual Studio skapar en lösning för distribution till IoT Edge-enheter. Först skapar du en Azure IoT Edge-lösning. Sedan skapar du en modul i den lösningen. Varje IoT Edge-lösning kan innehålla mer än en modul.

Varning

Azure IoT Edge-verktygen för Visual Studio-tillägget saknar projektmallarna för C- och C#-moduler. Vi arbetar för att lösa problemet. Om du inte kan skapa IoT Edge-moduler med tillägget använder du följande lösning.

Ladda ned följande filer och placera dem i den angivna Visual Studio-mallkatalogen:

Mallfil	Lägg till i katalogen
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`

I vår lösning ska vi skapa tre projekt. Huvudmodulen som innehåller EdgeAgent och EdgeHub, utöver temperatursensormodulen. Sedan lägger du till ytterligare två IoT Edge-moduler.

Viktigt!

IoT Edge-projektstrukturen som skapats av Visual Studio är inte samma som den i Visual Studio Code.

För närvarande stöder Inte Azure IoT Edge Dev Tool CLI att skapa Visual Studio-projekttypen. Du måste använda Visual Studio IoT Edge-tillägget för att skapa Visual Studio-projektet.

Skapa ett nytt projekt i Visual Studio.
I Skapa ett nytt projekt söker du efter Azure IoT Edge. Välj det projekt som matchar plattformen och arkitekturen för din IoT Edge-enhet och välj Nästa.
I Konfigurera det nya projektet anger du ett namn för projektet, anger platsen och väljer Skapa.
I Lägg till modul väljer du den typ av modul som du vill utveckla. Om du har en befintlig modul som du vill lägga till i distributionen väljer du Befintlig modul.
I Modulnamn anger du ett namn för modulen. Välj ett namn som är unikt i containerregistret.
I Url för lagringsplats anger du namnet på modulens avbildningslagringsplats. Visual Studio fyller automatiskt i modulnamnet med localhost:5000/<ditt modulnamn>. Ersätt den med din egen registerinformation. Använd localhost om du använder ett lokalt Docker-register för testning. Om du använder Azure Container Registry använder du inloggningsservern från registrets inställningar. Inloggningsservern ser ut som <registernamn.azurecr.io.> Ersätt endast localhost:5000-delen av strängen så att slutresultatet ser ut som <registernamn.azurecr.io/<> därt modulnamn.>
Välj Lägg till för att lägga till modulen i projektet.

Kommentar

Om du har ett befintligt IoT Edge-projekt kan du ändra lagringsplatsens URL genom att öppna filen module.json . Lagringsplatsens URL finns i lagringsplatsens egenskap för JSON-filen.

Nu har du ett IoT Edge-projekt och en IoT Edge-modul i din Visual Studio-lösning.

Projektstruktur

I din lösning finns det två mappar på projektnivå, inklusive en huvudprojektmapp och en enda modulmapp. Du kan till exempel ha en huvudprojektmapp med namnet AzureIotEdgeApp1 och en modulmapp med namnet IotEdgeModule1. Huvudprojektmappen innehåller distributionsmanifestet.

Modulprojektmappen innehåller en fil för modulkoden med namnet antingen Program.cs eller main.c beroende på vilket språk du har valt. Den här mappen innehåller också en fil med namnet module.json som beskriver metadata för din modul. Olika Docker-filer som ingår här innehåller den information som behövs för att skapa din modul som en Windows- eller Linux-container.

Distributionsmanifest för projektet

Distributionsmanifestet som du redigerar heter deployment.debug.template.json. Den här filen är en mall för ett IoT Edge-distributionsmanifest som definierar alla moduler som körs på en enhet tillsammans med hur de kommunicerar med varandra. Mer information om distributionsmanifest finns i Lär dig hur du distribuerar moduler och upprättar vägar.

Om du öppnar den här distributionsmallen ser du att de två runtime-modulerna, edgeAgent och edgeHub ingår, tillsammans med den anpassade modul som du skapade i det här Visual Studio-projektet. En fjärde modul med namnet SimulatedTemperatureSensor ingår också. Den här standardmodulen genererar simulerade data som du kan använda för att testa dina moduler eller ta bort om det inte behövs. Om du vill se hur den simulerade temperatursensorn fungerar kan du visa källkoden SimulatedTemperatureSensor.csproj.

Ange IoT Edge-körningsversion

För närvarande är den senaste stabila körningsversionen 1.5. Du bör uppdatera IoT Edge-körningsversionen till den senaste stabila versionen eller den version som du vill rikta in dig på för dina enheter.

I Istraživač rešenja högerklickar du på namnet på huvudprojektet och väljer Ange IoT Edge-körningsversion.
Använd den nedrullningsbara menyn för att välja den körningsversion som dina IoT Edge-enheter kör och välj sedan OK för att spara ändringarna. Om ingen ändring har gjorts väljer du Avbryt för att avsluta.

Tillägget innehåller för närvarande inte något val för de senaste körningsversionerna. Om du vill ange körningsversionen högre än 1.2 öppnar du deployment.debug.template.json distributionsmanifestfil. Ändra körningsversionen för systemkörningsmodulens avbildningar edgeAgent och edgeHub. Om du till exempel vill använda IoT Edge-körningsversionen 1.5 ändrar du följande rader i distributionsmanifestfilen:
```
"systemModules": {
   "edgeAgent": {
    //...
      "image": "mcr.microsoft.com/azureiotedge-agent:1.5"
    //...
   "edgeHub": {
   //...
      "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   //...
```
Om du har ändrat versionen återskapar du distributionsmanifestet genom att högerklicka på namnet på projektet och välja Generera distribution för IoT Edge. Detta genererar ett distributionsmanifest baserat på distributionsmallen och visas i konfigurationsmappen för ditt Visual Studio-projekt.

Öppna deployment.debug.template.json distributionsmanifestfil. Distributionsmanifestet är ett JSON-dokument som beskriver de moduler som ska konfigureras på den riktade IoT Edge-enheten.

Ändra körningsversionen för systemkörningsmodulens avbildningar edgeAgent och edgeHub. Om du till exempel vill använda IoT Edge-körningsversionen 1.5 ändrar du följande rader i distributionsmanifestfilen:

"systemModules": {
    "edgeAgent": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
    //...
    "edgeHub": {
    //...
        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
    //...

Alternativ för modulinfrastruktur och utveckling

När du lägger till en ny modul levereras den med standardkod som är redo att skapas och distribueras till en enhet så att du kan börja testa utan att röra någon kod. Modulkoden finns i modulmappen i en fil med namnet Program.cs (för C#) eller main.c (för C).

Standardlösningen skapas så att simulerade data från modulen SimulatedTemperatureSensor dirigeras till din modul, som tar indata och sedan skickar dem till IoT Hub.

När du är redo att anpassa modulmallen med din egen kod använder du SDK: erna för Azure IoT Hub för att skapa moduler som uppfyller nyckelbehoven för IoT-lösningar som säkerhet, enhetshantering och tillförlitlighet.

Felsöka med hjälp av simulatorn

Azure IoT EdgeHub Dev Tool ger en lokal utvecklings- och felsökningsupplevelse. Verktyget hjälper dig att starta IoT Edge-moduler utan IoT Edge-körningen så att du kan skapa, utveckla, testa, köra och felsöka IoT Edge-moduler och lösningar lokalt. Du behöver inte skicka avbildningar till ett containerregister och distribuera dem till en enhet för testning.

Mer information finns i Azure IoT EdgeHub Dev Tool.

Så här initierar du verktyget i Visual Studio:

Hämta niska veze för din IoT Edge-enhet (som finns i din IoT Hub) från Azure-portalen eller från Azure CLI.

Om du använder CLI för att hämta din niska veze använder du det här kommandot och ersätter [device_id]" och "[hub_name]" med dina egna värden:
```
az iot hub device-identity connection-string show --device-id [device_id] --hub-name [hub_name]
```
På menyn Verktyg i Visual Studio väljer du Azure IoT Edge Tools>Setup IoT Edge Simulator.
Klistra in niska veze och välj OK.

Kommentar

Du behöver bara följa dessa steg en gång på utvecklingsdatorn eftersom resultaten tillämpas automatiskt på alla efterföljande Azure IoT Edge-lösningar. Den här proceduren kan följas igen om du behöver ändra till en annan niska veze.

Skapa och felsöka en enskild modul

Normalt vill du testa och felsöka varje modul innan du kör den i en hel lösning med flera moduler. Med IoT Edge-simulatorverktyget kan du köra en enskild modul isolerat och skicka meddelanden via port 53000.

I Istraživač rešenja väljer och markerar du modulprojektmappen (till exempel IotEdgeModule1). Ange den anpassade modulen som startprojekt. Välj Project Set as StartUp Project (Projektuppsättning>som startprojekt) på menyn.
Tryck på F5 eller välj knappen kör verktygsfältet för att starta IoT Edge-simulatorn för en enskild modul. Det kan ta 10 till 20 sekunder från början.
Du bör se ett .NET Core-konsolappfönster om modulen har initierats.
Ange en brytpunkt för att inspektera modulen.
- Om du utvecklar i C# anger du en brytpunkt i PipeMessage() funktionen i ModuleBackgroundService.cs.
- Om du använder C anger du en brytpunkt i InputQueue1Callback() funktionen i main.c.
Testa modulen genom att skicka ett meddelande. När du felsöker en enskild modul lyssnar simulatorn på standardporten 53000 för meddelanden. Om du vill skicka ett meddelande till modulen kör du följande curl-kommando från ett kommandogränssnitt som Git Bash eller WSL Bash.
```
curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
```
Om du får felet ej matchad nära klammerparentes/hakparentes i URL:en kan du prova följande kommando i stället:
```
curl --header "Content-Type: application/json" --request POST --data "{\"inputName\": \"input1\", \"data\", \"hello world\"}"  http://localhost:53000/api/v1/messages
```
Brytpunkten ska utlösas. Du kan titta på variabler i Visual Studio Locals-fönstret, som hittas när felsökningsprogrammet körs. Gå till Felsöka>Lokala Windows-platser.>

I Bash eller gränssnittet bör du se en {"message":"accepted"} bekräftelse.

I .NET-konsolen bör du se:
```
IoT Hub module client initialized.
Received message: 1, Body: [hello world]
```
Dricks

Du kan också använda PostMan eller andra API-verktyg för att skicka meddelanden i stället curlför .
Tryck på Ctrl + F5 eller välj stoppknappen för att sluta felsöka.

Skapa och felsöka flera moduler

När du har utvecklat en enda modul kanske du vill köra och felsöka en hel lösning med flera moduler. Med IoT Edge-simulatorverktyget kan du köra alla moduler som definierats i distributionsmanifestet, inklusive en simulerad edgeHub för meddelanderoutning. I det här exemplet kör du två anpassade moduler och modulen för simulerad temperatursensor. Meddelanden från modulen för simulerad temperatursensor dirigeras till varje anpassad modul.

I Istraživač rešenja lägger du till en andra modul i lösningen genom att högerklicka på huvudprojektmappen. På menyn väljer du Lägg till>ny IoT Edge-modul.
I fönstret Add module ger du den nya modulen ett namn och ersätter localhost:5000 den del av lagringsplatsens URL med din Azure Container Registry-inloggningsserver, som du gjorde tidigare.
Öppna filen deployment.debug.template.json för att se att den nya modulen har lagts till i avsnittet moduler . En ny väg lades också till i avsnittet vägar i EdgeHub för att skicka meddelanden från den nya modulen till IoT Hub. Om du vill skicka data från den simulerade temperatursensorn till den nya modulen lägger du till en annan väg med följande rad JSONi . Ersätt <NewModuleName> (på två platser) med ditt eget modulnamn.
```
"sensorTo<NewModuleName>": "FROM /messages/modules/SimulatedTemperatureSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/<NewModuleName>/inputs/input1\")"
```
Högerklicka på huvudprojektet (till exempel AzureIotEdgeApp1) och välj Ange som startprojekt. Genom att ange huvudprojektet som startprojekt körs alla moduler i lösningen. Detta omfattar båda modulerna som du har lagt till i lösningen, modulen för simulerad temperatursensor och den simulerade Edge-hubben.
Tryck på F5 eller välj knappen kör verktygsfältet för att köra lösningen. Det kan ta 10 till 20 sekunder från början. Se till att du inte har andra Docker-containrar som kan binda den port som du behöver för det här projektet.
Du bör se två .NET Core-konsolappfönster visas en för varje modul.
Ange en brytpunkt för att inspektera modulerna.
- Om du utvecklar i C# anger du en brytpunkt i PipeMessage() funktionen i ModuleBackgroundService.cs.
- Om du använder C anger du en brytpunkt i InputQueue1Callback() funktionen i main.c.
Skapa brytpunkter i varje modul och tryck sedan på F5 för att köra och felsöka flera moduler samtidigt. Du bör se flera .NET Core-konsolappfönster, där varje fönster representerar en annan modul.
Tryck på Ctrl + F5 eller välj stoppknappen för att sluta felsöka.

Skapa och skicka avbildningar till registret

När du har utvecklat och debuggat modulen kan du skapa och push-överföra modulavbildningen till Azure Container Registry. Du kan sedan distribuera modulen till din IoT Edge-enhet.

Ange det huvudsakliga IoT Edge-projektet som startprojekt, inte en av de enskilda modulerna.
Välj antingen Felsök eller Släpp som konfiguration för att skapa för dina modulbilder.

Kommentar

När du väljer Felsök använder Dockerfile.(amd64|windows-amd64).debug Visual Studio för att skapa Docker-avbildningar. Detta inkluderar .NET Core-kommandoradsfelsökaren VSDBG i containeravbildningen när du skapar den. För produktionsklara IoT Edge-moduler rekommenderar vi att du använder versionskonfigurationen, som använder Dockerfile.(amd64|windows-amd64) utan VSDBG.
Om du använder ett privat register som Azure Container Registry (ACR) använder du följande Docker-kommando för att logga in på det. Du kan hämta användarnamnet och lösenordet från sidan Åtkomstnycklar i registret i Azure-portalen.
```
docker login <ACR login server>
```
Nu ska vi lägga till inloggningsinformationen för Azure Container Registry i körningsinställningarna som finns i filen deployment.debug.template.json. Det finns två sätt att göra detta på. Du kan antingen lägga till dina registerautentiseringsuppgifter i .env filen (säkrast) eller lägga till dem direkt i deployment.debug.template.json filen.

Lägg till autentiseringsuppgifter i .env filen:

I Istraživač rešenja väljer du verktygsfältet Visa alla filer. Filen .env visas. Lägg till ditt användarnamn och lösenord för Azure Container Registry i .env filen. Dessa autentiseringsuppgifter finns på sidan Åtkomstnycklar i Azure Container Registry i Azure-portalen.
```
    DEFAULT_RT_IMAGE=1.2
    CONTAINER_REGISTRY_USERNAME_myregistry=<my-registry-name>
    CONTAINER_REGISTRY_PASSWORD_myregistry=<my-registry-password>
```
Lägg till autentiseringsuppgifter direkt i deployment.debug.template.json

Om du hellre lägger till dina autentiseringsuppgifter direkt i distributionsmallen ersätter du platshållarna med ditt användarnamn, lösenord och registernamn för ACR-administratören.
```
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "registry1": {
            "username": "<username>",
            "password": "<password>",
            "address": "<registry name>.azurecr.io"
          }
        }
      }
```
Kommentar

Den här artikeln använder autentiseringsuppgifter för administratörsinloggning för Azure Container Registry, vilket är praktiskt för utvecklings- och testscenarier. När du är redo för produktionsscenarier rekommenderar vi ett alternativ för autentisering med minst privilegier som tjänstens huvudnamn. Mer information finns i Hantera åtkomst till containerregistret.
Om du använder ett lokalt register kan du köra ett lokalt register.
I Istraživač rešenja högerklickar du slutligen på huvudprojektmappen och väljer Skapa och push-överföra IoT Edge-moduler för att skapa och push-överföra Docker-avbildningen för varje modul. Det kan ta en minut. När du ser Finished Build and Push IoT Edge Modules. i utdatakonsolen i Visual Studio är du klar.

Distribuera lösningen

Nu när du har skapat och push-överfört dina modulavbildningar till Azure Container Registry kan du distribuera lösningen till din IoT Edge-enhet. Du har redan en mall för distributionsmanifestet som du har observerat under den här självstudien. Nu ska vi generera ett distributionsmanifest från det och sedan använda ett Azure CLI-kommando för att distribuera dina moduler till din IoT Edge-enhet i Azure.

Högerklicka på huvudprojektet i Visual Studio Istraživač rešenja och välj Generera distribution för IoT Edge.
Gå till din lokala Visual Studio-huvudprojektmapp och leta i config mappen. Filsökvägen kan se ut så här: C:\Users\<YOUR-USER-NAME>\source\repos\<YOUR-IOT-EDGE-PROJECT-NAME>\config. Här hittar du det genererade distributionsmanifestet, till exempel deployment.amd64.debug.json.
Kontrollera filen deployment.amd64.debug.json för att bekräfta att schemaversionen är inställd på edgeHub 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
       }
     }
   }
```
Dricks

Distributionsmallen för Visual Studio 2022 kräver schemaversionen 1.2. Om du vill att den ska vara 1.1 eller 1.0 väntar du tills distributionen har genererats (ändra den inte i deployment.debug.template.json). Om du genererar en distribution skapas ett 1.2-schema som standard. Du kan dock ändra deployment.amd64.debug.json, det genererade manifestet manuellt, om det behövs innan du distribuerar det till Azure.

Viktigt!

När din IoT Edge-enhet har distribuerats visas den för närvarande inte korrekt i Azure-portalen med schemaversion 1.2 (version 1.1 blir bra). Detta är en känd bugg och kommer snart att åtgärdas. Detta påverkar dock inte din enhet eftersom den fortfarande är ansluten i IoT Hub och kan kommuniceras med när som helst med hjälp av Azure CLI.
Nu ska vi distribuera vårt manifest med ett Azure CLI-kommando. Öppna kommandotolken för Visual Studio Developer och ändra till konfigurationskatalogen.
```
    cd config
```
Distribuera manifestet för din IoT Edge-enhet till IoT Hub. Kommandot konfigurerar enheten för att använda moduler som utvecklats i din lösning. Distributionsmanifestet skapades i föregående steg och lagras i mappen config . Kör följande distributionskommando från mappen config. [device id]Ersätt , [hub name]och [file path] med dina värden. Om IoT Edge-enhets-ID:t inte finns i IoT Hub måste det skapas.
```
    az iot edge set-modules --device-id [device id] --hub-name [hub name] --content [file path]
```
Kommandot kan till exempel se ut så här:
```
az iot edge set-modules --device-id my-device-name --hub-name my-iot-hub-name --content deployment.amd64.debug.json
```
När du har kört kommandot visas en bekräftelse på distributionen i JSON kommandotolken.

Docker-avbildning för byggmodul

När du har utvecklat modulen kan du skapa modulavbildningen som ska lagras i ett containerregister för distribution till din IoT Edge-enhet.

Använd modulens Dockerfile för att skapa docker-modulens avbildning.

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

Anta till exempel att kommandogränssnittet finns i projektkatalogen och att modulnamnet är IotEdgeModule1. Om du vill skapa avbildningen för det lokala registret eller ett Azure-containerregister använder du följande kommandon:

# 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"

Push-modul docker-avbildning

Skicka modulavbildningen till det lokala registret eller ett containerregister.

docker push <ImageName>

Till exempel:

# 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

Distribuera modulen till IoT Edge-enheten.

Öppna deployment.debug.template.json distributionsmanifestfil i huvudprojektet i Visual Studio. Distributionsmanifestet är ett JSON-dokument som beskriver de moduler som ska konfigureras på den riktade IoT Edge-enheten. Innan distributionen måste du uppdatera dina autentiseringsuppgifter för Azure Container Registry, dina modulavbildningar och rätt createOptions värden. Mer information om createOption-värden finns i Konfigurera alternativ för containerskapande för IoT Edge-moduler.

Om du använder ett Azure Container Registry för att lagra modulavbildningen måste du lägga till dina autentiseringsuppgifter för att deployment.debug.template.json i edgeAgent-inställningarna . Exempel:

"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"
          }
        }
      }
    },
//...

Ersätt värdet för avbildningsegenskapen med det modulbildnamn som du skickade till registret. Om du till exempel push-överförde en bild taggad myacr.azurecr.io/iotedgemodule1:0.0.1-amd64 för den anpassade modulen IotEdgeModule1 ersätter du värdet för bildegenskapen med taggvärdet.

Lägg till eller ersätt värdet createOptions med strängbegränsat innehåll för varje system och anpassad modul i distributionsmallen.

Till exempel skulle IotEdgeModule1s avbildning och createOptions-inställningar likna följande:

"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\"}]}}}"
}

Använd kommandot IoT Edge Azure CLI set-modules för att distribuera modulerna till Azure IoT Hub. Om du till exempel vill distribuera modulerna som definierats i filen deployment.debug.amd64.json till IoT Hub my-iot-hub för IoT Edge-enheten my-device använder du följande kommando:

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>"

Dricks

Du hittar din IoT Hub-niska veze i Azure-portalen under Säkerhetsinställningar>för Azure IoT Hub >Delade åtkomstprinciper.

Bekräfta distributionen till enheten

Om du vill kontrollera att dina IoT Edge-moduler har distribuerats till Azure loggar du in på enheten (eller den virtuella datorn), till exempel via SSH eller Azure Bastion, och kör IoT Edge-listkommandot.

   iotedge list

Du bör se en lista över dina moduler som körs på din enhet eller virtuella dator.

   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

Felsöka med Docker Remote SSH

Docker- och Moby-motorerna stöder SSH-anslutningar till containrar så att du kan ansluta och felsöka kod på en fjärrenhet med hjälp av Visual Studio.

Fjärranslutning till Docker kräver behörigheter på rotnivå. Följ stegen i Hantera docker som en icke-rotanvändare för att tillåta anslutning till Docker-daemonen på fjärrenheten. När du är klar med felsökningen kanske du vill ta bort användaren från Docker-gruppen.
Följ stegen för att använda Visual Studio för att ansluta till en process som körs på en Docker-container på fjärrenheten.
I Visual Studio anger du brytpunkter i din anpassade modul.
När en brytpunkt nås kan du inspektera variabler, stega igenom kod och felsöka modulen.

Nästa steg

Förstå och använda Azure IoT Hub-SDK:er för att utveckla anpassade moduler för dina IoT Edge-enheter.
Om du vill övervaka meddelanden från enhet till moln (D2C) för en specifik IoT Edge-enhet läser du Självstudie: Övervaka IoT Edge-enheter för att komma igång.

Dela via