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

Gäller för: IoT Edge 1,1 IoT Edge 1,2

Du kan omvandla din affärslogik till moduler för Azure IoT Edge. Den här artikeln visar hur du använder Visual Studio Code som huvudverktyg för att utveckla och felsöka moduler.

Det finns två sätt att felsöka moduler som skrivits i C#, Node.js eller Java i Visual Studio Code: Du kan antingen koppla en process i en modulcontainer eller starta modulkoden i felsökningsläge. Om du vill felsöka moduler som skrivits i Python eller C kan du bara ansluta till en process i Linux amd64-containrar.

Om du inte är bekant med felsökningsfunktionerna i Visual Studio Code kan du läsa om att felsöka.

Den här artikeln innehåller instruktioner för att utveckla och felsöka moduler på flera språk för flera arkitekturer. För närvarande Visual Studio Code stöd för moduler som skrivits i C#, C, Python, Node.js och Java. De enhetsarkitekturer som stöds är X64 och ARM32. Mer information om operativsystem, språk och arkitekturer som stöds finns i Stöd för språk och arkitektur.

Förutsättningar

Du kan använda en dator eller en virtuell dator som kör Windows, macOS eller Linux som utvecklingsdator. På Windows kan du utveckla antingen Windows eller Linux-moduler. Om du Windows moduler använder du en Windows dator som kör version 1809/version 17763 eller senare. Om du vill utveckla Linux-moduler Windows en dator som uppfyller kraven för Docker Desktop.

Installera Visual Studio Code först och lägg sedan till följande tillägg:

• Azure IoT-verktyg
• Docker-tillägg
• Visual Studio tillägg som är specifika för det språk som du utvecklar i:
  • C#, inklusive Azure Functions: C#-tillägg
  • Python: Python-tillägg
  • Java: Java-tilläggspaketet för Visual Studio Code
  • C: C/C++-tillägg

Du måste också installera några ytterligare språkspecifika verktyg för att utveckla din modul:

• C#, inklusive Azure Functions: .NET Core 2.1 SDK

• Python: Python och Pip för att installera Python-paket (ingår vanligtvis i Python-installationen).

• Node.js: Node.js. Du vill också installera Yeoman och Azure IoT Edge Node.js Module Generator.

• Java: Java SE Development Kit 10 och Maven. Du måste ange miljövariabeln JAVA_HOME så att den pekar på JDK-installationen.

För att skapa och distribuera modulavbildningen behöver du Docker för att skapa modulavbildningen och ett containerregister som ska innehålla modulavbildningen:

• Docker Community Edition på utvecklingsdatorn.

• Azure Container Registry eller Docker Hub

  Tips

  Du kan använda ett lokalt Docker-register i prototyp- och testsyfte i stället för ett molnregister.

Såvida du inte utvecklar din modul i C behöver du även det Python-baserade Azure IoT EdgeHub Dev Tool för att konfigurera din lokala utvecklingsmiljö för att felsöka, köra och testa din IoT Edge lösning. Om du inte redan har gjort det installerar du Python (2.7/3.6/3.7/3.8) och Pip och installerar sedan iotedgehubdev genom att köra det här kommandot i terminalen.

pip install --upgrade iotedgehubdev

Om du vill testa modulen på en enhet behöver du en aktiv IoT-hubb med minst en IoT Edge enhet. Om du vill använda datorn IoT Edge en enhet följer du stegen i snabbstarten för Linux eller Windows. Om du kör IoT Edge daemon på utvecklingsdatorn kan du behöva stoppa EdgeHub och EdgeAgent innan du går vidare till nästa steg.

Skapa en ny lösningsmall

Följande steg visar hur du skapar en IoT Edge-modul på det utvecklingsspråk du föredrar (inklusive Azure Functions, skrivet i C#) med Visual Studio Code och Azure IoT Tools. Du börjar med att skapa en lösning och genererar sedan den första modulen i lösningen. Varje lösning kan innehålla flera moduler.

1. Välj Visa > kommandopalett.

2. I kommandopaletten anger och kör du kommandot Azure IoT Edge: New IoT Edge Solution.

   

3. Bläddra till mappen där du vill skapa den nya lösningen och välj sedan Välj mapp.

4. Ange ett namn för lösningen.

5. Välj en modulmall för det utvecklingsspråk du föredrar för att bli den första modulen i lösningen.

6. Ange ett namn för modulen. Välj ett namn som är unikt i containerregistret.

7. Ange namnet på modulens avbildningsdatabas. Visual Studio code fyller automatiskt i modulnamnet med localhost:5000/<modulnamnet >. Ersätt den med din egen registerinformation. Om du använder ett lokalt Docker-register för testning går det bra med localhost. Om du Azure Container Registry använder du inloggningsservern från registrets inställningar. Inloggningsservern ser ut <registry name> som .azurecr.io. Ersätt endast localhost:5000-delen av strängen så att slutresultatet ser ut <registry name> som .azurecr.io/ <your module name>.

   

Visual Studio Code tar den information du angav, skapar en IoT Edge lösning och läser sedan in den i ett nytt fönster.

Det finns fyra objekt i lösningen:

• En .vscode-mapp innehåller felsökningskonfigurationer.

• En modules-mapp har undermappar för varje modul. I mappen för varje modul finns en fil, module.json, som styr hur moduler byggs och distribueras. Den här filen måste ändras för att ändra containerregistret för moduldistribution från localhost till ett fjärrregister. Nu har du bara en modul. Men du kan lägga till mer i kommandopaletten med kommandot Azure IoT Edge: Lägg IoT Edge Modul.

• En .env-fil visar en lista över dina miljövariabler. Om Azure Container Registry är ditt register har du ett användarnamn Azure Container Registry lösenord i det.

  I produktionsscenarier rekommenderar vi att du använder tjänstens huvudnamn för att ge åtkomst till containerregistret i stället för .env-filen. Mer information finns i Hantera åtkomst till containerregistret.

  Anteckning

  Miljöfilen skapas bara om du anger en avbildningsdatabas för modulen. Om du har accepterat localhost-standardvärdena för att testa och felsöka lokalt behöver du inte deklarera miljövariabler.

• En deployment.template.json-fil visar en lista över den nya modulen tillsammans med en simulatedTemperatureSensor-exempelmodul som simulerar data som du kan använda för testning. Mer information om hur distributionsmanifest fungerar finns i Lär dig hur du använder distributionsmanifest för att distribuera moduler och upprätta vägar.

Om du vill se hur modulen för simulerad temperatur fungerar kan du visa källkoden SimulatedTemperatureSensor.csproj.

Ange IoT Edge körningsversion

Tillägget IoT Edge som standard den senaste stabila versionen av IoT Edge när distributionstillgångar skapas. För närvarande är den senaste stabila versionen version 1.2. Om du utvecklar moduler för enheter som kör den långsiktiga supportversionen 1.1 eller den tidigare 1.0-versionen uppdaterar du IoT Edge-körningsversionen i Visual Studio Code så att den matchar.

1. Välj Visa > kommandopalett.

2. I kommandopaletten anger och kör du kommandot Azure IoT Edge: Ange standard IoT Edge körningsversion.

3. Välj den körningsversion som IoT Edge kör från listan.

När du har valt en ny körningsversion uppdateras distributionsmanifestet dynamiskt för att återspegla ändringen av körningsmodulavbildningarna.

Lägga till ytterligare moduler

Om du vill lägga till ytterligare moduler i din lösning kör du kommandot Azure IoT Edge: Lägg IoT Edge modul från kommandopaletten. Du kan också högerklicka på mappen modules eller filen i Visual Studio Code Explorer-vyn och sedan välja deployment.template.json Lägg till IoT Edge Modul.

Utveckla din modul

Standardmodulkoden som medföljer lösningen finns på följande plats:

• Azure Function (C#): moduler > namnet på > < > modulens < > namn . cs
• C#: moduler > < ditt modulnamn > > Program.cs
• Python: moduler > < ditt > modulnamn > main.py
• Node.js: moduler > ditt < > modulnamn > app.js
• Java: moduler > < > ditt modulnamn > src > main > java > com > edgemodulemodules > App.java
• C: moduler > < ditt modulnamn > > main.c

Modulen och filen deployment.template.json konfigureras så att du kan skapa lösningen, skicka den till containerregistret och distribuera den till en enhet för att börja testa utan att behöva röra någon kod. Modulen är skapad för att helt enkelt ta indata från en källa (i det här fallet modulen SimulatedTemperatureSensor som simulerar data) och skicka den till IoT Hub.

När du är redo att anpassa mallen med din egen kod kan du använda Azure IoT Hub-SDK:er för att skapa moduler som adresserar de viktigaste behoven för IoT-lösningar som säkerhet, enhetshantering och tillförlitlighet.

Felsöka en modul utan en container (C#, Node.js, Java)

Om du utvecklar i C#, Node.js eller Java måste modulen använda ett ModuleClient-objekt i standardmodulkoden så att den kan starta, köra och dirigera meddelanden. Du använder också standardindatakanalen input1 för att vidta åtgärder när modulen tar emot meddelanden.

Konfigurera IoT Edge simulator

IoT Edge moduler behöver en IoT Edge miljö för att köra och felsöka. Du kan använda en IoT Edge på utvecklingsdatorn i stället för att köra den fullständiga IoT Edge daemon och runtime. Du kan antingen simulera en enhet för att felsöka lösningar med flera moduler eller simulera ett enda modulprogram.

Alternativ 1: simulera en IoT Edge lösning:

1. På fliken Explorer till vänster expanderar du Azure IoT Hub avsnittet. Högerklicka på ditt enhets-ID IoT Edge och välj sedan Konfigurera IoT Edge-simulatorn för att starta simulatorn med enhetens anslutningssträng.
2. Du kan se IoT Edge simulatorn har ställts in genom att läsa förloppsdetaljerna i den integrerade terminalen.

Alternativ 2: simulera en IoT Edge modul:

1. I kommandopaletten Visual Studio Code kör du kommandot Azure IoT Edge: Start IoT Edge Hub Simulator for Single Module.

2. Ange namnen på de indata som du vill testa med din modul. Om du använder standardexempelkoden använder du värdet input1.

3. Kommandot utlöser iotedgehubdev CLI och startar sedan IoT Edge simulatorn och en testverktygsmodulcontainer. Du kan se utdata nedan i den integrerade terminalen om simulatorn har startats i enkelt modulläge. Du kan också se ett curl -kommando som hjälper dig att skicka meddelanden. Du ska använda det senare.

   

   Du kan använda Docker Explorer-vyn i Visual Studio Code för att se modulens körningsstatus.

   

   EdgeHubDev-containern är kärnan i den lokala IoT Edge simulatorn. Den kan köras på din utvecklingsdator utan IoT Edge säkerhetsdaemon och tillhandahåller miljöinställningar för din interna modulapp eller modulcontainrar. Indatacontainern exponerar REST-API:er för att hjälpa till att överbrygga meddelanden till målindatakanalen i modulen.

Felsökningsmodul i startläge

När simulatorn har startats kan du felsöka modulkoden.

1. Förbered din miljö för felsökning enligt kraven för utvecklingsspråket, ange en brytpunkt i modulen och välj den felsökningskonfiguration som ska användas:

   • C#

     • I den Visual Studio Code-integrerade terminalen < > ändrar du katalogen till mappen med modulnamnet och kör sedan följande kommando för att skapa .NET Core-programmet.

       dotnet build
       

     • Öppna filen och Program.cs lägg till en brytpunkt.

     • Gå till Visual Studio kodfelsökningsvyn genom att välja felsökningsikonen på menyn till vänster eller genom att skriva Ctrl+Shift+D . Välj den felsökningskonfiguration < som modulen heter > Lokal felsökning (.NET Core) i listrutan.

       Anteckning

       Om .NET Core inte är konsekvent med programsökvägen i måste du uppdatera programsökvägen i manuellt så att den matchar i TargetFramework launch.json launch.json .csproj-filen så att Visual Studio Code kan starta det här TargetFramework programmet.

   • Node.js

     • I den Visual Studio Code-integrerade terminalen < > ändrar du katalogen till mappen med modulnamnet och kör sedan följande kommando för att installera Node-paket

       npm install
       

     • Öppna filen och app.js lägg till en brytpunkt.

     • Gå till Visual Studio kodfelsökningsvyn genom att välja felsökningsikonen på menyn till vänster eller genom att skriva Ctrl+Shift+D . Välj den felsökningskonfiguration < som modulnamnet > Lokal felsökning (Node.js) i listrutan.

   • Java

     • Öppna filen och App.java lägg till en brytpunkt.

     • Gå till Visual Studio kodfelsökningsvyn genom att välja felsökningsikonen på menyn till vänster eller genom att skriva Ctrl+Shift+D . Välj den felsökningskonfiguration < som modulnamnet > Lokal felsökning (Java) i listrutan.

2. Klicka på Starta felsökning eller tryck på F5 för att starta felsökningssessionen.

3. I den Visual Studio Code-integrerade terminalen kör du följande kommando för att skicka Hello World meddelande till modulen. Det här är kommandot som visas i föregående steg när du konfigurerade IoT Edge simulatorn.

   curl --header "Content-Type: application/json" --request POST --data '{"inputName": "input1","data":"hello world"}' http://localhost:53000/api/v1/messages
   

   Anteckning

   Om du använder en Windows bör du kontrollera att gränssnittet för den integrerade Visual Studio Code är Git Bash eller WSL Bash. Du kan inte köra curl kommandot från en PowerShell- eller kommandotolk.

   Tips

   Du kan också använda PostMan eller andra API-verktyg för att skicka meddelanden via i stället för curl .

4. I Visual Studio kodfelsökningsvyn visas variablerna i den vänstra panelen.

5. Om du vill stoppa felsökningssessionen väljer du knappen Stoppa eller trycker på Skift + F5 och kör sedan Azure IoT Edge: Stoppa IoT Edge Simulator i kommandopaletten för att stoppa simulatorn och rensa.

Felsök i anslutningsläge med IoT Edge Simulator (C#, Node.js, Java, Azure Functions)

Din standardlösning innehåller två moduler, en är en simulerad temperatursensormodul och den andra är pipe-modulen. Den simulerade temperatursensorn skickar meddelanden till pipe-modulen och sedan skickas meddelandena till IoT Hub. I modulmappen som du skapade finns det flera Docker-filer för olika containertyper. Använd någon av de filer som slutar med filnamnstillägget .debug för att skapa modulen för testning.

Felsökning i anslutningsläge stöds för närvarande endast på följande sätt:

• C#-moduler, inklusive för Azure Functions, stöder felsökning i Linux amd64-containrar
• Node.js-moduler stöder felsökning i Linux amd64- och arm32v7-containrar och Windows amd64-containrar
• Java-moduler stöder felsökning i Linux amd64- och arm32v7-containrar

Konfigurera IoT Edge simulator för IoT Edge lösning

På utvecklingsdatorn kan du starta en IoT Edge-simulator i stället för att installera IoT Edge säkerhetsdaemon så att du kan köra din IoT Edge lösning.

1. På fliken Explorer till vänster expanderar du Azure IoT Hub avsnittet. Högerklicka på ditt enhets-ID IoT Edge och välj sedan Konfigurera IoT Edge-simulatorn för att starta simulatorn med enhetens anslutningssträng.

2. Du kan se IoT Edge simulatorn har ställts in genom att läsa förloppsdetaljerna i den integrerade terminalen.

Skapa och köra container för felsökning och felsökning i anslutningsläge

1. Öppna modulfilen ( Program.cs , , eller ) och lägg till en app.js App.java <your module name>.cs brytpunkt.

2. I Visual Studio Code Explorer-vyn högerklickar du på filen för din lösning och väljer sedan Skapa och deployment.debug.template.json kör IoT Edge i Simulator. Du kan titta på alla modulcontainerloggar i samma fönster. Du kan också gå till Docker-vyn för att se containerstatus.

   

3. Gå till Visual Studio kodfelsökningsvyn och välj konfigurationsfilen för felsökning för modulen. Namnet på felsökningsalternativet bör likna < modulnamnet Fjärrfelsökning >

4. Välj Starta felsökning eller tryck på F5. Välj den process som du vill koppla till.

5. I Visual Studio kodfelsökningsvyn visas variablerna i den vänstra panelen.

6. Om du vill stoppa felsökningssessionen väljer du först knappen Stoppa eller trycker på Skift + F5 och väljer sedan Azure IoT Edge: Stoppa IoT Edge simulatorn från kommandopaletten.

Felsöka en modul med IoT Edge körning

Det finns flera Docker-filer för olika containertyper i varje modulmapp. Använd någon av de filer som slutar med filnamnstillägget .debug för att skapa modulen för testning.

När du felsöker moduler med den här metoden körs modulerna ovanpå den IoT Edge körningen. Enheten IoT Edge och din Visual Studio Code kan finnas på samma dator, eller vanligtvis finns Visual Studio Code på utvecklingsdatorn och IoT Edge-körningen och modulerna körs på en annan fysisk dator. För att kunna felsöka från Visual Studio Code måste du:

• Konfigurera din IoT Edge-enhet, skapa dina IoT Edge-moduler med .debug Dockerfile och distribuera sedan till den IoT Edge enheten.
• Exponera IP-adressen och porten för modulen så att felsökaren kan kopplas.
• Uppdatera så launch.json att Visual Studio Code kan ansluta till processen i containern på fjärrdatorn. Den här filen finns i .vscode mappen på arbetsytan och uppdateras varje gång du lägger till en ny modul som stöder felsökning.

Skapa och distribuera modulen till IoT Edge enhet

1. I Visual Studio Code öppnar du filen som innehåller felsökningsversionen av modulavbildningarna deployment.debug.template.json med rätt createOptions värden inställda.

2. Om du utvecklar din modul i Python följer du dessa steg innan du fortsätter:

   • Öppna filen och main.py lägg till den här koden efter importavsnittet:

     import ptvsd
     ptvsd.enable_attach(('0.0.0.0',  5678))
     

   • Lägg till följande kodrad i motringningsprogrammet som du vill felsöka:

     ptvsd.break_into_debugger()
     

     Om du till exempel vill felsöka funktionen receive_message_handler infogar du den kodraden enligt nedan:

   def receive_message_handler(message):
       ptvsd.break_into_debugger()
       global RECEIVED_MESSAGES
       RECEIVED_MESSAGES += 1
       if message.input_name == "input1":
           print("Message received on input1")
           print( "    Data: <<{}>>".format(message.data) )
           print( "    Properties: {}".format(message.custom_properties))
           print( "    Total calls received: {}".format(RECEIVED_MESSAGES))
           print("Forwarding message to output1")
           client.send_message_to_output(message, "output1")
           print("Message successfully forwarded")
   
   

3. I kommandopaletten Visual Studio Code:

   1. Kör kommandot Azure IoT Edge: Build and Push IoT Edge solution.

   2. Välj deployment.debug.template.json filen för lösningen.

4. I avsnittet Azure IoT Hub enheter i Visual Studio Code Explorer:

   1. Högerklicka på ett IoT Edge enhets-ID och välj sedan Skapa distribution för enskild enhet.

      Tips

      Bekräfta att den enhet som du har valt är en IoT Edge-enhet genom att välja den för att expandera listan över moduler och verifiera förekomsten av $edgeHub och $edgeAgent. Varje IoT Edge enhet innehåller dessa två moduler.

   2. Navigera till lösningens konfigurationsmapp, välj filen deployment.debug.amd64.json och välj sedan Välj Distributionsmanifest för Edge.

Du ser att distributionen har skapats med ett distributions-ID i den integrerade terminalen.

Du kan kontrollera containerstatusen genom att köra docker ps kommandot i terminalen. Om din Visual Studio Code och IoT Edge körs på samma dator kan du också kontrollera statusen i dockervyn Visual Studio Code.

Exponera IP-adressen och porten för modulen för felsökningsprogrammet

Du kan hoppa över det här avsnittet om dina moduler körs på samma dator som Visual Studio Code, eftersom du använder localhost för att ansluta till containern och redan har rätt portinställningar i Dockerfile för felsökning, containerinställningar för modulen och createOptions launch.json filen. Om modulerna och Visual Studio Code körs på separata datorer följer du stegen för ditt utvecklingsspråk.

• C#, inklusive Azure Functions

  Konfigurera SSH-kanalen på utvecklingsdatorn och IoT Edge och redigera sedan filen som ska launch.json bifogas.

• Node.js

  • Kontrollera att modulen på datorn som ska felsökas körs och är redo för att felsökare ska anslutas och att port 9229 kan nås externt. Du kan kontrollera detta genom att http://<target-machine-IP>:9229/json öppna på felsökningsdatorn. Den här URL:en bör visa information Node.js modulen som ska felsökas.

  • På utvecklingsdatorn öppnar du Visual Studio Code launch.json < > och redigerar sedan så att adressvärdet för modulens namn Profil för fjärrfelsökning (Node.js) (eller < > modulnamnet Fjärrfelsökning (Node.js i Windows Container) om modulen körs som en Windows-container) är IP-adressen för den dator som felsöks.

• Java

  • Skapa en SSH-tunnel till datorn som ska felsökas genom att köra ssh -f <username>@<target-machine> -L 5005:127.0.0.1:5005 -N .

  • På utvecklingsdatorn öppnar du Visual Studio Code < > och redigerar modulnamnet Remote Debug (Java)-profil i så att du kan ansluta launch.json till måldatorn. Mer information om hur du redigerar och felsöker Java med Visual Studio Code finns i launch.json avsnittet om hur du konfigurerar felsökningsprogrammet.

• Python

  • Kontrollera att port 5678 på datorn som ska felsökas är öppen och tillgänglig.

  • I koden som du tidigare infogade i ändrar du ptvsd.enable_attach(('0.0.0.0', 5678)) main.py 0.0.0.0 till IP-adressen för datorn som ska felsökas. Skapa, push-distribuera IoT Edge modulen igen.

  • På utvecklingsdatorn öppnar du Visual Studio Code launch.json host < > och redigerar sedan så att värdet för modulnamnet Remote Debug (Python) profile använder MÅLDATORNs IP-adress i stället för localhost .

Felsöka modulen

1. I Visual Studio Code Debug (Felsökningsvy för felsökning) väljer du konfigurationsfilen för felsökning för modulen. Namnet på felsökningsalternativet bör likna < modulnamnet Fjärrfelsökning >

2. Öppna modulfilen för utvecklingsspråket och lägg till en brytpunkt:

   • Azure-funktion (C#): Lägg till brytpunkten i filen <your module name>.cs .
   • C#: Lägg till brytpunkten i filen Program.cs .
   • Node.js: Lägg till brytpunkten i filen app.js .
   • Java: Lägg till brytpunkten i filen App.java .
   • Python: Lägg till brytpunkten i filen main.py i återanropsmetoden där du lade till ptvsd.break_into_debugger() raden.
   • C: Lägg till brytpunkten i filen main.c .

3. Välj Starta felsökning eller F5. Välj den process som du vill koppla till.

4. I Visual Studio Code Debug visas variablerna i den vänstra panelen.

Skapa och felsöka en modul via fjärrinstallation

Med de senaste ändringarna i både Docker- och Moby-motorerna för att stödja SSH-anslutningar och en ny inställning i Azure IoT Tools som möjliggör loggning av miljöinställningar i kommandopaletten för Visual Studio Code och Azure IoT Edge-terminaler kan du nu skapa och felsöka moduler på fjärranslutna enheter.

Mer information och stegvisa instruktioner finns i det här blogginlägget för IoT-utvecklare.

Nästa steg

När du har skapat modulen kan du lära dig hur du distribuerar Azure IoT Edge moduler från Visual Studio Code.

Om du vill utveckla moduler för IoT Edge-enheter, förstå och använda Azure IoT Hub-SDK:er.