Dela via

Felsöka Azure IoT Edge-moduler med Visual Studio Code

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

Viktigt!

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

Den här artikeln beskriver hur du använder Visual Studio Code för att felsöka IoT Edge-moduler på flera språk. På utvecklingsdatorn använder du Visual Studio Code för att ansluta och felsöka modulen i en lokal container eller en fjärrmodulcontainer.

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

  • Kommandoradsverktyget azure IoT Edge Dev Tool (CLI). Det här verktyget är att föredra för utveckling.
  • Azure IoT Edge-verktyg för Visual Studio Code-tillägget . Tillägget är i underhållsläge.

Välj verktygsversionen med hjälp av knappen för verktygsväljaren i början av den här artikeln.

Visual Studio Code stöder skrivning av IoT Edge-moduler på följande programmeringsspråk:

  • C# och C# Azure Functions
  • C
  • python
  • Node.js
  • Java

Azure IoT Edge fungerar med dessa enhetsarkitekturer:

  • AMD64
  • ARM32v7
  • ARM64

Mer information om operativsystem, språk och arkitekturer som stöds finns i Stöd för språk och arkitektur.

När du använder Visual Studio Code IoT Edge-tillägget kan du även starta och felsöka modulkoden i IoT Edge-simulatorn.

Du kan också använda en Windows-utvecklingsdator och felsöka moduler i en Linux-container med hjälp av IoT Edge för Linux i Windows (EFLOW). Mer information om hur du använder EFLOW för att utveckla moduler finns i Självstudie: Utveckla IoT Edge-moduler med Linux-containrar med IoT Edge för Linux i Windows.

Om du är ny på felsökningsfunktionerna i Visual Studio Code, se Felsökning i Visual Studio Code.

Förutsättningar

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

Om du vill installera de verktyg som krävs för utveckling och felsökning slutför du självstudien Utveckla Azure IoT Edge-moduler med hjälp av Visual Studio Code .

Installera Visual Studio Code.

Lägg till följande tillägg:

Om du vill felsöka modulen på en enhet behöver du:

Felsöka utan en container med IoT Edge-simulatorn

IoT Edge-simulatorn är ett verktyg som körs på utvecklingsdatorn och simulerar beteendet för en enda IoT Edge-enhet. Du kan använda IoT Edge-simulatorn för att utveckla och testa dina IoT Edge-moduler utan en fysisk enhet eller en fullständig IoT Edge-enhetskörning.

Följande felsökningssteg förutsätter att du redan har skapat en anpassad modul. Om du inte har skapat en anpassad modul följer du stegen i självstudiekursen Utveckla Azure IoT Edge-moduler med hjälp av Visual Studio Code .

Det går inte att felsöka en modul utan en container när du använder C eller Python.

Felsöka i anslutningsläge med IoT Edge-simulatorn

Felsökning i kopplingsläge är inte tillgängligt för C eller Python.

Felsöka en modul med IoT Edge-körningen

Varje modulmapp innehåller flera Docker-filer för olika containertyper. Använd valfri fil som slutar med tillä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å IoT Edge-körningen. IoT Edge-enheten och Visual Studio Code kan köras på samma dator, men vanligtvis körs Visual Studio Code på utvecklingsdatorn medan IoT Edge-körningen och modulerna körs på en annan fysisk dator. Så här felsöker du från Visual Studio Code:

  • Konfigurera din IoT Edge-enhet, skapa dina IoT Edge-moduler med .debug Dockerfile och distribuera sedan till IoT Edge-enheten.
  • Uppdatera launch.json så att Visual Studio Code kan ansluta till processen i en container på fjärrdatorn. Du hittar den här filen i .vscode mappen på arbetsytan och uppdateras varje gång du lägger till en ny modul som stöder felsökning.
  • Använd fjärr-SSH-felsökning för att ansluta till containern på fjärrdatorn.

Skapa och distribuera din modul till en IoT Edge-enhet

Öppna deployment.debug.template.json-distributionsmanifestfilen i Visual Studio Code. Distributionsmanifestet beskriver de moduler som ska konfigureras på den riktade IoT Edge-enheten. Uppdatera dina autentiseringsuppgifter för Azure Container Registry och modulavbildningar med rätt createOptions värden före distributionen. Mer information om createOption-värden finns i Konfigurera alternativ för containerskapande för IoT Edge-moduler.

  1. Om du använder ett Azure Container Registry för att lagra modulavbildningen lägger du till > i deployment.debug.template.json. Ersätt myacr med ditt eget registernamn på båda platserna och ange lösenordet och inloggningsserveradressen . Till exempel:

    "modulesContent": {
"$edgeAgent": {
  "properties.desired": {
    "schemaVersion": "1.1",
    "runtime": {
      "type": "docker",
      "settings": {
        "minDockerVersion": "v1.25",
        "loggingOptions": "",
        "registryCredentials": {
          "myacr": {
            "username": "myacr",
            "password": "<your_azure_container_registry_password>",
            "address": "myacr.azurecr.io"
          }
        }
      }
    },
...

  2. Lägg till eller ersätt följande strängifierade innehåll till createOptions-värdet för varje system (edgeHub och edgeAgent) och anpassad modul (till exempel filtermodul) i listan. Ändra värdena om det behövs.

    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"

    Till exempel bör filtermodulkonfigurationen likna:

    "filtermodule": {
"version": "1.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
    "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
    "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}
  1. Kör kommandot Azure IoT Edge: Build and Push IoT Edge solution i Visual Studio Code-kommandopaletten.
  2. deployment.debug.template.json Välj filen för din lösning.
  3. I avsnittet i Visual Studio Code Explorer-vyn högerklickar du på IoT Edge-enhetsnamnet för distribution och väljer >

    Dricks

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

  4. Gå till lösningens konfigurationsmapp, välj filen och välj sedan Välj Edge-distributionsmanifest.deployment.debug.amd64.json

Kontrollera containerstatusen från enheten eller den virtuella datorn genom att docker ps köra kommandot i en terminal. Du bör se containern i listan när du har kört kommandot. Om Visual Studio Code och IoT Edge-körningen körs på samma dator kontrollerar du statusen i Visual Studio Code Docker-vyn.

Viktigt!

Om du använder ett privat register som Azure Container Registry för dina avbildningar kan du behöva autentisera för att skicka avbildningar. Använd docker login <Azure Container Registry login server> eller az acr login --name <Azure Container Registry name> för att autentisera.

Logga in på Docker

Ange dina autentiseringsuppgifter för containerregistret till Docker så att den kan skicka containeravbildningen till lagring i registret.

  1. Logga in på Docker med autentiseringsuppgifterna för Azure Container Registry som du sparade när du skapade registret.

    docker login -u <Azure Container Registry username> -p <Azure Container Registry password> <Azure Container Registry login server>

    Du kan få en säkerhetsvarning som rekommenderar användning av --password-stdin. Även om det är en rekommenderad metod för produktionsscenarier är det utanför omfånget för den här självstudien. Mer information finns i docker-inloggningsreferensen.

  2. Logga in på Azure Container Registry. Du kan behöva installera Azure CLI för att använda az kommandot. Det här kommandot frågar efter ditt användarnamn och lösenord som finns i containerregistret i Inställningar>Åtkomstnycklar.

    az acr login -n <Azure Container Registry name>

Dricks

Om du loggas ut någon gång i den här självstudien upprepar du inloggningsstegen docker och Azure Container Registry för att fortsätta.

Docker-avbildning för byggmodul

Använd modulens Dockerfile för att skapa Docker-avbildningen.

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

Om du till exempel vill skapa avbildningen för det lokala registret eller ett Azure Container Registry använder du följande kommandon:

# Build the image for the local registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t localhost:5000/filtermodule:0.0.1-amd64 "./modules/filtermodule"

# Or build the image for an Azure Container Registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t myacr.azurecr.io/filtermodule:0.0.1-amd64 "./modules/filtermodule"

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/filtermodule:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry
az acr login --name myacr
docker push myacr.azurecr.io/filtermodule:0.0.1-amd64

Distribuera modulen till IoT Edge-enheten

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.template.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-nyckel för delad åtkomst i Azure Portal i IoT Hub >>.

Felsöka din modul

Om du vill felsöka moduler på en fjärrenhet använder du Fjärr-SSH-felsökning i Visual Studio Code.

Aktivera fjärrfelsökning i Visual Studio Code genom att installera fjärrutvecklingstillägget. Mer information om fjärrfelsökning i Visual Studio Code finns i Fjärrutveckling i Visual Studio Code.

Mer information om hur du använder fjärr-SSH-felsökning i Visual Studio Code finns i Fjärrutveckling med hjälp av SSH.

I felsökningsvyn i Visual Studio Code väljer du konfigurationsfilen för felsökning för modulen. Som standard använder .debug Dockerfile, modulens containerinställningar createOptions och launch.json filen localhost.

Välj Starta felsökning eller F5 och välj sedan den process som ska kopplas till. I felsökningsvyn i Visual Studio Code ser du variabler i den vänstra panelen.

Felsöka med Docker remote SSH

Docker- och Moby-motorerna stöder SSH-anslutningar till containrar så att du kan felsöka i Visual Studio Code som är anslutet till en fjärrenhet. Du måste uppfylla följande krav innan du kan använda den här funktionen.

Kraven för fjärr-SSH-felsökning kan variera beroende på vilket språk du använder. I följande avsnitt beskrivs konfigurationen för .NET. Mer information om andra språk finns i Fjärrutveckling med hjälp av SSH för en översikt. Information om hur du konfigurerar fjärrfelsökning finns i felsökningsavsnitt för varje språk i Visual Studio Code-dokumentationen.

Konfigurera Docker SSH-tunnlar

  1. Följ stegen i Docker SSH-tunnlar för att konfigurera SSH-tunnlar på utvecklingsdatorn. SSH-tunneltrafik kräver autentisering med offentliga/privata nyckelpar och en Docker-kontext som definierar fjärrenhetens slutpunkt.

  2. Anslutning till Docker kräver rotprivilegier. 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.

  3. I Visual Studio Code använder du kommandopaletten (Ctrl+Skift+P) för att utfärda kommandot Docker Context: Use för att aktivera Docker-kontexten som pekar på fjärrdatorn. Med det här kommandot kan både Visual Studio Code och Docker CLI använda fjärrdatorkontexten.

    Dricks

    Alla Docker-kommandon använder den aktuella kontexten. Kom ihåg att ändra tillbaka kontexten till standard när du är klar med felsökningen.

  4. Om du vill kontrollera att Docker-fjärrkontexten är aktiv anger du de containrar som körs på fjärrenheten:

    docker ps

    Utdata visar de containrar som körs på fjärrenheten, ungefär så här:

    PS C:\> docker ps        
CONTAINER ID   IMAGE                                                             COMMAND                   CREATED        STATUS         PORTS                                                                                                                                   NAMES
a317b8058786   myacr.azurecr.io/filtermodule:0.0.1-amd64                         "dotnet filtermodule…"    24 hours ago   Up 6 minutes                                                                                                                                           filtermodule
d4d949f8dfb9   mcr.microsoft.com/azureiotedge-hub:1.5                            "/bin/sh -c 'echo \"$…"   24 hours ago   Up 6 minutes   0.0.0.0:443->443/tcp, :::443->443/tcp, 0.0.0.0:5671->5671/tcp, :::5671->5671/tcp, 0.0.0.0:8883->8883/tcp, :::8883->8883/tcp, 1883/tcp   edgeHub
1f0da9cfe8e8   mcr.microsoft.com/azureiotedge-simulated-temperature-sensor:1.0   "/bin/sh -c 'echo \"$…"   24 hours ago   Up 6 minutes                                                                                                    
                                       tempSensor
66078969d843   mcr.microsoft.com/azureiotedge-agent:1.5                          "/bin/sh -c 'exec /a…"    24 hours ago   Up 6 minutes                                                                                                    
                                       edgeAgent

  5. I katalogen .vscode öppnar dulaunch.json i Visual Studio Code och lägger till en ny konfiguration. Välj Lägg till konfiguration och välj sedan den matchande mallen för fjärranslutning för modulen. Följande konfiguration är till exempel för .NET Core. Ändra värdet för parametern -H i PipeArgs till enhetens DNS-namn eller IP-adress.

    "configurations": [
{
  "name": "Remote Debug IoT Edge Module (.NET Core)",
  "type": "coreclr",
  "request": "attach",
  "processId": "${command:pickRemoteProcess}",
  "pipeTransport": {
    "pipeProgram": "docker",
    "pipeArgs": [
      "-H",
      "ssh://user@my-device-vm.eastus.cloudapp.azure.com:22",
      "exec",
      "-i",
      "filtermodule",
      "sh",
      "-c"
    ],
    "debuggerPath": "~/vsdbg/vsdbg",
    "pipeCwd": "${workspaceFolder}",
    "quoteArgs": true
  },
  "sourceFileMap": {
    "/app": "${workspaceFolder}/modules/filtermodule"
  },
  "justMyCode": true
},

Felsöka modulen via fjärranslutning

  1. I felsökningsvyn i Visual Studio Code väljer du felsökningskonfigurationen Remote Debug IoT Edge Module (.NET Core).

  2. Välj Starta felsökning eller välj F5. Välj den process som ska kopplas till.

  3. I felsökningsvyn i Visual Studio Code ser du variablerna i den vänstra panelen.

  4. I Visual Studio Code anger du brytpunkter i din anpassade modul.

  5. När en brytpunkt nås kan du inspektera variabler, stega igenom kod och felsöka modulen.

    Skärmbild av Visual Studio Code som är kopplad till en Docker-container på en fjärrenhet som pausats vid en brytpunkt.

Kommentar

Föregående exempel visar hur du felsöker IoT Edge-moduler på fjärrcontainrar. Exemplet lägger till en fjärransluten Docker-kontext och ändringar i Docker-behörigheterna på fjärrenheten. När du har felsökt modulerna ställer du in Docker-kontexten som standard och tar bort behörigheter från ditt användarkonto.

I det här blogginlägget för IoT Developer finns ett exempel på hur du använder en Raspberry Pi-enhet.

Nästa steg

När du har skapat modulen får du lära dig hur du distribuerar Azure IoT Edge-moduler.

Om du vill utveckla moduler för dina IoT Edge-enheter kan du lära dig mer om och använda Azure IoT Hub-SDK:er.