Freigeben über

Tutorial: Entwickeln von IoT Edge-Modulen mithilfe von Visual Studio Code

Gilt für:Häkchen für IoT Edge 1.5 IoT Edge 1.5

Wichtig

IoT Edge 1.5 LTS ist die unterstützte Version. IoT Edge 1.4 LTS wurde am 12. November 2024 eingestellt. Wenn Sie eine frühere Version verwenden, lesen Sie Update IoT Edge.

In diesem Lernprogramm erfahren Sie, wie Sie Ihren Code auf einem IoT Edge-Gerät entwickeln und bereitstellen. Mit Azure IoT Edge-Modulen können Sie Code bereitstellen, der Ihre Geschäftslogik direkt auf Ihrem IoT Edge-Gerät ausführt. Im Schnellstart zum Bereitstellen von Code auf einem Linux-Gerät richten Sie ein IoT Edge-Gerät ein und haben ein Modul aus dem Azure Marketplace bereitgestellt.

In diesem Artikel werden die Schritte für zwei IoT Edge-Entwicklungstools behandelt:

  • Azure IoT Edge Dev Tool Befehlszeile (CLI), die für die Entwicklung bevorzugt wird.
  • Azure IoT Edge-Tools für die Visual Studio Code-Erweiterung , die sich im Wartungsmodus befindet.

Verwenden Sie die Schaltfläche "Toolauswahl" am Anfang dieses Artikels, um Ihr Tool auszuwählen.

In diesem Tutorial lernen Sie Folgendes:

  • Einrichten des Entwicklungscomputers
  • Verwenden der IoT Edge-Tools zum Erstellen eines neuen Projekts
  • Erstellen Sie Ihr Projekt als Docker-Container , und speichern Sie es in einer Azure-Containerregistrierung.
  • Bereitstellen Ihres Codes auf einem IoT Edge-Gerät

Das In diesem Lernprogramm erstellte IoT Edge-Modul filtert die von Ihrem Gerät generierten Temperaturdaten. Er sendet nur Nachrichten stromaufwärts, wenn die Temperatur über einem festgelegten Schwellenwert liegt. Diese Art von Analyse am Rand trägt dazu bei, die Menge der an die Cloud gesendeten und gespeicherten Daten zu reduzieren.

Voraussetzungen

Ein Entwicklungscomputer:

  • Verwenden Sie Ihren eigenen Computer oder einen virtuellen Computer.
  • Stellen Sie sicher, dass Ihr Entwicklungscomputer die geschachtelte Virtualisierung unterstützt, um ein Containermodul auszuführen.
  • Sie können die meisten Betriebssysteme verwenden, die ein Containermodul ausführen, um IoT Edge-Module für Linux-Geräte zu entwickeln. Dieses Lernprogramm verwendet einen Windows-Computer, weist jedoch auf bekannte Unterschiede unter macOS oder Linux hin.
  • Installieren von Visual Studio Code
  • Installieren Sie die Azure CLI.

Ein Azure IoT Edge-Gerät:

Cloudressourcen:

  • Verwenden Sie einen kostenlosen oder standardmäßigen Azure IoT Hub.

Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

Tipp

Leitfaden zum interaktiven Debuggen in Visual Studio Code oder Visual Studio 2022:

In diesem Lernprogramm werden entwicklungsschritte für Visual Studio Code behandelt.

Wichtige Begriffe

Dieses Lernprogramm führt Sie durch die Entwicklung eines IoT Edge-Moduls. Ein IoT Edge-Modul ist ein Container mit ausführbarem Code. Stellen Sie ein oder mehrere Module auf einem IoT Edge-Gerät bereit. Module erledigen bestimmte Aufgaben wie das Aufnehmen von Daten aus Sensoren, das Bereinigen und Analysieren von Daten oder das Senden von Nachrichten an einen IoT Hub. Weitere Informationen finden Sie unter "Grundlegendes zu Azure IoT Edge-Modulen".

Wenn Sie IoT Edge-Module entwickeln, verstehen Sie den Unterschied zwischen dem Entwicklungscomputer und dem IoT Edge-Zielgerät, auf dem das Modul bereitgestellt wird. Der Container, den Sie zum Speichern des Modulcodes erstellen, muss mit dem Betriebssystem (Betriebssystem) des Zielgeräts übereinstimmen. Das häufigste Szenario ist beispielsweise die Entwicklung eines Moduls auf einem Windows-Computer für ein Linux-Gerät mit IoT Edge. In diesem Fall ist das Containerbetriebssystem Linux. Beachten Sie beim Durchlaufen dieses Lernprogramms den Unterschied zwischen dem Entwicklungscomputerbetriebssystem und dem Containerbetriebssystem.

Tipp

Wenn Sie IoT Edge für Linux unter Windows verwenden, ist das Zielgerät in Ihrem Szenario der virtuelle Linux-Computer, nicht der Windows-Host.

In diesem Tutorial geht es um Geräte, auf denen IoT Edge mit Linux-Containern ausgeführt wird. Verwenden Sie Ihr bevorzugtes Betriebssystem, solange ihr Entwicklungscomputer Linux-Container ausführt. Visual Studio Code wird für die Entwicklung mit Linux-Containern empfohlen, daher wird es in diesem Lernprogramm verwendet. Alternativ können Sie Visual Studio nutzen, aber zwischen den beiden Tools gibt es Unterschiede in Bezug auf die Unterstützung.

In der folgenden Tabelle sind unterstützte Entwicklungsszenarien für Linux-Container in Visual Studio Code und Visual Studio aufgeführt.

Visual Studio Code Visual Studio 2019/2022
Linux-Gerätearchitektur Linux AMD64
Linux ARM32v7
Linux ARM64		 Linux AMD64
Linux ARM32
Linux ARM64
Azure-Dienste Überprüfung auf
Azure Stream Analytics
Azure Machine Learning
Sprachen C
C#
Java
Node.js
Python		 C
C#
Weitere Informationen Azure IoT Edge für Visual Studio Code Azure IoT Edge Tools für Visual Studio 2019
Azure IoT Edge Tools für Visual Studio 2022

Installieren der Container-Engine

IoT Edge-Module werden als Container verpackt, daher benötigen Sie ein Docker-kompatibles Containerverwaltungssystem auf Ihrem Entwicklungscomputer, um sie zu erstellen und zu verwalten. Docker Desktop ist eine beliebte Wahl für die Entwicklung, da sie über starke Featureunterstützung verfügt. Mit Docker Desktop unter Windows können Sie zwischen Linux-Containern und Windows-Containern wechseln, sodass Sie Module für verschiedene Arten von IoT Edge-Geräten entwickeln können.

Verwenden Sie die Docker-Dokumentation, um Docker auf Ihrem Entwicklungscomputer zu installieren:

Tools für die Einrichtung

Installieren Sie das Python-basierte Azure IoT Edge Dev Tool , um Ihre IoT Edge-Lösung zu erstellen. Sie haben zwei Möglichkeiten:

Wichtig

Die Azure IoT Edge-Tools für die Visual Studio Code-Erweiterung befinden sich im Wartungsmodus. Das bevorzugte Entwicklungstool ist das Befehlszeilentool (CLI) Azure IoT Edge Dev Tool.

Verwenden Sie die IoT-Erweiterungen für Visual Studio Code zum Entwickeln von IoT Edge-Modulen. Diese Erweiterungen bieten Projektvorlagen, automatisieren die Erstellung des Bereitstellungsmanifests und ermöglichen es Ihnen, IoT Edge-Geräte zu überwachen und zu verwalten. In diesem Abschnitt installieren Sie Visual Studio Code und die IoT-Erweiterung und richten dann Ihr Azure-Konto ein, um IoT Hub-Ressourcen über Visual Studio Code zu verwalten.

  1. Installieren Sie die Azure IoT Edge-Erweiterung .

  2. Installieren Sie die Azure IoT Hub-Erweiterung .

  3. Nachdem Sie die Erweiterungen installiert haben, öffnen Sie die Befehlspalette, indem Sie Ansicht>Befehlspalette auswählen.

  4. Suchen Sie in der Befehlspalette nach Azure IoT Hub, und wählen Sie sie aus: Wählen Sie "IoT Hub" aus. Folgen Sie den Aufforderungen, um Ihr Azure-Abonnement und den IoT-Hub auszuwählen.

  5. Öffnen Sie den Explorer-Abschnitt von Visual Studio Code, indem Sie das Symbol in der Aktivitätsleiste auswählen oder "Explorer anzeigen"> auswählen.

  6. Erweitern Sie im Explorer-Bereich unten das zusammengeklappte Azure IoT Hub / Geräte-Menü. Sie sehen die Geräte und IoT Edge-Geräte, die dem IoT Hub zugeordnet sind, den Sie über die Befehlspalette ausgewählt haben.

Installieren von sprachspezifischen Tools

Installieren Sie Tools für die Sprache, in der Sie entwickeln:

Erstellen einer Containerregistrierung

In diesem Lernprogramm verwenden Sie die Azure IoT Edge - und Azure IoT Hub-Erweiterungen , um ein Modul zu erstellen und ein Containerimage aus den Dateien zu erstellen. Anschließend übertragen Sie dieses Image in eine Registrierung , in der Ihre Bilder gespeichert und verwaltet werden. Abschließend stellen Sie Ihr Image aus der Registrierung zur Ausführung auf dem IoT Edge-Gerät bereit.

Wichtig

Die Azure IoT Edge Visual Studio Code-Erweiterung befindet sich im Wartungsmodus.

Sie können eine beliebige Docker-kompatible Registrierung zum Speichern Ihrer Containerimages verwenden. Zwei beliebte Docker-Registrierungsdienste sind Azure Container Registry und Docker Hub. In diesem Tutorial wird Azure Container Registry verwendet.

Sollten Sie noch keine Containerregistrierung besitzen, führen Sie die folgenden Schritte aus, um eine neue Containerregistrierung in Azure zu erstellen:

  1. Wählen Sie im Azure-Portal die Option Erstellen Sie eine Ressource>Container>Containerregistrierung aus.

  2. Geben Sie die folgenden erforderlichen Werte an, um Ihre Containerregistrierung zu erstellen:

    Feld Wert
    Abonnement Wählen Sie ein Abonnement aus der Dropdownliste aus.
    Ressourcengruppe Verwenden Sie dieselbe Ressourcengruppe für alle Testressourcen, die Sie während der IoT Edge-Schnellstarts und -Tutorials erstellen. Beispiel: IoTEdgeResources.
    Registrierungsname Geben Sie einen eindeutigen Namen an.
    Standort Wählen Sie einen Standort in Ihrer Nähe aus.
    Artikelnummer (SKU) Wählen Sie "Einfach" aus.

  3. Wählen Sie Überprüfen + Erstellen und dann Erstellen aus.

  4. Wählen Sie Ihre neue Containerregistrierung im Abschnitt "Ressourcen " der Startseite Ihres Azure-Portals aus, um sie zu öffnen.

  5. Wählen Sie im linken Bereich Ihrer Containerregistrierung Zugriffstasten aus dem Menü unter "Einstellungen" aus.

    Screenshot des Menüstandorts der Zugriffstasten.

  6. Aktivieren Sie den Administratorbenutzer mit der Umschaltfläche, und zeigen Sie den Benutzernamen und das Kennwort für Ihre Containerregistrierung an.

  7. Kopieren Sie die Werte für Anmeldeserver, Benutzername und Kennwort , und speichern Sie sie an einer beliebigen Stelle. Sie verwenden diese Werte in diesem Tutorial, um Zugriff auf die Containerregistrierung zu gewähren.

Erstellen eines neuen Modulprojekts

Die Azure IoT Edge-Erweiterung bietet Projektvorlagen für alle unterstützten IoT Edge-Modulsprachen in Visual Studio Code. Diese Vorlagen enthalten alle Dateien und Codes, die Sie benötigen, um ein funktionierendes Modul bereitzustellen und IoT Edge zu testen, oder sie bieten Ihnen eine Ausgangsbasis, um die Vorlage mit Ihrer eigenen Geschäftslogik anzupassen.

Erstellen einer Projektvorlage

Das IoT Edge Dev Tool vereinfacht die Entwicklung von Azure IoT Edge mit Befehlen, die von Umgebungsvariablen gesteuert werden. Es hilft Ihnen bei den ersten Schritten mit der IoT Edge-Entwicklung mithilfe des IoT Edge Dev Container- und IoT Edge-Lösungsgerüsts, das ein Standardmodul und alle erforderlichen Konfigurationsdateien enthält.

  1. Erstellen Sie ein Verzeichnis für Ihre Lösung auf dem gewünschten Pfad. Wechseln Sie zu Ihrem iotedgesolution Verzeichnis.

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

  2. Verwenden Sie den Befehl "iotedgedev" , um eine Lösung zu erstellen und Ihren Azure IoT Hub in der Entwicklungssprache Ihrer Wahl einzurichten.

    iotedgedev solution init --template csharp

Die Iotedgedev-Lösung init fordert Sie auf, mehrere Schritte auszuführen, darunter:

  • Für Azure authentifizieren
  • Ein Azure-Abonnement auswählen
  • Eine Ressourcengruppe auswählen oder erstellen
  • Einen Azure IoT Hub auswählen oder erstellen
  • Ein Azure IoT Edge-Gerät auswählen oder erstellen

Verwenden Sie Visual Studio Code und die Azure IoT Edge-Erweiterung . Erstellen Sie zunächst eine Lösung, und generieren Sie dann das erste Modul in dieser Lösung. Jede Lösung kann mehrere Module enthalten.

  1. Wählen Sie Ansicht>Befehlspalette aus.
  2. Geben Sie in der Befehlspalette den Befehl Azure IoT Edge: Neue IoT Edge-Lösung ein, und führen Sie ihn aus.
  3. Navigieren Sie zu dem Ordner, in dem Sie die neue Lösung erstellen möchten, und wählen Sie dann "Ordner auswählen" aus.
  4. Geben Sie einen Namen für die Lösung ein.
  5. Wählen Sie als erstes Modul in der Projektmappe eine Modulvorlage für Ihre bevorzugte Entwicklungssprache aus.
  6. Geben Sie einen Namen für Ihr Modul ein. Wählen Sie einen Namen, der in der Containerregistrierung eindeutig ist.
  7. Geben Sie den Namen des Bild-Repositorys des Moduls ein. Visual Studio Code füllt den Modulnamen automatisch mit dem Namen "localhost:5000/<your module"> auf. Ersetzen Sie ihn durch Ihre eigenen Registrierungsinformationen. Verwenden Sie localhost , wenn Sie eine lokale Docker-Registrierung zum Testen verwenden. Wenn Sie azure Container Registry verwenden, verwenden Sie den Anmeldeserver aus den Einstellungen Ihrer Registrierung. Der Anmeldeserver sieht wie <der Registrierungsname.azurecr.io> aus. Ersetzen Sie nur den "localhost:5000" -Teil der Zeichenfolge, sodass das endgültige Ergebnis wie <registrierungsname.azurecr.io/><your modulname> aussieht.

Visual Studio Code verwendet die angegebenen Informationen, erstellt eine IoT Edge-Projektmappe, und lädt diese in einem neuen Fenster.

Nachdem Sie die Lösung erstellt haben, befinden sich diese Hauptdateien in der Lösung:

  • Der VSCODE-Ordner enthält die Konfigurationsdatei launch.json.

  • Der Ordner "Module " enthält Unterordner für jedes Modul. In jedem Unterordner steuert die module.json Datei, wie Module erstellt und bereitgestellt werden.

  • Die env-Datei listet Ihre Umgebungsvariablen auf. Die Umgebungsvariable für die Containerregistrierung ist standardmäßig "localhost:5000" .

  • Zwei Modulbereitstellungsdateien, deployment.template.json und deployment.debug.template.json, listen die Module auf, die auf Ihrem Gerät bereitgestellt werden sollen. Standardmäßig enthält die Liste die IoT Edge-Systemmodule (edgeAgent und edgeHub) und Beispielmodule wie:

    Hinweis

    Die genau installierten Module können von Ihrer Wahlsprache abhängen.

Festlegen der IoT Edge-Runtimeversion

Die neueste stabile IoT Edge-Systemmodulversion ist 1.5. Legen Sie Ihre Systemmodule auf Version 1.5 fest.

  1. Öffnen Sie in Visual Studio Code deployment.template.json Bereitstellungsmanifestdatei. Das Bereitstellungsmanifest ist ein JSON-Dokument, das die Module beschreibt, die auf dem zielbezogenen IoT Edge-Gerät konfiguriert werden sollen.

  2. Ändern Sie die Laufzeitversion für die Systemlaufzeitmodulimages edgeAgent und edgeHub. Wenn Sie beispielsweise die IoT Edge-Runtimeversion 1.5 verwenden möchten, ändern Sie in der Bereitstellungsmanifestdatei die folgenden Zeilen:

    "systemModules": {
    "edgeAgent": {

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

    "edgeHub": {

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

Angeben Ihrer Anmeldeinformationen für die Registrierung über den IoT Edge-Agent

Die Umgebungsdatei speichert die Anmeldeinformationen für Ihre Containerregistrierung und gibt sie an die IoT Edge-Runtime weiter. Die Runtime benötigt diese Anmeldeinformationen, um Ihre Containerimages auf das IoT Edge-Gerät zu pullen.

Die IoT Edge-Erweiterung versucht, Ihre Anmeldeinformationen für die Containerregistrierung per Pullvorgang aus Azure abzurufen und in die Umgebungsdatei einzufügen.

Hinweis

Die Umgebungsdatei wird nur erstellt, wenn Sie ein Imagerepository für das Modul angeben. Wenn Sie die „localhost“-Standardeinstellungen zum lokalen Testen und Debuggen akzeptiert haben, müssen Sie keine Umgebungsvariablen deklarieren.

Überprüfen Sie, ob Ihre Anmeldeinformationen vorhanden sind. Fügen Sie sie jetzt hinzu, wenn dies nicht der Fall ist:

  1. Wenn Azure Container Registry Ihre Registrierung ist, legen Sie dafür einen Benutzernamen und ein Kennwort fest. Rufen Sie diese Werte aus dem Menü Einstellungen>Zugriffsschlüssel der Containerregistrierung im Azure-Portal ab.

  2. Öffnen Sie die env-Datei in Ihrer Modullösung.

  3. Fügen Sie die Benutzernamen - und Kennwortwerte hinzu, die Sie aus Ihrer Azure-Containerregistrierung kopiert haben. Beispiel:

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

  4. Speichern Sie Ihre Änderungen in der env-Datei .

Hinweis

In diesem Lernprogramm werden Administratoranmeldeinformationen für die Azure-Containerregistrierung verwendet, die für Entwicklungs- und Testszenarien geeignet sind. Wenn Sie für Produktionsszenarien bereit sind, empfehlen wir Ihnen, eine Authentifizierungsoption mit den geringstmöglichen Rechten auszuwählen, z. B. Dienstprinzipale oder Token mit Repositorygültigkeitsbereich. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf Ihre Containerregistrierung.

Zielarchitektur

Wählen Sie die Architektur aus, die Sie für jede Lösung verwenden, da sich dies auf die Erstellung und Ausführung des Containers auswirkt. Der Standardwert ist „Linux AMD64“. Verwenden Sie für dieses Lernprogramm einen virtuellen Ubuntu-Computer als IoT Edge-Gerät und behalten Sie den Standard amd64 bei.

Wenn Sie die Zielarchitektur für Ihre Lösung ändern müssen, führen Sie die folgenden Schritte aus.

  1. Öffnen Sie die Befehlspalette und suchen Sie nach Azure IoT Edge: Standardzielplattform für Edge-Lösung festlegen oder wählen Sie das Verknüpfungssymbol in der Randleiste unten im Fenster aus.

  2. Wählen Sie in der Befehlspalette die Zielarchitektur aus der Liste mit Optionen aus.

Die Zielarchitektur wird festgelegt, wenn Sie das Containerimage in einem späteren Schritt erstellen.

Aktualisieren des Moduls mit benutzerdefiniertem Code

Jede Vorlage enthält Beispielcode, der simulierte Sensordaten aus dem SimulatedTemperatureSensor-Modul verwendet und an den IoT Hub weiterleitet. Das Beispielmodul empfängt Nachrichten und übergibt sie. Die Pipelinefunktionalität zeigt ein wichtiges Konzept in IoT Edge: Wie Module miteinander kommunizieren.

Jedes Modul kann mehrere Eingabe- und Ausgabewarteschlangen im Code deklariert haben. Der auf dem Gerät ausgeführte IoT Edge-Hub leitet Nachrichten von der Ausgabe eines Moduls an die Eingabe eines oder mehrerer Module weiter. Der spezifische Code zum Deklarieren von Eingaben und Ausgaben variiert zwischen Sprachen, aber das Konzept ist für alle Module identisch. Weitere Informationen zum Routing zwischen Modulen finden Sie unter Deklarieren von Routen.

Der C#-Beispielcode, der in der Projektvorlage enthalten ist, verwendet die ModuleClient-Klasse aus dem IoT Hub SDK für .NET.

  1. Öffnen Sie im Visual Studio Code-Explorer module>filtermodule>ModuleBackgroundService.cs.

  2. Fügen Sie vor dem Filtermodule-Namespace drei using-Anweisungen für Typen hinzu, die später verwendet werden:

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

  3. Fügen Sie der ModuleBackgroundService-Klasse die Variable "temperatureThreshold" hinzu. Diese Variable legt den Wert fest, den die gemessene Temperatur überschreiten muss, damit die Daten an den IoT Hub gesendet werden.

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

  4. Fügen Sie die Klassen MessageBody, Machine und Ambient hinzu. Diese Klassen definieren das erwartete Schema für den Textkörper eingehender Nachrichten.

    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. Suchen Sie die ExecuteAsync-Funktion . Diese Funktion erstellt und konfiguriert ein ModuleClient-Objekt , mit dem das Modul eine Verbindung mit der lokalen Azure IoT Edge-Laufzeit herstellen kann, um Nachrichten zu senden und zu empfangen. Nach dem Erstellen des ModuleClient liest der Code den Temperaturschwellenwert aus den gewünschten Eigenschaften des Modultwins. Der Code registriert einen Rückruf zum Empfangen von Nachrichten von einem IoT Edge-Hub über einen Endpunkt namens Input1.

    Ersetzen Sie den Aufruf der ProcessMessageAsync-Methode durch eine neue Methode, die den Namen des Endpunkts und die Methode aktualisiert, die beim Eintreffen von Eingaben aufgerufen wird. Fügen Sie außerdem eine SetDesiredPropertyUpdateCallbackAsync-Methode für Aktualisierungen der gewünschten Eigenschaften hinzu. Ersetzen Sie die letzte Zeile der ExecuteAsync-Methode durch den folgenden Code, um diese Änderung vorzunehmen:

    // 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. Fügen Sie der ModuleBackgroundService-Klasse die onDesiredPropertiesUpdate-Methode hinzu. Diese Methode empfängt Aktualisierungen der gewünschten Eigenschaften des Moduls Twin und aktualisiert die Variable "temperatureThreshold " entsprechend. Alle Module haben ihren eigenen Modulzwilling, über den Sie den in einem Modul ausgeführten Code direkt in der Cloud konfigurieren können.

    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. Fügen Sie die FilterMessages-Methode hinzu. Diese Methode wird aufgerufen, wenn das Modul eine Nachricht vom IoT Edge-Hub empfängt. Sie filtert Nachrichten heraus, die Temperaturen unter dem über den Modulzwilling festgelegten Temperaturschwellenwert melden. Außerdem wird der Nachricht die MessageType-Eigenschaft hinzugefügt, wobei der Wert auf "Alert" festgelegt ist.

    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. Speichern Sie die ModuleBackgroundService.cs Datei.

  9. Öffnen Sie im Visual Studio Code-Explorer die deployment.template.json-Datei im IoT Edge-Lösungsarbeitsbereich.

  10. Da wir den Namen des Endpunkts geändert haben, auf dem das Modul lauscht, müssen wir auch die Routen im Bereitstellungsmanifest aktualisieren, damit edgeHub Nachrichten an den neuen Endpunkt sendet.

    Finden Sie den Abschnitt "Routen" im $edgeHub-Modul-Zwilling. Aktualisieren Sie die sensorTofiltermodule-Route, um input1 durch inputFromSensor zu ersetzen.

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

  11. Fügen Sie den Filtermodul-Zwilling zum Bereitstellungsmanifest hinzu. Fügen Sie den folgenden JSON-Inhalt am Ende des Abschnitts modulesContent nach dem $edgeHub Modul-Zwilling ein.

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

  12. Speichern Sie die deployment.template.json Datei.

Erstellen und Pushen Ihrer Projektmappe

Sie haben den Modulcode und die Bereitstellungsvorlage aktualisiert, um sich mit einigen wichtigen Konzepten der Bereitstellung vertraut zu machen. Sie können nun das Modulcontainerimage erstellen und per Push an Ihre Containerregistrierung übertragen.

Öffnen Sie in Visual Studio Code die deployment.template.json Bereitstellungsmanifestdatei. Das Bereitstellungsmanifest beschreibt die Module, die auf dem zielbezogenen IoT Edge-Gerät konfiguriert werden sollen. Vor der Bereitstellung müssen Sie Ihre Azure Container Registry-Anmeldeinformationen und Ihre Modulimages mit den richtigen createOptions-Werten aktualisieren. Weitere Informationen zu createOption-Werten finden Sie unter Konfigurieren von Containererstellungsoptionen für IoT Edge-Module.

Wenn Sie eine Azure Container-Registrierung verwenden, um Ihr Modulimage zu speichern, fügen Sie Ihre Anmeldeinformationen im Abschnitt modulesContent>edgeAgent>settings>registryCredentials in deployment.template.json hinzu. Ersetzen Sie myacr durch Ihren eigenen Registrierungsnamen, und geben Sie Ihr Kennwort und Ihre Anmeldeserveradresse an. Beispiel:

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

Fügen Sie dem Wert createOptions für jedes aufgelistete Systemmodul (edgeHub und edgeAgent) und benutzerdefinierte Modul (filtermodule und tempSensor) den folgenden Zeichenfolgeninhalt hinzu, oder ersetzen Sie ihn. Ändern Sie ggf. die Werte.

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

Die Filtermodule-Konfiguration sollte z. B. ähnlich sein wie:

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

Erstellen des Moduls „Docker-Image“

Öffnen Sie das integrierte Terminal von Visual Studio Code, indem Sie "Terminal>New Terminal" auswählen.

Verwenden Sie den Befehl dotnet publish, um das Containerimage für Linux und die amd64-Architektur zu erstellen. Wechseln Sie in das Filtermodulverzeichnis in Ihrem Projekt und führen Sie den Befehl dotnet publish aus.

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

Derzeit zielt die Iotedgedev-Toolvorlage auf .NET 7.0 ab. Wenn Sie auf eine andere Version von .NET abzielen möchten, können Sie die Datei filtermodule.csproj bearbeiten und die TargetFramework - und PackageReference-Werte ändern. Um z. B. .NET 8.0 als Ziel festzulegen, sollte die Datei "filtermodule.csproj " wie folgt aussehen:

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

Markieren Sie das Docker-Image mit Informationen zur Containerregistrierung sowie der Version und Architektur. Ersetzen Sie myacr durch Ihren eigenen Registrierungsnamen.

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

Pushen des Moduls „Docker-Image“

Geben Sie Ihre Anmeldeinformationen für die Containerregistrierung für Docker an, damit Ihr Containerimage per Pushvorgang übertragen und in der Registrierung gespeichert werden kann.

  1. Melden Sie sich in Docker mit den Anmeldeinformationen für die Azure Container Registry (ACR) an.

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

    Möglicherweise wird Ihnen in einem Sicherheitshinweis die Verwendung von --password-stdin empfohlen. Diese bewährte Methode wird für Produktionsszenarien empfohlen, aber sie ist nicht Gegenstand dieses Tutorials. Weitere Informationen finden Sie in der Docker-Anmeldereferenz .

  2. Melden Sie sich bei Azure Container Registry an. Sie müssen Azure CLI installieren, um den az Befehl zu verwenden. Dieser Befehl fordert Ihren Benutzernamen und Ihr Kennwort an, die Sie in Ihrer Containerregistrierung unter Einstellungen>Zugriffsschlüssel finden.

    az acr login -n <ACR registry name>

    Tipp

    Wenn Sie an irgendeinem Punkt in diesem Tutorial abgemeldet werden, wiederholen Sie die Schritte für die Docker- und Azure Container Registry-Anmeldung, um fortzufahren.

  3. Pushen Sie Ihr Modulimage in die lokale Registrierung oder eine Containerregistrierung.

    docker push <ImageName>

    Beispiel:

    # 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

Aktualisieren der Bereitstellungsvorlage

Aktualisieren Sie in der Bereitstellungsvorlage deployment.template.json den Speicherort des Containerregistrierungsimages. Wenn Sie beispielsweise eine Azure Container Registry myacr.azurecr.io verwenden und Ihr Image filtermodule:0.0.1-amd64 ist, aktualisieren Sie die Filtermodule-Konfiguration auf:

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

Klicken Sie im Visual Studio Code-Explorer mit der rechten Maustaste auf die deployment.template.json Datei, und wählen Sie "IoT Edge-Projektmappe erstellen und pushen" aus.

Der Befehl zum Erstellen und Übertragen per Push startet drei Vorgänge. Zunächst wird ein neuer Ordner in der Lösung namens "config " erstellt, der das vollständige Bereitstellungsmanifest enthält, das aus Informationen in der Bereitstellungsvorlage und anderen Lösungsdateien erstellt wurde. Danach führt er docker build zum Erstellen des Containerimages aus, das auf der entsprechenden Dockerfile-Datei für Ihre Zielarchitektur basiert. Und schließlich führt er docker push aus, um das Imagerepository per Push in Ihre Containerregistrierung zu übertragen.

Dieser Vorgang kann beim ersten Mal einige Minuten dauern, aber er ist bei der nächsten Ausführung von Befehlen schon schneller.

Optional: Aktualisieren Sie das Modul und das Image

Wenn Sie Änderungen am Modulcode vornehmen, müssen Sie das Modulimage neu erstellen und per Push in die Containerregistrierung übertragen. Führen Sie die Schritte in diesem Abschnitt aus, um den Build und das Containerimage zu aktualisieren. Sie können diesen Abschnitt überspringen, wenn Sie keine Änderungen am Modulcode vorgenommen haben.

Öffnen Sie die dateideployment.amd64.json im neu erstellten Konfigurationsordner. Der Dateiname spiegelt die Zielarchitektur wider und weicht daher ab, wenn Sie eine andere Architektur wählen.

Beachten Sie Folgendes: Die beiden Parameter, die über Platzhalter verfügt haben, enthalten jetzt die entsprechenden Werte. Der Abschnitt "registryCredentials " enthält Ihren Registrierungsbenutzernamen und das Kennwort, das aus der env-Datei abgerufen wird. Das Filtermodul verfügt über das vollständige Bild-Repository mit dem Namen, der Version und dem Architekturtag aus der module.json Datei.

  1. Öffnen Sie die module.json Datei im Ordner "filtermodule ".

  2. Ändern Sie die Versionsnummer für das Modulimage. Erhöhen Sie beispielsweise die Patchversionsnummer auf "version": "0.0.2", als ob Sie eine geringfügige Änderung am Modulcode vorgenommen hätten.

    Tipp

    Für Modulversionen kann die Versionskontrolle genutzt werden, und Sie können Änderungen für eine kleine Gruppe mit Geräten testen, bevor Sie Updates für die Produktion bereitstellen. Falls Sie die Modulversion vor dem Erstellen und Pushen nicht inkrementieren, überschreiben Sie das Repository in Ihrer Containerregistrierung.

  3. Speichern Sie Ihre Änderungen in der module.json Datei.

Erstellen und pushen Sie das aktualisierte Image mit einem 0.0.2-Versionstag. Verwenden Sie beispielsweise die folgenden Befehle, um das Image für die lokale Registrierung oder eine Azure-Containerregistrierung zu erstellen und zu pushen:


# 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

Klicken Sie erneut mit der rechten Maustaste auf die deployment.template.json Datei, und wählen Sie dann erneut "Erstellen" und "IoT Edge-Lösung pushen" aus.

Öffnen Sie die deployment.amd64.json Datei erneut. Beachten Sie, dass das Buildsystem keine neue Datei erstellt, wenn Sie den Befehl build and push erneut ausführen. Stattdessen aktualisiert sich dieselbe Datei, um die Änderungen abzubilden. Das Filtermodule-Image verweist jetzt auf die Version 0.0.2 des Containers.

Um weiter zu überprüfen, was der Build- und Pushbefehl getan hat, navigieren Sie zum Azure-Portal , und navigieren Sie zu Ihrer Containerregistrierung.

Wählen Sie in Ihrer Containerregistrierung Repositorys und dann filtermodule aus. Stellen Sie sicher, dass beide Versionen des Images per Pushvorgang an die Registrierung übertragen wurden.

Screenshot des Bereichs, in dem beide Imageversionen in Ihrer Containerregistrierung angezeigt werden.

Problembehandlung

Falls beim Erstellen und Pushen Ihres Modulimages Fehler auftreten, liegt dies häufig an der Docker-Konfiguration auf Ihrem Entwicklungscomputer. Überprüfen Sie für Ihre Konfiguration Folgendes:

  • Haben Sie den Befehl docker login mit den Anmeldeinformationen ausgeführt, die Sie aus Ihrer Containerregistrierung kopiert haben? Hierbei handelt es sich um andere Anmeldeinformationen als für die Anmeldung an Azure.
  • Ist Ihr Containerrepository richtig? Verfügt es über den richtigen Namen für die Containerregistrierung und den richtigen Modulnamen? Öffnen Sie die module.json Datei im Filtermodulordner , um dies zu überprüfen. Der Repositorywert sollte wie <Registrierungsname>.azurecr.io/filtermodule aussehen.
  • Wenn Sie einen anderen Namen als Filtermodule für Ihr Modul verwendet haben, ist dieser Name in der gesamten Lösung konsistent?
  • Entsprechen die auf Ihrem Computer ausgeführten Containertypen den von Ihnen erstellten Containertypen? Dieses Lernprogramm richtet sich an Linux IoT Edge-Geräte, daher sollte Visual Studio Code amd64 oder arm32v7 in der Seitenleiste sagen, und Docker Desktop sollte Linux-Container ausführen.

Bereitstellen von Modulen auf dem Gerät

Sie haben sich vergewissert, dass die Containerimages in Ihrer Containerregistrierung gespeichert sind. Diese können nun also auf einem Gerät bereitgestellt werden. Sorgen Sie dafür, dass Ihr IoT Edge-Gerät ordnungsgemäß ausgeführt wird.

Verwenden Sie den Befehl "IoT Edge Azure CLI-Set-modules" , um die Module im Azure IoT Hub bereitzustellen. Verwenden Sie beispielsweise den folgenden Befehl, um die Module bereitzustellen, die in der deployment.template.json-Datei definiert sind, für den IoT Hub my-iot-hub und das IoT Edge-Gerät my-device. Ersetzen Sie die Werte für Hubname, Geräte-ID und Anmelde-IoT Hub-Verbindungszeichenfolge durch Ihre eigene.

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

Tipp

Suchen Sie ihre IoT Hub-Verbindungszeichenfolge, einschließlich des freigegebenen Zugriffsschlüssels, im Azure-Portal. Wechseln Sie zu Ihren IoT Hub->Sicherheitseinstellungen>Gemeinsam genutzte Zugriffsrichtlinien>iothubowner.

  1. Erweitern Sie im Visual Studio Code-Explorer unter dem Abschnitt "Azure IoT Hub" "Geräte", um Ihre Liste der IoT-Geräte anzuzeigen.

  2. Klicken Sie mit der rechten Maustaste auf das IoT Edge-Gerät, für das Sie bereitstellen möchten, und wählen Sie dann "Bereitstellung für einzelnes Gerät erstellen" aus.

  3. Navigieren Sie im Datei-Explorer in den Konfigurationsordner , und wählen Sie dann die deployment.amd64.json Datei aus.

    Verwenden Sie nicht die Datei deployment.template.json, da sie nicht die Anmeldeinformationen für die Containerregistrierung bzw. die Modulimagewerte enthält. Wenn Sie auf ein Linux ARM32-Gerät abzielen, wird der Name des Bereitstellungsmanifests deployment.arm32v7.json.

  4. Erweitern Sie unter Ihrem Gerät Module , um eine Liste der bereitgestellten und ausgeführten Module anzuzeigen. Klicken Sie auf die Schaltfläche Aktualisieren. Auf Ihrem Gerät sollten die neuen tempSensor- und filtermodule-Module angezeigt werden.

    Es kann einige Minuten dauern, bis die Module beginnen. Die IoT Edge-Laufzeit empfängt das neue Bereitstellungsmanifest, ruft die Modulimages aus der Containerlaufzeit ab und startet dann jedes neue Modul.

Anzeigen von Nachrichten vom Gerät

Der Beispielmodulcode ruft Nachrichten über die Eingabewarteschlange ab und sendet sie über die Ausgabewarteschlange. Das Bereitstellungsmanifest richtet Routen ein, die Nachrichten an Filtermodule von tempSensor senden und dann Nachrichten von filtermodule an IoT Hub weiterleiten. Mit den Azure IoT Edge- und Azure IoT Hub-Erweiterungen können Sie Nachrichten sehen, sobald sie von Ihrem Gerät aus beim IoT Hub ankommen.

  1. Wählen Sie im Visual Studio Code-Explorer das IoT Edge-Gerät aus, das Sie überwachen möchten, und wählen Sie dann "Überwachung des integrierten Ereignisendpunkts starten" aus.

  2. Sehen Sie sich das Ausgabefenster in Visual Studio Code an, um Nachrichten anzuzeigen, die auf Ihrem IoT Hub eingehen.

    Screenshot des Visual Studio Code-Ausgabefensters mit eingehenden Geräte-zu-Cloud-Nachrichten.

Anzeigen von Änderungen auf dem Gerät

Um zu sehen, was auf Ihrem Gerät passiert, verwenden Sie die Befehle in diesem Abschnitt, um die IoT Edge-Runtime und -Module zu untersuchen, die auf Ihrem Gerät ausgeführt werden.

Diese Befehle gelten für Ihr IoT Edge-Gerät, nicht für Ihren Entwicklungscomputer. Wenn Sie einen virtuellen Computer für Ihr IoT Edge-Gerät verwenden, sollten Sie nun die Verbindung dafür herstellen. Wechseln Sie in Azure zur Übersichtsseite des virtuellen Computers, und wählen Sie "Verbinden" aus, um auf die sichere Shellverbindung zuzugreifen.

  • Zeigen Sie alle Module an, die auf Ihrem Gerät bereitgestellt wurden, und überprüfen Sie ihren Status:

    iotedge list

    Es werden vier Module angezeigt: die beiden IoT Edge-Laufzeitmodule tempSensor und Filtermodule. Alle vier sollten als laufend aufgeführt werden.

  • Überprüfen Sie die Protokolle für ein bestimmtes Modul:

    iotedge logs <module name>

    Bei Modulnamen muss die Groß-/Kleinschreibung beachtet werden.

    In den Protokollen von tempSensor und filtermodule werden die verarbeiteten Nachrichten angezeigt. Das EdgeAgent-Modul startet die anderen Module, sodass die Protokolle Informationen zum Bereitstellungsmanifest enthalten. Wenn ein Modul nicht aufgeführt ist oder nicht ausgeführt wird, überprüfen Sie die EdgeAgent-Protokolle auf Fehler. Das EdgeHub-Modul verwaltet die Kommunikation zwischen den Modulen und dem IoT Hub. Wenn die Module ausgeführt werden, nachrichten aber nicht an Ihrem IoT Hub ankommen, überprüfen Sie die EdgeHub-Protokolle auf Fehler.

Bereinigen von Ressourcen

Wenn Sie mit dem nächsten empfohlenen Artikel fortfahren möchten, behalten Sie die von Ihnen erstellten Ressourcen und Konfigurationen bei, und verwenden Sie sie wieder. Sie können auch dasselbe IoT Edge-Gerät als Testgerät weiter nutzen.

Löschen Sie andernfalls die lokalen Konfigurationen und die Azure-Ressourcen, die Sie in diesem Artikel verwendet haben, um Gebühren zu vermeiden.

Löschen von Azure-Ressourcen

Das Löschen von Azure-Ressourcen und -Ressourcengruppen kann nicht rückgängig gemacht werden. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Wenn Sie den IoT Hub in einer vorhandenen Ressourcengruppe erstellt haben, die Ressourcen enthält, die Sie behalten möchten, löschen Sie nur die IoT Hub-Ressource selbst, nicht die Ressourcengruppe.

So löschen Sie die Ressourcen:

  1. Melden Sie sich beim Azure-Portal an, und wählen Sie dann "Ressourcengruppen" aus.

  2. Wählen Sie den Namen der Ressourcengruppe aus, die Ihre IoT Edge-Testressourcen enthält.

  3. Überprüfen Sie die Liste der Ressourcen, die Ihre Ressourcengruppe enthält. Wenn Sie alle löschen möchten, können Sie " Ressourcengruppe löschen" auswählen. Wenn Sie nur einige Ressourcen löschen möchten, wählen Sie die jeweiligen Ressourcen aus, um sie einzeln zu löschen.

Nächste Schritte

In diesem Lernprogramm richten Sie Visual Studio Code auf Ihrem Entwicklungscomputer ein und stellen Ihr erstes IoT Edge-Modul mit Code bereit, der rohe Daten filtert, die von Ihrem IoT Edge-Gerät generiert werden.

Fahren Sie mit den nächsten Lernprogrammen fort, um zu erfahren, wie Azure IoT Edge Ihnen die Bereitstellung von Azure-Clouddiensten zum Verarbeiten und Analysieren von Daten am Edge ermöglicht.

Debuggen von Azure IoT Edge-ModulenFunktionenStream AnalyticsCustom Vision Service