Delen via

Zelfstudie: IoT Edge-modules ontwikkelen met Visual Studio Code

  • Artikel

Van toepassing op: IoT Edge 1.5-vinkje IoT Edge 1.5 Vinkje voor IoT Edge 1.4 IoT Edge 1.4

Belangrijk

IoT Edge 1.5 LTS en IoT Edge 1.4 LTS worden ondersteund releases. IoT Edge 1.4 LTS eindigt op 12 november 2024. Raadpleeg IoT Edge bijwerken als u een eerdere versie hebt.

In deze zelfstudie wordt uitgelegd hoe u uw eigen code ontwikkelt en implementeert op een IoT Edge-apparaat. U kunt Azure IoT Edge-modules gebruiken voor het implementeren van code die uw bedrijfslogica rechtstreeks op uw IoT Edge-apparaten implementeert. In de quickstart Code implementeren op een Linux-apparaat hebt u een IoT Edge-apparaat gemaakt en een module geïmplementeerd vanuit Azure Marketplace.

Dit artikel bevat stappen voor twee IoT Edge-ontwikkelhulpprogramma's.

  • Azure IoT Edge Dev Tool-opdrachtregel (CLI). Dit hulpprogramma heeft de voorkeur voor ontwikkeling.
  • Azure IoT Edge-hulpprogramma's voor Visual Studio Code-extensie . De extensie bevindt zich in de onderhoudsmodus.

Gebruik de knop toolselector aan het begin van dit artikel om de versie van het hulpprogramma te selecteren.

In deze zelfstudie leert u het volgende:

  • Uw ontwikkelcomputer instellen.
  • Gebruik de IoT Edge-hulpprogramma's om een nieuw project te maken.
  • Bouw uw project als een Docker-container en sla het op in een Azure-containerregister.
  • Uw code implementeren op een IoT Edge-apparaat.

De IoT Edge-module die u in deze zelfstudie maakt, filtert de temperatuurgegevens die uw apparaat genereert. Er worden alleen gegevens upstream gezonden als de temperatuur boven een opgegeven drempelwaarde komt. Dit soort analyse is nuttig om de hoeveelheid gegevens te reduceren die worden gecommuniceerd naar en worden opgeslagen in de cloud.

Vereisten

Een ontwikkelcomputer:

  • Gebruik uw eigen computer of een virtuele machine.
  • Uw ontwikkelcomputer moet geneste virtualisatie ondersteunen voor het uitvoeren van een containerengine.
  • De meeste besturingssystemen waarop een container-engine kan worden uitgevoerd, kunnen worden gebruikt voor het ontwikkelen van IoT Edge-modules voor Linux-apparaten. In deze zelfstudie wordt gebruikgemaakt van een Windows-computer. Er wordt echter gewezen op bekende verschillen in macOS of Linux.
  • Visual Studio Code installeren
  • Installeer de Azure CLI.

Een Azure IoT Edge-apparaat:

  • U moet IoT Edge uitvoeren op een afzonderlijk apparaat. Dit onderscheid tussen ontwikkelcomputer en IoT Edge-apparaat simuleert een waar implementatiescenario en helpt de verschillende concepten gescheiden te houden. Gebruik het quickstart-artikel Code implementeren op een Linux-apparaat om een IoT Edge-apparaat te maken in Azure of de Azure-resourcesjabloon om een vm met IoT Edge te implementeren.

Cloudresources:

  • Een gratis of standaard IoT-hub-laag in Azure.

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

Tip

Voor hulp bij interactieve foutopsporing in Visual Studio Code of Visual Studio 2022:

In deze zelfstudie leert u de ontwikkelstappen voor Visual Studio Code.

Belangrijke concepten

In deze zelfstudie doorloopt u de ontwikkeling van een IoT Edge-module. Een IoT Edge-module is een container met uitvoerbare code. U kunt een of meer modules implementeren op een IoT Edge-apparaat. Modules voeren specifieke taken uit, zoals het opnemen van gegevens van sensoren, het opschonen en analyseren van gegevens of het verzenden van berichten naar een IoT-hub. Zie Informatie over Azure IoT Edge-modules voor meer informatie.

Bij het ontwikkelen van IoT Edge-modules is het belangrijk om inzicht te hebben in het verschil tussen de ontwikkelcomputer en het ioT Edge-doelapparaat waar de module wordt geïmplementeerd. De container die u voor de modulecode bouwt, moet overeenkomen met het besturingssysteem van het doelapparaat. Zo is het meest voorkomende scenario dat iemand een module ontwikkelt op een Windows-computer met het doel deze op een Linux-apparaat met IoT Edge te implementeren. In dat geval zou het besturingssysteem van de container Linux zijn. Als u deze zelfstudie doorloopt, moet u rekening houden met het verschil tussen het besturingssysteem van de ontwikkelcomputer en het besturingssysteem van de container.

Tip

Als u IoT Edge voor Linux in Windows gebruikt, is het doelapparaat in uw scenario de virtuele Linux-machine, niet de Windows-host.

Deze zelfstudie is gericht op apparaten met IoT Edge met Linux-containers. Als de ontwikkelcomputer Linux-containers uitvoert, kunt u uw favoriete besturingssysteem gebruiken. We raden u aan Visual Studio Code te gebruiken om te ontwikkelen met Linux-containers, dus dat is wat in deze zelfstudie wordt gebruikt. U kunt ook Visual Studio gebruiken, maar er zijn wel verschillen in ondersteuning tussen de twee hulpprogramma's.

De volgende tabel bevat een overzicht van de ondersteunde ontwikkelscenario's voor Linux-containers in Visual Studio Code en Visual Studio.

Visual Studio Code Visual Studio 2019/2022
Architectuur van Linux-apparaat Linux AMD64
Linux ARM32v7
Linux ARM64		 Linux AMD64
Linux ARM32
Linux ARM64
Azure-services Azure Functions
Azure Stream Analytics
Azure Machine Learning
Talen C
C#
Java
Node.js
Python		 C
C#
Meer informatie Azure IoT Edge voor Visual Studio Code Azure IoT Edge Tools voor Visual Studio 2019
Azure IoT Edge Tools voor Visual Studio 2022

Container-engine installeren

IoT Edge-modules worden verpakt als containers, dus u hebt een docker-compatibel containerbeheersysteem op uw ontwikkelcomputer nodig om ze te bouwen en te beheren. We raden aan Docker Desktop te gebruiken voor ontwikkeling vanwege de ondersteuning en populariteit van de functies. Met Docker Desktop in Windows kunt u schakelen tussen Linux-containers en Windows-containers, zodat u modules voor verschillende typen IoT Edge-apparaten kunt ontwikkelen.

Gebruik de Docker-documentatie om Docker Desktop te installeren op uw ontwikkelcomputer:

Hulpprogramma's instellen

Installeer het Azure IoT Edge Dev Tool op basis van Python om uw IoT Edge-oplossing te maken. Er zijn twee opties:

Belangrijk

De Azure IoT Edge-hulpprogramma's voor de Visual Studio Code-extensie bevindt zich in de onderhoudsmodus. Het favoriete ontwikkelhulpprogramma is de opdrachtregel (CLI) Azure IoT Edge Dev Tool.

Gebruik de IoT-extensies voor Visual Studio Code voor het ontwikkelen van IoT Edge-modules. Deze extensies bieden projectsjablonen, automatiseren het maken van het implementatiemanifest en bieden u de mogelijkheid om IoT Edge-apparaten te bewaken en te beheren. In deze sectie installeert u Visual Studio Code en de IoT-extensie. Vervolgens stelt u uw Azure-account in voor het beheren van IoT Hub-resources vanuit Visual Studio Code.

  1. Installeer de Azure IoT Edge-extensie .

  2. Installeer de Azure IoT Hub-extensie .

  3. Nadat u extensies hebt geïnstalleerd, opent u het opdrachtenpalet door het opdrachtenpalet weergeven>te selecteren.

  4. Zoek en selecteer Azure IoT Hub in het opdrachtpalet opnieuw: Selecteer IoT Hub. Volg de aanwijzingen om uw Azure-abonnement en IoT Hub te selecteren.

  5. Open de sectie Explorer van Visual Studio Code door het pictogram te selecteren in de activiteitenbalk aan de linkerkant of door View>Explorer te selecteren.

  6. Vouw onderaan de sectie Explorer het samengevouwen menu Azure IoT Hub / Devices uit. U ziet nu de apparaten en IoT Edge-apparaten die zijn gekoppeld aan de IoT Hub die u hebt geselecteerd via het opdrachtenpalet.

Taalspecifieke hulpprogramma's installeren

Installeer hulpprogramma's die specifiek zijn voor de taal waarin u ontwikkelt:

Een containerregister maken

In deze zelfstudie gebruikt u de Azure IoT Edge - en Azure IoT Hub-extensies om een module te bouwen en een containerinstallatiekopieën te maken op basis van de bestanden. Vervolgens pusht u deze installatiekopie naar een register waarin uw installatiekopieën worden opgeslagen en beheerd. Tot slot implementeert u de installatiekopie uit het register voor uitvoering op uw IoT Edge-apparaat.

Belangrijk

De Azure IoT Edge Visual Studio Code-extensie bevindt zich in de onderhoudsmodus.

U kunt een Docker-register gebruiken om de containerinstallatiekopieën op te slaan. Twee populaire Docker-registerservices zijn Azure Container Registry en Docker Hub. In deze zelfstudie wordt Azure Container Registry gebruikt.

Als u nog geen containerregister hebt, volgt u deze stappen om een nieuw containerregister te maken in Azure:

  1. Selecteer in Azure Portal de optie Een resource maken>Containers>Container Registry.

  2. Geef de volgende vereiste waarden op om uw containerregister te maken:

    Veld Waarde
    Abonnement Selecteer een abonnement in de vervolgkeuzelijst.
    Resourcegroep Gebruik dezelfde resourcegroep voor alle testresources die u maakt tijdens de quickstarts en zelfstudies van IoT Edge. zoals IoTEdgeResources.
    Registernaam Geef hier een unieke naam op.
    Locatie Kies een locatie dicht bij u in de buurt.
    SKU Selecteer Basic.

  3. Selecteer Beoordelen en maken en vervolgens Maken.

  4. Selecteer uw nieuwe containerregister in de sectie Resources van de startpagina van Azure Portal om het te openen.

  5. Selecteer in het linkerdeelvenster van het containerregister toegangssleutels in het menu onder Instellingen.

    Schermopname van de menulocatie toegangssleutels.

  6. Schakel beheerdersgebruiker in met de wisselknop en bekijk de gebruikersnaam en het wachtwoord voor uw containerregister.

  7. Kopieer de waarden voor de aanmeldingsserver, gebruikersnaam en wachtwoord en sla ze ergens op. U gebruikt deze waarden verderop in de zelfstudie om toegang te verlenen tot het containerregister.

Een nieuw moduleproject maken

De Azure IoT Edge-extensie biedt projectsjablonen voor alle ondersteunde IoT Edge-moduletalen in Visual Studio Code. Deze sjablonen bevatten alle bestanden en code die u nodig hebt om een werkende module te implementeren om IoT Edge te testen of bieden u een uitgangspunt om de sjabloon aan te passen met uw eigen bedrijfslogica.

Een projectsjabloon maken

Het IoT Edge Dev Tool vereenvoudigt de ontwikkeling van Azure IoT Edge naar opdrachten die worden aangestuurd door omgevingsvariabelen. Hiermee kunt u aan de slag met IoT Edge-ontwikkeling met de IoT Edge Dev Container- en IoT Edge-oplossingsstructuur met een standaardmodule en alle vereiste configuratiebestanden.

  1. Maak een map voor uw oplossing met het pad van uw keuze. Ga naar uw iotedgesolution map.

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

  2. Gebruik de init-opdracht iotedgedev-oplossing om een oplossing te maken en uw Azure IoT Hub in te stellen in de ontwikkeltaal van uw keuze.

    iotedgedev solution init --template csharp

In het init-script van de iotedgedev-oplossing wordt u gevraagd om verschillende stappen uit te voeren, waaronder:

  • Verifiëren bij Azure
  • Een Azure-abonnement kiezen
  • Een resourcegroep kiezen of maken
  • Een Azure IoT Hub kiezen of maken
  • Een Azure IoT Edge-apparaat kiezen of maken

Gebruik Visual Studio Code en de Azure IoT Edge-extensie . U begint met het maken van een oplossing en vervolgens genereert u de eerste module in die oplossing. Elke oplossing kan meerdere modules bevatten.

  1. Selecteer Opdrachtpalet weergeven>.
  2. Voer in het opdrachtenpalet de opdracht Azure IoT Edge: New IoT Edge Solution in en voer deze uit.
  3. Blader naar de map waarin u de nieuwe oplossing wilt maken en selecteer vervolgens Map selecteren.
  4. Voer een naam in voor uw oplossing.
  5. Selecteer een modulesjabloon voor de ontwikkeltaal van uw voorkeur als de eerste module in de oplossing.
  6. Voer een naam in voor uw module. Kies een naam die uniek is in uw containerregister.
  7. Geef de naam op van de opslagplaats voor installatiekopieën van de module. Visual Studio Code vult de modulenaam automatisch in met localhost:5000/<uw modulenaam>. Vervang deze door uw eigen registergegevens. Gebruik localhost als u een lokaal Docker-register gebruikt om te testen. Als u Azure Container Registry gebruikt, gebruikt u de aanmeldingsserver vanuit de instellingen van uw register. De aanmeldingsserver ziet eruit als <registernaam.azurecr.io>. Vervang alleen het gedeelte localhost:5000 van de tekenreeks, zodat het uiteindelijke resultaat eruitziet als <registernaam.azurecr.io/<> naam van de module.>

Visual Studio Code gebruikt de informatie die u hebt opgegeven, maakt een IoT Edge-oplossing en laadt deze vervolgens in een nieuw venster.

Nadat de oplossing is gemaakt, bevinden deze hoofdbestanden zich in de oplossing:

  • Een .vscode-map bevat configuratiebestand launch.json.

  • Een modulemap met submappen voor elke module. In de submap voor elke module bepaalt het module.json bestand hoe modules worden gebouwd en geïmplementeerd.

  • Een .env-bestand bevat uw omgevingsvariabelen. De omgevingsvariabele voor het containerregister is standaard localhost:5000 .

  • Twee module-implementatiebestanden met de naam deployment.template.json en deployment.debug.template.json de modules weer te geven die op uw apparaat moeten worden geïmplementeerd. De lijst bevat standaard de IoT Edge-systeemmodules (edgeAgent en edgeHub) en voorbeeldmodules zoals:

    Notitie

    De exacte geïnstalleerde modules kunnen afhankelijk zijn van uw keuzetaal.

Runtimeversie van IoT Edge instellen

De nieuwste stabiele versie van de IoT Edge-systeemmodule is 1.5. Stel uw systeemmodules in op versie 1.5.

  1. Open in Visual Studio Code deployment.template.json manifestbestand voor de implementatie. Het implementatiemanifest is een JSON-document waarin de modules worden beschreven die moeten worden geconfigureerd op het beoogde IoT Edge-apparaat.

  2. Wijzig de runtimeversie voor de installatiekopieën van de system Runtime-module edgeAgent en edgeHub. Als u bijvoorbeeld de IoT Edge-runtimeversie 1.5 wilt gebruiken, wijzigt u de volgende regels in het distributiemanifestbestand:

    "systemModules": {
    "edgeAgent": {

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

    "edgeHub": {

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

Uw registerreferenties voor de IoT Edge-agent opgeven

In het omgevingsbestand worden de referenties voor het containerregister opgeslagen. Deze referenties worden gedeeld met de IoT Edge-runtime. De runtime heeft deze referenties nodig om uw containerinstallatiekopieën naar het IoT Edge-apparaat te halen.

De IoT Edge-extensie probeert uw containerregisterreferenties van Azure op te halen en deze in het omgevingsbestand in te vullen.

Notitie

Het omgevingsbestand wordt alleen gemaakt als u een opslagplaats voor installatiekopieën voor de module opgeeft. Als u de localhost-standaardwaarden hebt geaccepteerd om lokaal te testen en fouten op te sporen, hoeft u geen omgevingsvariabelen te declareren.

Controleer of uw referenties bestaan. Als dat niet het geval is, voegt u ze nu toe:

  1. Als Azure Container Registry uw register is, stelt u een gebruikersnaam en wachtwoord voor Azure Container Registry in. Haal deze waarden op in het menu Instellingentoegangssleutels> van uw containerregister in Azure Portal.

  2. Open het .env-bestand in uw moduleoplossing.

  3. Voeg de waarden voor gebruikersnaam en wachtwoord toe die u hebt gekopieerd uit het Azure-containerregister. Voorbeeld:

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

  4. Sla uw wijzigingen op in het .env-bestand .

Notitie

In deze zelfstudie worden aanmeldingsreferenties voor beheerders gebruikt voor Azure Container Registry die handig zijn voor ontwikkelings- en testscenario's. Wanneer u klaar bent voor productiescenario's, raden we u aan een optie voor verificatie met minimale bevoegdheden, zoals service-principals of tokens binnen het bereik van de opslagplaats. Zie Toegang tot uw containerregister beheren voor meer informatie.

Doelarchitectuur

U moet de architectuur selecteren die u wilt gebruiken voor elke oplossing, omdat dit van invloed is op de wijze waarop de container wordt gebouwd en uitgevoerd. De standaardinstelling is Linux AMD64. Voor deze zelfstudie gebruiken we een virtuele Ubuntu-machine als het IoT Edge-apparaat en behouden we de standaard amd64.

Als u de doelarchitectuur voor uw oplossing wilt wijzigen, gebruikt u de volgende stappen.

  1. Open het opdrachtenpalet en zoek naar Azure IoT Edge: Stel standaarddoelplatform voor Edge-oplossing in of selecteer het snelkoppelingspictogram in de zijbalk onder aan het venster.

  2. Selecteer in het opdrachtpalet de doelarchitectuur in de lijst met opties.

De doelarchitectuur wordt ingesteld wanneer u de containerinstallatiekopieën in een latere stap maakt.

Module bijwerken met aangepaste code

Elke sjabloon bevat voorbeeldcode die gesimuleerde sensorgegevens uit de Module SimulatedTemperatureSensor gebruikt en deze routeert naar de IoT-hub. De voorbeeldmodule ontvangt berichten en geeft deze vervolgens door. Met de pijplijnfunctionaliteit wordt een belangrijk concept in IoT Edge gedemonstreerd, waarmee modules met elkaar communiceren.

Elke module kan meerdere invoer- en uitvoerwachtrijen hebben die in hun code zijn gedeclareerd. Met de IoT Edge-hub die op het apparaat wordt uitgevoerd, worden berichten van de uitvoer van een module naar de invoer van een of meer modules gerouteerd. De specifieke code voor het declareren van invoer en uitvoer verschilt per taal, maar het concept is voor alle modules hetzelfde. Zie Routes declareren voor meer informatie over routering tussen modules.

De C#-voorbeeldcode die bij de projectsjabloon hoort, maakt gebruik van de ModuleClient-klasse van de IoT Hub SDK voor .NET.

  1. Open modules>filtermodule>in Visual Studio Code Explorer ModuleBackgroundService.cs.

  2. Voeg vóór de filtermodulenaamruimte drie using-instructies toe voor typen die later worden gebruikt:

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

  3. Voeg de variabele temperatureThreshold toe aan de klasse ModuleBackgroundService . Deze variabele bepaalt de waarde die de gemeten temperatuur moet overschrijden voordat de gegevens naar de IoT-hub worden verzonden.

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

  4. Voeg de klassen MessageBody, Machine en Ambient toe. Deze klassen bepalen het verwachte schema voor de hoofdtekst van inkomende berichten.

    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. Zoek de functie ExecuteAsync . Met deze functie maakt en configureert u een ModuleClient-object waarmee de module verbinding kan maken met de lokale Azure IoT Edge-runtime om berichten te verzenden en te ontvangen. Nadat de ModuleClient is gemaakt, leest de code de waarde van temperatureThreshold uit de gewenste eigenschappen van de moduledubbel. De code registreert een callback voor het ontvangen van berichten van een IoT Edge-hub via een eindpunt met de naam input1.

    Vervang de aanroep naar de ProcessMessageAsync-methode door een nieuwe methode die de naam van het eindpunt bijwerkt en de methode die wordt aangeroepen wanneer invoer binnenkomt. Voeg ook een SetDesiredPropertyUpdateCallbackAsync-methode toe voor updates aan de gewenste eigenschappen. Vervang de laatste regel van de ExecuteAsync-methode door de volgende code om deze wijziging aan te brengen:

    // 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. Voeg de onDesiredPropertiesUpdate-methode toe aan de klasse ModuleBackgroundService . Deze methode ontvangt updates van de gewenste eigenschappen van de moduledubbel en updatet de variabele temperatureThreshold naar dezelfde waarde. Alle modules hebben hun eigen moduledubbel, waardoor u rechtstreeks in de cloud de code kunt configureren die in een module wordt uitgevoerd.

    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. Voeg de methode FilterMessages toe. Deze methode wordt aangeroepen wanneer de module een bericht ontvangt van de IoT Edge-hub. Berichten die temperaturen onder de drempelwaarde die via de moduledubbel is ingesteld, worden hierdoor gefilterd. Ook wordt de eigenschap BerichtType toegevoegd aan het bericht met de waarde ingesteld op Alarm.

    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. Sla het ModuleBackgroundService.cs-bestand op.

  9. Open in Visual Studio Code Explorer het deployment.template.json-bestand in de werkruimte van uw IoT Edge-oplossing.

  10. Omdat we de naam van het eindpunt hebben gewijzigd waarop de module luistert, moeten we ook de routes in het implementatiemanifest bijwerken, zodat edgeHub berichten naar het nieuwe eindpunt verzendt.

    Zoek de sectie Routes in de $edgeHub moduledubbel. Werk de sensorTofiltermodule-route bij om deze te vervangen door input1 inputFromSensor:

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

  11. Voeg de moduledubbel filtermodule toe aan het implementatiemanifest. Voeg de volgende JSON-inhoud onder aan de sectie modulesContent in, na de moduledubbel $edgeHub:

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

  12. Sla het bestand deployment.template.json op.

De oplossing bouwen en pushen

U hebt de modulecode en de implementatiesjabloon bijgewerkt om inzicht te hebben in enkele belangrijke implementatieconcepten. U bent nu klaar om de containerinstallatiekopieën van de module te bouwen en naar het containerregister te pushen.

Open in Visual Studio Code het manifestbestand voor de deployment.template.json-implementatie . In het implementatiemanifest worden de modules beschreven die moeten worden geconfigureerd op het beoogde IoT Edge-apparaat. Voordat u gaat implementeren, moet u uw Azure Container Registry-referenties en uw moduleinstallatiekopieën bijwerken met de juiste createOptions waarden. Zie Opties voor het maken van containers configureren voor IoT Edge-modules voor meer informatie over createOption-waarden.

Als u een Azure Container Registry gebruikt om de installatiekopie van de module op te slaan, voegt u uw referenties toe aan de sectie registryCredentials-instellingen van>modulesContent>edgeAgent>in deployment.template.json. Vervang myacr door uw eigen registernaam en geef uw wachtwoord en het adres van de aanmeldingsserver op. Voorbeeld:

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

Voeg de volgende tekenreeksinhoud toe aan of vervang deze door de waarde createOptions voor elk systeem (edgeHub en edgeAgent) en aangepaste module (filtermodule en tempSensor). Wijzig indien nodig de waarden.

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

De filtermoduleconfiguratie moet bijvoorbeeld vergelijkbaar zijn met:

"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-installatiekopieën bouwen

Open de geïntegreerde Visual Studio Code-terminal door Terminal>New Terminal te selecteren.

Gebruik de dotnet publish opdracht om de containerinstallatiekopieën voor Linux- en amd64-architectuur te bouwen. Wijzig de map in de filtermodulemap in uw project en voer de opdracht dotnet publish uit.

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

Momenteel is de iotedgedev-hulpprogrammasjabloon gericht op .NET 7.0. Als u een andere versie van .NET wilt gebruiken, kunt u het bestand filtermodule.csproj bewerken en de targetFramework - en PackageReference-waarden wijzigen. Als u bijvoorbeeld .NET 8.0 wilt gebruiken, ziet het bestand filtermodule.csproj er als volgt uit:

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

Tag de docker-installatiekopieën met de informatie, versie en architectuur van uw containerregister. Vervang myacr door uw eigen registernaam.

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

Docker-installatiekopieën van pushmodule

Geef uw containerregisterreferenties op voor Docker, zodat deze uw containerinstallatiekopieën naar de opslag in het register kan pushen.

  1. Meld u aan bij Docker met de ACR-referenties (Azure Container Registry).

    docker login -u <ACR username> -p <ACR password> <ACR login server>

    Mogelijk ontvangt u een beveiligingswaarschuwing die het gebruik van --password-stdin. Hoewel dit een aanbevolen best practice is voor productiescenario's, valt dit buiten het bereik van deze zelfstudie. Zie de documentatie voor aanmelding bij Docker voor meer informatie.

  2. Meld u aan bij de Azure Container Registry. U moet Azure CLI installeren om de az opdracht te kunnen gebruiken. Met deze opdracht wordt u gevraagd om uw gebruikersnaam en wachtwoord in het containerregister in Toegangssleutels voor instellingen>.

    az acr login -n <ACR registry name>

    Tip

    Als u op enig moment in deze zelfstudie wordt afgemeld, herhaalt u de aanmeldingsstappen van Docker en Azure Container Registry om door te gaan.

  3. Push de module-installatiekopieën naar het lokale register of een containerregister.

    docker push <ImageName>

    Voorbeeld:

    # 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

De implementatiesjabloon bijwerken

Werk de implementatiesjabloon deployment.template.json bij met de locatie van de containerregisterinstallatiekopieën. Als u bijvoorbeeld een Azure Container Registry-myacr.azurecr.io gebruikt en uw installatiekopieën filtermodule:0.0.1-amd64 zijn, werkt u de filtermoduleconfiguratie bij naar:

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

Klik in de Visual Studio Code Explorer met de rechtermuisknop op het bestand deployment.template.json en selecteer Build and Push IoT Edge Solution.

Met de opdracht voor bouwen en pushen worden drie bewerkingen gestart. Eerst wordt er een nieuwe map met de naam config in de oplossing gemaakt die het volledige implementatiemanifest bevat, op basis van de informatie in de implementatiesjabloon en andere oplossingsbestanden. Daarna wordt docker build uitgevoerd om de containerinstallatiekopie te bouwen op basis van de juiste dockerfile voor uw doelarchitectuur. Vervolgens wordt docker push uitgevoerd om de opslagplaats van de installatiekopie naar het containerregister te pushen.

Dit proces kan de eerste keer enkele minuten duren, maar de volgende keer dat u de opdrachten uitvoert, wordt het sneller uitgevoerd.

Optioneel: De module en installatiekopieën bijwerken

Als u wijzigingen aanbrengt in de modulecode, moet u de moduleinstallatiekopieën opnieuw bouwen en naar het containerregister pushen. Gebruik de stappen in deze sectie om de build- en containerinstallatiekopieën bij te werken. U kunt deze sectie overslaan als u geen wijzigingen hebt aangebracht in de modulecode.

Open het bestand deployment.amd64.json in de zojuist gemaakte configuratiemap. De bestandsnaam weerspiegelt de doelarchitectuur, dus dit is anders als u een andere architectuur kiest.

U ziet dat de twee parameters met tijdelijke aanduidingen nu de juiste waarden bevatten. In de sectie registryCredentials is de gebruikersnaam en het wachtwoord van het register opgehaald uit het .env-bestand . De filtermodule heeft de volledige opslagplaats voor installatiekopieën met de naam, versie en architectuurtag van het module.json-bestand .

  1. Open het bestand module.json in de map filtermodule .

  2. Wijzig het versienummer voor de installatiekopie van de module. U kunt bijvoorbeeld het versienummer van de patch verhogen alsof "version": "0.0.2" u een kleine oplossing in de modulecode hebt gemaakt.

    Tip

    Moduleversies bieden ondersteuning voor versiebeheer en bieden u de mogelijkheid wijzigingen te testen op een klein aantal apparaten voordat u updates in een productieomgeving implementeert. Als u de moduleversie niet verhoogt voordat u bouwt en pusht, overschrijft u de opslagplaats in uw containerregister.

  3. Sla uw wijzigingen op in het module.json-bestand .

Bouw en push de bijgewerkte installatiekopieën met een versietag 0.0.2 . Als u bijvoorbeeld de installatiekopieën voor het lokale register of een Azure-containerregister wilt bouwen en pushen, gebruikt u de volgende opdrachten:


# 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

Klik opnieuw met de rechtermuisknop op het bestand deployment.template.json en selecteer opnieuw Build and Push IoT Edge solution.

Open het bestand deployment.amd64.json opnieuw. U ziet dat het buildsysteem geen nieuw bestand maakt wanneer u de build- en pushopdracht opnieuw uitvoert. In plaats daarvan worden dezelfde bestandsupdates bijgewerkt om de wijzigingen weer te geven. De filtermodule-installatiekopieën verwijst nu naar de versie 0.0.2 van de container.

Ga naar Azure Portal en navigeer naar het containerregister om verder te controleren wat de opdracht voor het bouwen en pushen heeft gedaan.

Selecteer opslagplaatsen in het containerregister en filtermodule. Controleer of beide versies van de installatiekopieën naar het register pushen.

Schermopname van waar u beide installatiekopieën in uw containerregister kunt bekijken.

Problemen oplossen

Als er fouten optreden bij het bouwen en pushen van de installatiekopie van de module, heeft dit vaak te maken met Docker-configuratie op uw ontwikkelcomputer. Gebruik de volgende controles om uw configuratie te controleren:

  • Hebt u de opdracht docker login uitgevoerd met behulp van de referenties die u uit het containerregister hebt gekopieerd? Deze referenties zijn anders dan de referenties die u gebruikt om u aan te melden bij Azure.
  • Hebt u de juiste containeropslagplaats? Heeft deze de juiste containerregisternaam en de juiste modulenaam? Open het module.json-bestand in de map filtermodule om dit te controleren. De waarde van de opslagplaats moet eruitzien als registernaam.azurecr.io/filtermodule>.<
  • Als u een andere naam dan filtermodule voor uw module hebt gebruikt, is die naam consistent in de hele oplossing?
  • Worden op de computer hetzelfde type containers uitgevoerd als die u bouwt? Deze zelfstudie is voor Linux IoT Edge-apparaten en daarom moet in de zijbalk van Visual Studio Code amd64 of arm32v7 worden vermeld, en moeten op Docker Desktop Linux-containers worden uitgevoerd.

Modules op het apparaat implementeren

U hebt gecontroleerd of er ingebouwde containerinstallatiekopieën zijn opgeslagen in uw containerregister, dus het is tijd om ze op een apparaat te implementeren. Zorg ervoor dat uw IoT Edge-apparaat actief is.

Gebruik de opdracht Azure CLI-setmodules voor IoT Edge om de modules te implementeren in de Azure IoT Hub. Als u bijvoorbeeld de modules wilt implementeren die in het bestand deployment.template.json zijn gedefinieerd in IoT Hub my-iot-hub voor het IoT Edge-apparaat, gebruikt u de volgende opdracht. Vervang de waarden voor hubnaam, apparaat-id en meld u aan bij IoT Hub verbindingsreeks door uw eigen.

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

Tip

U vindt uw IoT Hub-verbindingsreeks inclusief de gedeelde toegangssleutel in Azure Portal. Ga naar uw IoT Hub-beveiligingsinstellingen >>voor gedeeld toegangsbeleid>iothubowner.

  1. Vouw in de Visual Studio Code Explorer, onder de sectie Azure IoT Hub, de optie Apparaten uit om de lijst met IoT-apparaten weer te geven.

  2. Klik met de rechtermuisknop op de naam van het IoT Edge-apparaat dat u wilt implementeren en selecteer Create Deployment for Single Device.

  3. Ga in de bestandsverkenner naar de map config en selecteer vervolgens het bestand deployment.amd64.json.

    Gebruik het deployment.template.json bestand niet, waarvoor de containerregisterreferenties of module-installatiekopieën niet in het bestand zijn opgenomen. Als u zich richt op een Linux ARM32-apparaat, wordt de naam van het implementatiemanifest deployment.arm32v7.json.

  4. Vouw onder uw apparaat Modules uit voor een lijst met de geïmplementeerde en actieve modules. Selecteer de knop Vernieuwen. U ziet nu de nieuwe tempSensor - en filtermodulemodules die op uw apparaat worden uitgevoerd.

    Het kan enkele minuten duren voordat de modules zijn gestart. De IoT Edge-runtime moet het nieuwe implementatiemanifest ontvangen, de module-installatiekopieën uit de containerruntime ophalen en vervolgens elke nieuwe module starten.

Berichten van het apparaat weergeven

De voorbeeldmodulecode ontvangt berichten via de invoerwachtrij en geeft deze door via de uitvoerwachtrij. Het distributiemanifest heeft routes gedeclareerd die berichten doorgegeven aan filtermodule van tempSensor en vervolgens berichten van filtermodule naar IoT Hub hebben doorgestuurd. Met de Extensies van Azure IoT Edge en Azure IoT Hub kunt u berichten zien wanneer ze vanaf uw afzonderlijke apparaten bij IoT Hub binnenkomen.

  1. Klik in de Visual Studio Code Explorer met de rechtermuisknop op de naam van het IoT Edge-apparaat dat u wilt controleren en selecteer Start Monitoring Built-in Event Endpoint.

  2. Bekijk het uitvoervenster in Visual Studio Code om berichten te zien die binnenkomen op uw IoT-hub.

    Schermopname die laat zien waar binnenkomende apparaten naar cloudberichten moeten worden weergegeven.

Wijzigingen op apparaat weergeven

Als u wilt zien wat er gebeurt op uw apparaat zelf, gebruikt u de opdrachten in deze sectie om de IoT Edge-runtime en -modules op uw apparaat te controleren.

De opdrachten in deze sectie zijn voor uw IoT Edge apparaat, niet voor uw ontwikkelcomputer. Als u een virtuele machine voor uw IoT Edge-apparaat gebruikt, kunt u er nu verbinding mee maken. Ga in Azure naar de overzichtspagina van de virtuele machine en selecteer Verbinding maken voor toegang tot de beveiligde shell-verbinding.

  • Bekijk alle modules die op het apparaat zijn geïmplementeerd en controleer de status ervan:

    iotedge list

    U ziet vier modules: de twee IoT Edge-runtimemodules, tempSensor en filtermodule. Als het goed is, worden alle vier de vier weergegeven als actief.

  • Controleer de logboeken voor een specifieke module:

    iotedge logs <module name>

    IoT Edge-modules zijn hoofdlettergevoelig.

    In de logboeken tempSensor en filtermodule moeten de berichten worden weergegeven die ze verwerken. De edgeAgent-module is verantwoordelijk voor het starten van de andere modules, zodat de logboeken informatie hebben over het implementeren van het implementatiemanifest. Als u merkt dat een module niet wordt vermeld of niet wordt uitgevoerd, bevatten de edgeAgent-logboeken waarschijnlijk de fouten. De edgeHub-module is verantwoordelijk voor de communicatie tussen de modules en IoT Hub. Als de modules actief zijn, maar de berichten niet binnenkomen bij uw IoT-hub, bevatten de edgeHub-logboeken waarschijnlijk de fouten.

Resources opschonen

Als u van plan bent door te gaan met het volgende aanbevolen artikel, kunt u de resources en configuraties die u hebt gemaakt behouden en opnieuw gebruiken. U kunt ook hetzelfde IoT Edge-apparaat blijven gebruiken als een testapparaat.

Anders kunt u de lokale configuraties en Azure-resources die u in dit artikel hebt gemaakt, verwijderen om kosten te voorkomen.

Azure-resources verwijderen

Het verwijderen van de Azure-resources en resourcegroepen kan niet ongedaan worden gemaakt. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of resources verwijdert. Als u de IoT-hub in een bestaande resourcegroep hebt gemaakt met de resources die u wilt behouden, moet u alleen de IoT-hub zelf verwijderen en niet de resourcegroep.

Om de resources te verwijderen:

  1. Meld u aan bij Azure Portal en selecteer vervolgens Resourcegroepen.

  2. Selecteer de naam van de resourcegroep die uw IoT Edge-testresources bevat.

  3. Bekijk de lijst met resources die uw resourcegroep bevat. Als u alle mappen wilt verwijderen, kunt u Resourcegroep verwijderen selecteren. Als u slechts enkele resources wilt verwijderen, kunt u elke resource selecteren om ze afzonderlijk te verwijderen.

Volgende stappen

In deze zelfstudie stelt u Visual Studio Code in op uw ontwikkelcomputer en hebt u uw eerste IoT Edge-module geïmplementeerd die code bevat om onbewerkte gegevens te filteren die zijn gegenereerd door uw IoT Edge-apparaat.

U kunt doorgaan met de volgende zelfstudies om te leren hoe Azure IoT Edge u kan helpen bij de implementatie van Azure Cloud Services voor het verwerken en analyseren van gegevens aan de rand.

Fouten opsporen in Azure IoT Edge-modulesFunctionsStream AnalyticsCustom Vision Service