Självstudie: Utveckla IoT Edge-moduler med Visual Studio Code

  • Artikel

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

Viktigt!

IoT Edge 1.4 är den version som stöds. Om du har en tidigare version läser du Uppdatera IoT Edge.

I den här självstudien går vi igenom hur du utvecklar och distribuerar din egen kod till en IoT Edge-enhet. Du kan använda Azure IoT Edge-moduler för att distribuera kod som implementerar din affärslogik direkt på dina IoT Edge-enheter. I snabbstarten Distribuera kod till en Linux-enhet skapade du en IoT Edge-enhet och distribuerade en modul från Azure Marketplace.

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

  • Kommandorad för 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.

Använd knappen för verktygsväljaren i början av den här artikeln för att välja verktygsversionen.

I den här självstudien lär du dig att:

  • Konfigurera utvecklingsdatorn.
  • Använd IoT Edge-verktygen för att skapa ett nytt projekt.
  • Skapa projektet som en Docker-container och lagra det i ett Azure-containerregister.
  • Distribuera koden till en IoT Edge-enhet.

IoT Edge-modulen som du skapar i den här självstudien filtrerar temperaturdata som enheten genererar. Den skickar enbart meddelanden uppströms om temperaturen överskrider ett angivet tröskelvärde. Den här typen av analys vid kanten är användbar när du vill minska mängden data som skickas till och lagras i molnet.

Förutsättningar

En utvecklingsdator:

  • Använd din egen dator eller en virtuell dator.
  • Utvecklingsdatorn måste ha stöd för kapslad virtualisering för att köra en containermotor.
  • De flesta operativsystem som kan köra en containermotor kan användas för att utveckla IoT Edge-moduler för Linux-enheter. Den här självstudien använder en Windows-dator, men pekar på kända skillnader i macOS eller Linux.
  • Installera Visual Studio Code
  • Installera Azure CLI.

En Azure IoT Edge-enhet:

Molnresurser:

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Dricks

För vägledning om interaktiv felsökning i Visual Studio Code eller Visual Studio 2022:

I den här självstudien lär du dig utvecklingsstegen för Visual Studio Code.

Nyckelbegrepp

Den här självstudien går igenom utvecklingen av en IoT Edge-modul. En IoT Edge-modul är en container med körbar kod. Du kan distribuera en eller flera moduler till en IoT Edge-enhet. Moduler utför specifika uppgifter som att mata in data från sensorer, rensa och analysera data eller skicka meddelanden till en IoT-hubb. Mer information finns i Förstå Azure IoT Edge-moduler.

När du utvecklar IoT Edge-moduler är det viktigt att förstå skillnaden mellan utvecklingsdatorn och mål-IoT Edge-enheten där modulen distribueras. Containern som du skapar för att lagra modulkoden måste matcha operativsystemet (OS) för målenheten. Det vanligaste scenariot är till exempel att någon utvecklar en modul på en Windows-dator som tänker rikta in sig på en Linux-enhet som kör IoT Edge. I så fall skulle containeroperativsystemet vara Linux. När du går igenom den här självstudien bör du tänka på skillnaden mellan operativsystemet för utvecklingsdatorn och containeroperativsystemet.

Dricks

Om du använder IoT Edge för Linux i Windows är målenheten i ditt scenario den virtuella Linux-datorn, inte Windows-värden.

Den här självstudien riktar sig till enheter som kör IoT Edge med Linux-containrar. Du kan använda önskat operativsystem så länge utvecklingsdatorn kör Linux-containrar. Vi rekommenderar att du använder Visual Studio Code för att utveckla med Linux-containrar, så det är vad den här självstudien använder. Du kan också använda Visual Studio, även om det finns skillnader i stöd mellan de två verktygen.

I följande tabell visas utvecklingsscenarier som stöds för Linux-containrar i Visual Studio Code och Visual Studio.

Visual Studio-koden Visual Studio 2019/2022
Linux-enhetsarkitektur Linux AMD64
Linux ARM32v7
Linux ARM64		 Linux AMD64
Linux ARM32
Linux ARM64
Azure-tjänster Azure Functions
Azure Stream Analytics
Azure Machine Learning
Språk C
C#
Java
Node.js
Python		 C
C#
Mer information Azure IoT Edge för Visual Studio Code Azure IoT Edge-verktyg för Visual Studio 2019
Azure IoT Edge-verktyg för Visual Studio 2022

Installera containermotorn

IoT Edge-moduler paketeras som containrar, så du behöver ett Docker-kompatibelt containerhanteringssystem på utvecklingsdatorn för att skapa och hantera dem. Vi rekommenderar Docker Desktop för utveckling på grund av dess funktionsstöd och popularitet. Med Docker Desktop i Windows kan du växla mellan Linux-containrar och Windows-containrar så att du kan utveckla moduler för olika typer av IoT Edge-enheter.

Använd Docker-dokumentationen för att installera på utvecklingsdatorn:

Konfigurera verktyg

Installera Python-baserade Azure IoT Edge Dev Tool för att skapa din IoT Edge-lösning. Det finns två alternativ:

  • Använda den fördefinierade IoT Edge Dev-containern
  • Installera verktyget med iotedgedev-utvecklingskonfigurationen

Viktigt!

Azure IoT Edge-verktygen för Visual Studio Code-tillägget är i underhållsläge. Det föredragna utvecklingsverktyget är kommandoradsverktyget (CLI) Azure IoT Edge Dev Tool.

Använd IoT-tilläggen för Visual Studio Code för att utveckla IoT Edge-moduler. Dessa tillägg erbjuder projektmallar, automatiserar skapandet av distributionsmanifestet och gör att du kan övervaka och hantera IoT Edge-enheter. I det här avsnittet installerar du Visual Studio Code och IoT-tillägget och konfigurerar sedan ditt Azure-konto för att hantera IoT Hub-resurser inifrån Visual Studio Code.

  1. Installera Azure IoT Edge-tillägget .

  2. Installera Azure IoT Hub-tillägget .

  3. När du har installerat tillägg öppnar du kommandopaletten genom att välja Visa>kommandopalett.

  4. I kommandopaletten igen söker du efter och väljer Azure IoT Hub: Välj IoT Hub. Följ anvisningarna för att välja din Azure-prenumeration och IoT Hub.

  5. Öppna explorer-avsnittet i Visual Studio Code genom att antingen välja ikonen i aktivitetsfältet till vänster eller genom att välja Visa>utforskaren.

  6. Längst ned i explorer-avsnittet expanderar du menyn komprimerad Azure IoT Hub/Devices . Du bör se de enheter och IoT Edge-enheter som är associerade med den IoT Hub som du valde via kommandopaletten.

Installera språkspecifika verktyg

Installera verktyg som är specifika för det språk som du utvecklar i:

Skapa ett containerregister

I den här självstudien använder du Azure IoT Edge - och Azure IoT Hub-tilläggen för att skapa en modul och skapa en containeravbildning från filerna. Sedan pushar du avbildningen till ett register som lagrar och hanterar dina avbildningar. Slutligen, distribuerar du din avbildning från ditt register så det kör på din IoT Edge-enhet.

Viktigt!

Azure IoT Edge Visual Studio Code-tillägget är i underhållsläge.

Du kan använda valfritt Docker-kompatibelt register för att lagra dina containeravbildningar. Två populära Docker-registertjänster är Azure Container Registry och Docker Hub. I den här kursen använder vi Azure Container Registry.

Om du inte redan har ett containerregister följer du dessa steg för att skapa ett nytt i Azure:

  1. I Azure Portal väljer du Skapa en resurs>Container>Containerregister.

  2. Ange följande obligatoriska värden för att skapa containerregistret:

    Fält Värde
    Prenumeration Välj en prenumeration i listrutan.
    Resursgrupp Använd samma resursgrupp för alla testresurser som du skapar under snabbstarterna och självstudierna i IoT Edge. Till exempel IoTEdgeResources.
    Registernamn Ange ett unikt namn.
    Plats Välj en plats i närheten av dig.
    SKU Välj Grundläggande.

  3. Välj Granska + skapa och sedan Skapa.

  4. Välj ditt nya containerregister i avsnittet Resurser på startsidan för Azure-portalen för att öppna det.

  5. I det vänstra fönstret i containerregistret väljer du Åtkomstnycklar på menyn under Inställningar.

    Screenshot of the Access Keys menu location.

  6. Aktivera administratörsanvändare med växlingsknappen och visa användarnamnetoch lösenordet för containerregistret.

  7. Kopiera värdena för inloggningsserver, användarnamn och lösenord och spara dem någonstans bekvämt. Du använder dessa värden i den här självstudien för att ge åtkomst till containerregistret.

Skapa ett nytt modulprojekt

Azure IoT Edge-tillägget erbjuder projektmallar för alla IoT Edge-modulspråk som stöds i Visual Studio Code. Dessa mallar har alla filer och kod som du behöver för att distribuera en arbetsmodul för att testa IoT Edge, eller ge dig en startpunkt för att anpassa mallen med din egen affärslogik.

Skapa en projektmall

IoT Edge Dev Tool förenklar Azure IoT Edge-utveckling till kommandon som drivs av miljövariabler. Du kommer igång med IoT Edge-utveckling med IoT Edge Dev Container- och IoT Edge-lösningsställningar som har en standardmodul och alla nödvändiga konfigurationsfiler.

  1. Skapa en katalog för din lösning med valfri sökväg. Ändra till din iotedgesolution katalog.

    mkdir c:\dev\iotedgesolution
cd c:\dev\iotedgesolution

  2. Använd init-kommandot iotedgedev-lösningen för att skapa en lösning och konfigurera din Azure IoT Hub på det utvecklingsspråk som du väljer.

    iotedgedev solution init --template csharp

I init-skriptet iotedgedev-lösningen uppmanas du att utföra flera steg, bland annat:

  • Autentisera till Azure
  • Välj en Azure-prenumeration
  • Välj eller skapa en resursgrupp
  • Välj eller skapa en Azure IoT Hub
  • Välj eller skapa en Azure IoT Edge-enhet

Använd Visual Studio Code och Azure IoT Edge-tillägget . Du börjar med att skapa en lösning och sedan generera den första modulen i den 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(Ny IoT Edge-lösning).
  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 på lösningen.
  5. Välj en modulmall för det utvecklingsspråk som du föredrar som 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 avbildningslagringsplats. Visual Studio Code fyller i modulnamnet automatiskt 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.>

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.

När lösningen har skapats finns dessa huvudfiler i lösningen:

  • En .vscode-mapp innehåller konfigurationsfilen launch.json.

  • En modulmapp som har undermappar för varje modul. I undermappen för varje modul styr module.json-filen hur moduler skapas och distribueras.

  • En .env-fil visar dina miljövariabler. Miljövariabeln för containerregistret är localhost:5000 som standard.

  • Två moduldistributionsfiler med namnet deployment.template.json och deployment.debug.template.json lista de moduler som ska distribueras till enheten. Som standard innehåller listan IoT Edge-systemmodulerna (edgeAgent och edgeHub) och exempelmoduler som:

    Kommentar

    De exakta moduler som installeras kan bero på vilket språk du väljer.

Ange IoT Edge-körningsversion

Den senaste stabila versionen av IoT Edge-systemmodulen är 1.4. Ställ in systemmodulerna på version 1.4.

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

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

    "systemModules": {
    "edgeAgent": {

        "image": "mcr.microsoft.com/azureiotedge-agent:1.4",

    "edgeHub": {

        "image": "mcr.microsoft.com/azureiotedge-hub:1.4",

Ange dina registerautentiseringsuppgifter till IoT Edge-agenten

Miljöfilen lagrar autentiseringsuppgifterna för containerregistret och delar dem med körningsmiljön för IoT Edge. Körningen behöver dessa autentiseringsuppgifter för att hämta containeravbildningarna till IoT Edge-enheten.

IoT Edge-tillägget försöker hämta dina autentiseringsuppgifter för containerregistret från Azure och fylla i dem i miljöfilen.

Kommentar

Miljöfilen skapas bara om du tillhandahåller en avbildningslagringsplats för modulen. Om du accepterade localhost-standardinställningarna för att testa och felsöka lokalt behöver du inte deklarera miljövariabler.

Kontrollera om dina autentiseringsuppgifter finns. Om inte lägger du till dem nu:

  1. Om Azure Container Registry är ditt register anger du ett användarnamn och lösenord för Azure Container Registry. Hämta dessa värden från containerregistrets meny Inställningar> Åtkomstnycklar i Azure-portalen.

  2. Öppna .env-filen i modullösningen.

  3. Lägg till de användarnamns - och lösenordsvärden som du kopierade från azure-containerregistret. Till exempel:

    CONTAINER_REGISTRY_SERVER="myacr.azurecr.io"
CONTAINER_REGISTRY_USERNAME="myacr"
CONTAINER_REGISTRY_PASSWORD="<registry_password>"

  4. Spara ändringarna i .env-filen .

Kommentar

I den här självstudien används autentiseringsuppgifter för administratörsinloggning för Azure Container Registry som ä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, till exempel tjänstens huvudnamn eller token med lagringsplatsomfattning. Mer information finns i Hantera åtkomst till containerregistret.

Målarkitektur

Du måste välja den arkitektur som du riktar in dig på för varje lösning, eftersom det påverkar hur containern skapas och körs. Standardvärdet är Linux AMD64. I den här självstudien använder vi en virtuell Ubuntu-dator som IoT Edge-enhet och behåller standardvärdet amd64.

Om du behöver ändra målarkitekturen för din lösning använder du följande steg.

  1. Öppna kommandopaletten och sök efter Azure IoT Edge: Ange standardmålplattform för Edge-lösning eller välj genvägsikonen i sidofältet längst ned i fönstret.

  2. I kommandopaletten väljer du målarkitekturen i listan med alternativ.

Målarkitekturen anges när du skapar containeravbildningen i ett senare steg.

Uppdatera modulen med anpassad kod

Varje mall innehåller exempelkod som tar simulerade sensordata från modulen SimulatedTemperatureSensor och dirigerar dem till IoT-hubben. Exempelmodulen tar emot meddelanden och skickar dem sedan vidare. Pipelinefunktionen visar ett viktigt begrepp i IoT Edge, vilket är hur moduler kommunicerar med varandra.

Varje modul kan ha flera indata- och utdataköer deklarerade i sin kod. IoT Edge-hubben som körs på enheten dirigerar meddelanden från utdata från en modul till indata från en eller flera moduler. Den specifika koden för att deklarera indata och utdata varierar mellan språk, men konceptet är detsamma i alla moduler. Mer information om routning mellan moduler finns i Deklarera vägar.

C#-exempelkoden som medföljer projektmallen använder Klassen ModuleClient från IoT Hub SDK för .NET.

  1. Öppna moduler filtermodule>>ModuleBackgroundService.cs i Visual Studio Code-utforskaren.

  2. Innan filtermodulens namnområde lägger du till tre användningssatser för typer som används senare:

    using System.Collections.Generic;     // For KeyValuePair<>
using Microsoft.Azure.Devices.Shared; // For TwinCollection
using Newtonsoft.Json;                // For JsonConvert

  3. Lägg till variabeln temperatureThreshold i klassen ModuleBackgroundService . Variabeln anger det värde som den uppmätta temperaturen måste överstiga för att data ska skickas till IoT-hubben.

    static int temperatureThreshold { get; set; } = 25;

  4. Lägg till klasserna MessageBody, Machine och Ambient . Dessa klasser definierar det förväntade schemat för brödtexten i inkommande meddelanden.

    class MessageBody
{
    public Machine machine {get;set;}
    public Ambient ambient {get; set;}
    public string timeCreated {get; set;}
}
class Machine
{
    public double temperature {get; set;}
    public double pressure {get; set;}
}
class Ambient
{
    public double temperature {get; set;}
    public int humidity {get; set;}
}

  5. Leta upp funktionen ExecuteAsync . Den här funktionen skapar och konfigurerar ett ModuleClient-objekt som gör att modulen kan ansluta till den lokala Azure IoT Edge-körningen för att skicka och ta emot meddelanden. När du har skapat ModuleClient läser koden temperatureThreshold-värdet från modultvillingens önskade egenskaper. Koden registrerar ett återanrop för att ta emot meddelanden från en IoT Edge-hubb via en slutpunkt med namnet input1.

    Ersätt anropet till metoden ProcessMessageAsync med ett nytt som uppdaterar namnet på slutpunkten och metoden som anropas när indata kommer. Lägg också till en SetDesiredPropertyUpdateCallbackAsync-metod för uppdateringar av önskade egenskaper. Om du vill göra den här ändringen ersätter du den sista raden i metoden ExecuteAsync med följande kod:

    // Register a callback for messages that are received by the module.
// await _moduleClient.SetInputMessageHandlerAsync("input1", PipeMessage, cancellationToken);

// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await _moduleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, _moduleClient);

// Attach a callback for updates to the module twin's desired properties.
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);

// Register a callback for messages that are received by the module. Messages received on the inputFromSensor endpoint are sent to the FilterMessages method.
await _moduleClient.SetInputMessageHandlerAsync("inputFromSensor", FilterMessages, _moduleClient);

  6. Lägg till metoden onDesiredPropertiesUpdate i klassen ModuleBackgroundService. Metoden tar emot uppdateringar av önskade egenskaper från modultvillingen och uppdaterar variabeln temperatureThreshold som ska matchas. Alla moduler har en egen modultvilling, vilket innebär att du kan konfigurera den kod som körs i en modul direkt från molnet.

    static Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
{
    try
    {
        Console.WriteLine("Desired property change:");
        Console.WriteLine(JsonConvert.SerializeObject(desiredProperties));

        if (desiredProperties["TemperatureThreshold"]!=null)
            temperatureThreshold = desiredProperties["TemperatureThreshold"];

    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error when receiving desired property: {0}", exception);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
    }
    return Task.CompletedTask;
}

  7. Lägg till metoden FilterMessages. Den här metoden anropas när modulen tar emot ett meddelande från IoT Edge-hubben. Den filtrerar ut meddelanden som rapporterar temperaturer under temperaturtröskelvärdet som angetts via modultvillingen. Den lägger också till egenskapen MessageType i meddelandet med värdet angivet som Avisering.

    async Task<MessageResponse> FilterMessages(Message message, object userContext)
{
    var counterValue = Interlocked.Increment(ref _counter);
    try
    {
        ModuleClient moduleClient = (ModuleClient)userContext;
        var messageBytes = message.GetBytes();
        var messageString = Encoding.UTF8.GetString(messageBytes);
        Console.WriteLine($"Received message {counterValue}: [{messageString}]");

        // Get the message body.
        var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);

        if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
        {
            Console.WriteLine($"Machine temperature {messageBody.machine.temperature} " +
                $"exceeds threshold {temperatureThreshold}");
            using (var filteredMessage = new Message(messageBytes))
            {
                foreach (KeyValuePair<string, string> prop in message.Properties)
                {
                    filteredMessage.Properties.Add(prop.Key, prop.Value);
                }

                filteredMessage.Properties.Add("MessageType", "Alert");
                await moduleClient.SendEventAsync("output1", filteredMessage);
            }
        }

        // Indicate that the message treatment is completed.
        return MessageResponse.Completed;
    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error in sample: {0}", exception);
        }
        // Indicate that the message treatment is not completed.
        var moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error in sample: {0}", ex.Message);
        // Indicate that the message treatment is not completed.
        ModuleClient moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
}

  8. Spara filen ModuleBackgroundService.cs .

  9. I Visual Studio Code-utforskaren öppnar du filen deployment.template.json i arbetsytan för IoT Edge-lösningen.

  10. Eftersom vi har ändrat namnet på slutpunkten som modulen lyssnar på måste vi också uppdatera vägarna i distributionsmanifestet så att edgeHub skickar meddelanden till den nya slutpunkten.

    Leta upp avsnittet vägar i modultvillingen $edgeHub . Uppdatera sensorTofiltermodule-vägen för att ersätta input1 med inputFromSensor:

    "sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/inputFromSensor\")"

  11. Lägg till modultvillingen filtermodul i distributionsmanifestet. Infoga följande JSON-innehåll längst ned i avsnittet modulesContent efter $edgeHub-modultvillingen:

       "filtermodule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }

  12. Spara filen deployment.template.json.

Skapa och push-överföra lösningen

Du har uppdaterat modulkoden och distributionsmallen för att förstå några viktiga distributionsbegrepp. Nu är du redo att skapa din modulcontaineravbildning och skicka den till containerregistret.

I Visual Studio Code öppnar du deployment.template.json-distributionsmanifestfilen. Distributionsmanifestet 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 och dina modulavbildningar med 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 lägger du till dina autentiseringsuppgifter i avsnittet modulesContent>edgeAgent>settings>registryCredentials i deployment.template.json. Ersätt myacr med ditt eget registernamn och ange lösenordet och inloggningsserveradressen . Till exempel:

"registryCredentials": {
    "myacr": {
        "username": "myacr",
        "password": "<your_acr_password>",
        "address": "myacr.azurecr.io"
    }
}

Lägg till eller ersätt följande strängifierade innehåll i värdet createOptions för varje system (edgeHub och edgeAgent) och anpassad modul (filtermodule och tempSensor) 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\"}]}}}"
}

Docker-avbildning för byggmodul

Öppna den integrerade Terminalen i Visual Studio Code genom att välja Terminal>Ny terminal.

dotnet publish Använd kommandot för att skapa containeravbildningen för Linux- och amd64-arkitekturen. Ändra katalogen till filtermodule-katalogen i projektet och kör kommandot dotnet publish .

dotnet publish --os linux --arch x64 /t:PublishContainer

För närvarande är verktygsmallen iotedgedev inriktad på .NET 7.0. Om du vill rikta in dig på en annan version av .NET kan du redigera filen filtermodule.csproj och ändra värdena TargetFramework och PackageReference . För att till exempel rikta in sig på .NET 8.0 bör filen filtermodule.csproj se ut så här:

<Project Sdk="Microsoft.NET.Sdk.Worker">
    <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.42.0" />
        <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
    </ItemGroup>
</Project>

Tagga docker-avbildningen med information, version och arkitektur för containerregistret. Ersätt myacr med ditt eget registernamn.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.1-amd64

Push-modul docker-avbildning

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 (ACR).

    docker login -u <ACR username> -p <ACR password> <ACR 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 måste 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 <ACR 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.

  3. 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. Replace myacr with your Azure Container Registry name.

az acr login --name myacr
docker push myacr.azurecr.io/filtermodule:0.0.1-amd64

Uppdatera distributionsmallen

Uppdatera distributionsmallen deployment.template.json med containerregistrets avbildningsplats. Om du till exempel använder ett Azure Container Registry-myacr.azurecr.io och avbildningen är filtermodule:0.0.1-amd64 uppdaterar du filtermodulkonfigurationen till:

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

I Visual Studio Code-utforskaren högerklickar du på filen deployment.template.json och väljer Build and Push IoT Edge Solution (Skapa och push-lösning för IoT Edge).

Kommandot build och push startar tre åtgärder. Först skapar den en ny mapp i lösningen med namnet config som innehåller det fullständiga distributionsmanifestet, inbyggt med information i distributionsmallen och andra lösningsfiler. För det andra körs docker build den för att skapa containeravbildningen baserat på lämplig dockerfile för målarkitekturen. Sedan körs docker push den för att skicka avbildningslagringsplatsen till containerregistret.

Den här processen kan ta flera minuter första gången, men det går snabbare nästa gång du kör kommandona.

Valfritt: Uppdatera modulen och avbildningen

Om du gör ändringar i modulkoden måste du återskapa och skicka modulavbildningen till containerregistret. Följ stegen i det här avsnittet för att uppdatera bygg- och containeravbildningen. Du kan hoppa över det här avsnittet om du inte har ändrat modulkoden.

Öppna filen deployment.amd64.json i den nyligen skapade konfigurationsmappen. Filnamnet återspeglar målarkitekturen, så det är annorlunda om du väljer en annan arkitektur.

Observera att de två parametrarna som hade platshållare nu innehåller rätt värden. I avsnittet registryCredentials hämtas ditt registeranvändarnamn och lösenord från .env-filen . Filtermodulen har den fullständiga avbildningslagringsplatsen med taggen namn, version och arkitektur från module.json-filen.

  1. Öppna filen module.json i mappen filtermodule .

  2. Ändra versionsnumret för modulbilden. Öka till exempel versionsnumret för korrigeringen till "version": "0.0.2" som om du gjorde en liten korrigering i modulkoden.

    Dricks

    Modulversioner aktiverar versionskontroll och gör att du kan testa ändringar på en liten uppsättning enheter innan du distribuerar uppdateringar till produktion. Om du inte ökar modulversionen innan du skapar och push-överför den skriver du över lagringsplatsen i containerregistret.

  3. Spara ändringarna i filen module.json .

Skapa och push-överför den uppdaterade avbildningen med en versionstagg för 0.0.2 . Om du till exempel vill skapa och push-överföra avbildningen för det lokala registret eller ett Azure-containerregister använder du följande kommandon:


# Build the container image for Linux and amd64 architecture.

dotnet publish --os linux --arch x64

# For local registry:
# Tag the image with version 0.0.2, x64 architecture, and the local registry.

docker tag filtermodule localhost:5000/filtermodule:0.0.2-amd64

# For Azure Container Registry:
# Tag the image with version 0.0.2, x64 architecture, and your container registry information. Replace **myacr** with your own registry name.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.2-amd64

Högerklicka på filen deployment.template.json igen och välj skapa och skicka IoT Edge-lösning igen.

Öppna filen deployment.amd64.json igen. Observera att byggsystemet inte skapar en ny fil när du kör kommandot build och push igen. I stället uppdateras samma fil för att återspegla ändringarna. Filtermodulavbildningen pekar nu på 0.0.2-versionen av containern.

Om du vill kontrollera vad kommandot build och push gjorde går du till Azure-portalen och går till containerregistret.

I containerregistret väljer du Lagringsplatser och filtrerar sedanmodul. Kontrollera att båda versionerna av avbildningen skickas till registret.

Screenshot of where to view both image versions in your container registry.

Felsöka

Om du får fel när du skapar och push-överför modulens avbildning har det ofta att göra med Docker-konfigurationen på utvecklingsdatorn. Använd följande kontroller för att granska konfigurationen:

  • Körde du docker login kommandot med de autentiseringsuppgifter som du kopierade från containerregistret? Dessa autentiseringsuppgifter skiljer sig från de som du använder för att logga in på Azure.
  • Stämmer containerlagringsplatsen? Har den rätt containerregisternamn och rätt modulnamn? Öppna filen module.json i mappen filtermodule för att kontrollera. Lagringsplatsens värde bör se ut som registernamn.azurecr.io/filtermodule>.<
  • Om du använde ett annat namn än filtermodulen för modulen, är namnet konsekvent i hela lösningen?
  • Kör datorn samma typ av containrar som du skapar? Den här självstudien är avsedd för Linux IoT Edge-enheter, så Visual Studio Code bör säga amd64 eller arm32v7 i sidofältet och Docker Desktop ska köra Linux-containrar.

Distribuera moduler till enheten

Du har kontrollerat att det finns byggda containeravbildningar lagrade i containerregistret, så det är dags att distribuera dem till en enhet. Kontrollera att din IoT Edge-enhet är igång.

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.template.json till IoT Hub my-iot-hub för IoT Edge-enheten my-device använder du följande kommando. Ersätt värdena för hubbnamn, enhets-ID och inloggnings-IoT Hub-anslutningssträng med dina egna.

az iot edge set-modules --hub-name my-iot-hub --device-id my-device --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Dricks

Du hittar din IoT Hub-anslutningssträng inklusive nyckeln för delad åtkomst i Azure-portalen. Gå till dina IoT Hub-säkerhetsinställningar >>Principer för delad åtkomst>iothubowner.

  1. I Visual Studio Code-utforskaren under avsnittet Azure IoT Hub expanderar du Enheter för att se din lista över IoT-enheter.

  2. Högerklicka på den IoT Edge-enhet som du vill distribuera till och välj sedan Skapa distribution för enskild enhet.

  3. I utforskaren navigerar du till mappen config och väljer sedan filen deployment.amd64.json .

    Använd inte filen deployment.template.json, som inte har autentiseringsuppgifterna för containerregistret eller modulavbildningsvärdena i den. Om du riktar in dig på en Linux ARM32-enhet är distributionsmanifestets namn deployment.arm32v7.json.

  4. Under enheten expanderar du Moduler för att se en lista över distribuerade och körande moduler. Välj uppdateringsknappen. Du bör se de nya tempSensor - och filtermodulmodulmodulerna som körs på enheten.

    Det kan ta några minuter innan modulerna startas. IoT Edge-körningen måste ta emot sitt nya distributionsmanifest, hämta modulavbildningarna från containerkörningen och starta sedan varje ny modul.

Visa meddelanden från enheten

Exempelmodulkoden tar emot meddelanden via indatakön och skickar dem genom utdatakön. Distributionsmanifestet deklarerade vägar som skickade meddelanden till filtermodul från tempSensor och vidarebefordrade sedan meddelanden från filtermodul till IoT Hub. Med Azure IoT Edge- och Azure IoT Hub-tilläggen kan du se meddelanden när de kommer till IoT Hub från dina enskilda enheter.

  1. Högerklicka på den IoT Edge-enhet som du vill övervaka i Visual Studio Code-utforskaren och välj sedan Starta övervakning inbyggd händelseslutpunkt.

  2. Titta på utdatafönstret i Visual Studio Code för att se meddelanden som kommer till din IoT-hubb.

    Screenshot showing where to view incoming device to cloud messages.

Visa ändringar på enheten

Om du vill se vad som händer på själva enheten använder du kommandona i det här avsnittet för att inspektera IoT Edge-körningen och modulerna som körs på enheten.

Kommandona i det här avsnittet gäller för din IoT Edge-enhet, inte utvecklingsdatorn. Om du använder en virtuell dator för din IoT Edge-enhet ansluter du till den nu. I Azure går du till översiktssidan för den virtuella datorn och väljer Anslut för att få åtkomst till den säkra shell-anslutningen.

  • Visa alla moduler som distribuerats till enheten och kontrollera deras status:

    iotedge list

    Du bör se fyra moduler: de två IoT Edge-körningsmodulerna tempSensor och filtermodule. Du bör se alla fyra som körs.

  • Granska loggarna för en specifik modul:

    iotedge logs <module name>

    IoT Edge-moduler är skiftlägeskänsliga.

    TempSensor- och filtermodulloggarna ska visa de meddelanden som de bearbetar. EdgeAgent-modulen ansvarar för att starta de andra modulerna, så loggarna innehåller information om hur du implementerar distributionsmanifestet. Om du upptäcker att en modul är olistad eller inte körs har edgeAgent-loggarna troligen felen. EdgeHub-modulen ansvarar för kommunikation mellan modulerna och IoT Hub. Om modulerna är igång, men meddelandena inte kommer till din IoT-hubb, har edgeHub-loggarna troligen felen.

Rensa resurser

Om du tänker fortsätta till nästa rekommenderade artikel kan du behålla de resurser och konfigurationer du har skapat och använda dem igen. Du kan även fortsätta att använda samma IoT Edge-enhet som en testenhet.

Annars kan du ta bort de lokala konfigurationer och Azure-resurser som du använde i den här artikeln för att undvika avgifter.

Ta bort Azure-resurser

Det går inte att ångra borttagningen av Azure-resurser och resursgrupper. Var noga så att du inte tar bort fel resursgrupp eller resurser av misstag. Om du har skapat IoT-hubben i en befintlig resursgrupp som har resurser som du vill behålla tar du bara bort själva IoT Hub-resursen, inte resursgruppen.

Ta bort resurser:

  1. Logga in på Azure-portalen och välj Resursgrupper.

  2. Välj namnet på resursgruppen som innehåller dina IoT Edge-testresurser.

  3. Granska listan över resurser som finns i resursgruppen. Om du vill ta bort alla kan du välja Ta bort resursgrupp. Om du bara vill ta bort några av dem kan du klicka i varje resurs och ta bort dem individuellt.

Nästa steg

I den här självstudien konfigurerar du Visual Studio Code på utvecklingsdatorn och distribuerar din första IoT Edge-modul som innehåller kod för att filtrera rådata som genereras av din IoT Edge-enhet.

Du kan fortsätta till nästa självstudier för att lära dig hur Azure IoT Edge kan hjälpa dig att distribuera Azure-molntjänster för att bearbeta och analysera data vid gränsen.

Felsöka Azure IoT Edge-modulerFunctionsStream AnalyticsCustom Vision Service